// Copyright 2022 Luca Casonato. All rights reserved. MIT license.
/**
 * Google Meet API Client for Deno
 * ===============================
 * 
 * Create and manage meetings in Google Meet.
 * 
 * Docs: https://developers.google.com/meet/api
 * Source: https://googleapis.deno.dev/v1/meet:v2.ts
 */

import { auth, CredentialsClient, GoogleAuth, request } from "/_/base@v1/mod.ts";
export { auth, GoogleAuth };
export type { CredentialsClient };

/**
 * Create and manage meetings in Google Meet.
 */
export class Meet {
  #client: CredentialsClient | undefined;
  #baseUrl: string;

  constructor(client?: CredentialsClient, baseUrl: string = "https://meet.googleapis.com/") {
    this.#client = client;
    this.#baseUrl = baseUrl;
  }

  /**
   * Gets a conference record by conference ID.
   *
   * @param name Required. Resource name of the conference.
   */
  async conferenceRecordsGet(name: string): Promise<ConferenceRecord> {
    const url = new URL(`${this.#baseUrl}v2/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ConferenceRecord;
  }

  /**
   * Lists the conference records. By default, ordered by start time and in
   * descending order.
   *
   */
  async conferenceRecordsList(opts: ConferenceRecordsListOptions = {}): Promise<ListConferenceRecordsResponse> {
    const url = new URL(`${this.#baseUrl}v2/conferenceRecords`);
    if (opts.filter !== undefined) {
      url.searchParams.append("filter", String(opts.filter));
    }
    if (opts.pageSize !== undefined) {
      url.searchParams.append("pageSize", String(opts.pageSize));
    }
    if (opts.pageToken !== undefined) {
      url.searchParams.append("pageToken", String(opts.pageToken));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ListConferenceRecordsResponse;
  }

  /**
   * Gets a participant by participant ID.
   *
   * @param name Required. Resource name of the participant.
   */
  async conferenceRecordsParticipantsGet(name: string): Promise<Participant> {
    const url = new URL(`${this.#baseUrl}v2/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Participant;
  }

  /**
   * Lists the participants in a conference record. By default, ordered by join
   * time and in descending order. This API supports `fields` as standard
   * parameters like every other API. However, when the `fields` request
   * parameter is omitted, this API defaults to `'participants/*,
   * next_page_token'`.
   *
   * @param parent Required. Format: `conferenceRecords/{conference_record}`
   */
  async conferenceRecordsParticipantsList(parent: string, opts: ConferenceRecordsParticipantsListOptions = {}): Promise<ListParticipantsResponse> {
    const url = new URL(`${this.#baseUrl}v2/${ parent }/participants`);
    if (opts.filter !== undefined) {
      url.searchParams.append("filter", String(opts.filter));
    }
    if (opts.pageSize !== undefined) {
      url.searchParams.append("pageSize", String(opts.pageSize));
    }
    if (opts.pageToken !== undefined) {
      url.searchParams.append("pageToken", String(opts.pageToken));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ListParticipantsResponse;
  }

  /**
   * Gets a participant session by participant session ID.
   *
   * @param name Required. Resource name of the participant.
   */
  async conferenceRecordsParticipantsParticipantSessionsGet(name: string): Promise<ParticipantSession> {
    const url = new URL(`${this.#baseUrl}v2/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ParticipantSession;
  }

  /**
   * Lists the participant sessions of a participant in a conference record. By
   * default, ordered by join time and in descending order. This API supports
   * `fields` as standard parameters like every other API. However, when the
   * `fields` request parameter is omitted this API defaults to
   * `'participantsessions/*, next_page_token'`.
   *
   * @param parent Required. Format: `conferenceRecords/{conference_record}/participants/{participant}`
   */
  async conferenceRecordsParticipantsParticipantSessionsList(parent: string, opts: ConferenceRecordsParticipantsParticipantSessionsListOptions = {}): Promise<ListParticipantSessionsResponse> {
    const url = new URL(`${this.#baseUrl}v2/${ parent }/participantSessions`);
    if (opts.filter !== undefined) {
      url.searchParams.append("filter", String(opts.filter));
    }
    if (opts.pageSize !== undefined) {
      url.searchParams.append("pageSize", String(opts.pageSize));
    }
    if (opts.pageToken !== undefined) {
      url.searchParams.append("pageToken", String(opts.pageToken));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ListParticipantSessionsResponse;
  }

  /**
   * Gets a recording by recording ID.
   *
   * @param name Required. Resource name of the recording.
   */
  async conferenceRecordsRecordingsGet(name: string): Promise<Recording> {
    const url = new URL(`${this.#baseUrl}v2/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Recording;
  }

  /**
   * Lists the recording resources from the conference record. By default,
   * ordered by start time and in ascending order.
   *
   * @param parent Required. Format: `conferenceRecords/{conference_record}`
   */
  async conferenceRecordsRecordingsList(parent: string, opts: ConferenceRecordsRecordingsListOptions = {}): Promise<ListRecordingsResponse> {
    const url = new URL(`${this.#baseUrl}v2/${ parent }/recordings`);
    if (opts.pageSize !== undefined) {
      url.searchParams.append("pageSize", String(opts.pageSize));
    }
    if (opts.pageToken !== undefined) {
      url.searchParams.append("pageToken", String(opts.pageToken));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ListRecordingsResponse;
  }

  /**
   * Gets a `TranscriptEntry` resource by entry ID. Note: The transcript
   * entries returned by the Google Meet API might not match the transcription
   * found in the Google Docs transcript file. This can occur when the Google
   * Docs transcript file is modified after generation.
   *
   * @param name Required. Resource name of the `TranscriptEntry`.
   */
  async conferenceRecordsTranscriptsEntriesGet(name: string): Promise<TranscriptEntry> {
    const url = new URL(`${this.#baseUrl}v2/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as TranscriptEntry;
  }

  /**
   * Lists the structured transcript entries per transcript. By default,
   * ordered by start time and in ascending order. Note: The transcript entries
   * returned by the Google Meet API might not match the transcription found in
   * the Google Docs transcript file. This can occur when the Google Docs
   * transcript file is modified after generation.
   *
   * @param parent Required. Format: `conferenceRecords/{conference_record}/transcripts/{transcript}`
   */
  async conferenceRecordsTranscriptsEntriesList(parent: string, opts: ConferenceRecordsTranscriptsEntriesListOptions = {}): Promise<ListTranscriptEntriesResponse> {
    const url = new URL(`${this.#baseUrl}v2/${ parent }/entries`);
    if (opts.pageSize !== undefined) {
      url.searchParams.append("pageSize", String(opts.pageSize));
    }
    if (opts.pageToken !== undefined) {
      url.searchParams.append("pageToken", String(opts.pageToken));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ListTranscriptEntriesResponse;
  }

  /**
   * Gets a transcript by transcript ID.
   *
   * @param name Required. Resource name of the transcript.
   */
  async conferenceRecordsTranscriptsGet(name: string): Promise<Transcript> {
    const url = new URL(`${this.#baseUrl}v2/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Transcript;
  }

  /**
   * Lists the set of transcripts from the conference record. By default,
   * ordered by start time and in ascending order.
   *
   * @param parent Required. Format: `conferenceRecords/{conference_record}`
   */
  async conferenceRecordsTranscriptsList(parent: string, opts: ConferenceRecordsTranscriptsListOptions = {}): Promise<ListTranscriptsResponse> {
    const url = new URL(`${this.#baseUrl}v2/${ parent }/transcripts`);
    if (opts.pageSize !== undefined) {
      url.searchParams.append("pageSize", String(opts.pageSize));
    }
    if (opts.pageToken !== undefined) {
      url.searchParams.append("pageToken", String(opts.pageToken));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as ListTranscriptsResponse;
  }

  /**
   * Creates a space.
   *
   */
  async spacesCreate(req: Space): Promise<Space> {
    const url = new URL(`${this.#baseUrl}v2/spaces`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Space;
  }

  /**
   * Ends an active conference (if there's one). For an example, see [End
   * active
   * conference](https://developers.google.com/meet/api/guides/meeting-spaces#end-active-conference).
   *
   * @param name Required. Resource name of the space. Format: `spaces/{space}`. `{space}` is the resource identifier for the space. It's a unique, server-generated ID and is case sensitive. For example, `jQCFfuBOdN5z`. For more information, see [How Meet identifies a meeting space](https://developers.google.com/meet/api/guides/meeting-spaces#identify-meeting-space).
   */
  async spacesEndActiveConference(name: string, req: EndActiveConferenceRequest): Promise<Empty> {
    const url = new URL(`${this.#baseUrl}v2/${ name }:endActiveConference`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as Empty;
  }

  /**
   * Gets details about a meeting space. For an example, see [Get a meeting
   * space](https://developers.google.com/meet/api/guides/meeting-spaces#get-meeting-space).
   *
   * @param name Required. Resource name of the space. Format: `spaces/{space}` or `spaces/{meetingCode}`. `{space}` is the resource identifier for the space. It's a unique, server-generated ID and is case sensitive. For example, `jQCFfuBOdN5z`. `{meetingCode}` is an alias for the space. It's a typeable, unique character string and is non-case sensitive. For example, `abc-mnop-xyz`. The maximum length is 128 characters. A `meetingCode` shouldn't be stored long term as it can become dissociated from a meeting space and can be reused for different meeting spaces in the future. Generally, a `meetingCode` expires 365 days after last use. For more information, see [Learn about meeting codes in Google Meet](https://support.google.com/meet/answer/10710509). For more information, see [How Meet identifies a meeting space](https://developers.google.com/meet/api/guides/meeting-spaces#identify-meeting-space).
   */
  async spacesGet(name: string): Promise<Space> {
    const url = new URL(`${this.#baseUrl}v2/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as Space;
  }

  /**
   * Updates details about a meeting space. For an example, see [Update a
   * meeting
   * space](https://developers.google.com/meet/api/guides/meeting-spaces#update-meeting-space).
   *
   * @param name Immutable. Resource name of the space. Format: `spaces/{space}`. `{space}` is the resource identifier for the space. It's a unique, server-generated ID and is case sensitive. For example, `jQCFfuBOdN5z`. For more information, see [How Meet identifies a meeting space](https://developers.google.com/meet/api/guides/meeting-spaces#identify-meeting-space).
   */
  async spacesPatch(name: string, req: Space, opts: SpacesPatchOptions = {}): Promise<Space> {
    opts = serializeSpacesPatchOptions(opts);
    const url = new URL(`${this.#baseUrl}v2/${ name }`);
    if (opts.updateMask !== undefined) {
      url.searchParams.append("updateMask", String(opts.updateMask));
    }
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as Space;
  }
}

/**
 * Active conference.
 */
export interface ActiveConference {
  /**
   * Output only. Reference to 'ConferenceRecord' resource. Format:
   * `conferenceRecords/{conference_record}` where `{conference_record}` is a
   * unique ID for each instance of a call within a space.
   */
  readonly conferenceRecord?: string;
}

/**
 * User who joins anonymously (meaning not signed into a Google Account).
 */
export interface AnonymousUser {
  /**
   * Output only. User provided name when they join a conference anonymously.
   */
  readonly displayName?: string;
}

/**
 * Single instance of a meeting held in a space.
 */
export interface ConferenceRecord {
  /**
   * Output only. Timestamp when the conference ended. Set for past
   * conferences. Unset if the conference is ongoing.
   */
  readonly endTime?: Date;
  /**
   * Output only. Server enforced expiration time for when this conference
   * record resource is deleted. The resource is deleted 30 days after the
   * conference ends.
   */
  readonly expireTime?: Date;
  /**
   * Identifier. Resource name of the conference record. Format:
   * `conferenceRecords/{conference_record}` where `{conference_record}` is a
   * unique ID for each instance of a call within a space.
   */
  name?: string;
  /**
   * Output only. The space where the conference was held.
   */
  readonly space?: string;
  /**
   * Output only. Timestamp when the conference started. Always set.
   */
  readonly startTime?: Date;
}

/**
 * Additional options for Meet#conferenceRecordsList.
 */
export interface ConferenceRecordsListOptions {
  /**
   * Optional. User specified filtering condition in [EBNF
   * format](https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_form).
   * The following are the filterable fields: * `space.meeting_code` *
   * `space.name` * `start_time` * `end_time` For example, consider the
   * following filters: * `space.name = "spaces/NAME"` * `space.meeting_code =
   * "abc-mnop-xyz"` * `start_time>="2024-01-01T00:00:00.000Z" AND
   * start_time<="2024-01-02T00:00:00.000Z"` * `end_time IS NULL`
   */
  filter?: string;
  /**
   * Optional. Maximum number of conference records to return. The service
   * might return fewer than this value. If unspecified, at most 25 conference
   * records are returned. The maximum value is 100; values above 100 are
   * coerced to 100. Maximum might change in the future.
   */
  pageSize?: number;
  /**
   * Optional. Page token returned from previous List Call.
   */
  pageToken?: string;
}

/**
 * Additional options for Meet#conferenceRecordsParticipantsList.
 */
export interface ConferenceRecordsParticipantsListOptions {
  /**
   * Optional. User specified filtering condition in [EBNF
   * format](https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_form).
   * The following are the filterable fields: * `earliest_start_time` *
   * `latest_end_time` For example, `latest_end_time IS NULL` returns active
   * participants in the conference.
   */
  filter?: string;
  /**
   * Maximum number of participants to return. The service might return fewer
   * than this value. If unspecified, at most 100 participants are returned. The
   * maximum value is 250; values above 250 are coerced to 250. Maximum might
   * change in the future.
   */
  pageSize?: number;
  /**
   * Page token returned from previous List Call.
   */
  pageToken?: string;
}

/**
 * Additional options for
 * Meet#conferenceRecordsParticipantsParticipantSessionsList.
 */
export interface ConferenceRecordsParticipantsParticipantSessionsListOptions {
  /**
   * Optional. User specified filtering condition in [EBNF
   * format](https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_form).
   * The following are the filterable fields: * `start_time` * `end_time` For
   * example, `end_time IS NULL` returns active participant sessions in the
   * conference record.
   */
  filter?: string;
  /**
   * Optional. Maximum number of participant sessions to return. The service
   * might return fewer than this value. If unspecified, at most 100
   * participants are returned. The maximum value is 250; values above 250 are
   * coerced to 250. Maximum might change in the future.
   */
  pageSize?: number;
  /**
   * Optional. Page token returned from previous List Call.
   */
  pageToken?: string;
}

/**
 * Additional options for Meet#conferenceRecordsRecordingsList.
 */
export interface ConferenceRecordsRecordingsListOptions {
  /**
   * Maximum number of recordings to return. The service might return fewer
   * than this value. If unspecified, at most 10 recordings are returned. The
   * maximum value is 100; values above 100 are coerced to 100. Maximum might
   * change in the future.
   */
  pageSize?: number;
  /**
   * Page token returned from previous List Call.
   */
  pageToken?: string;
}

/**
 * Additional options for Meet#conferenceRecordsTranscriptsEntriesList.
 */
export interface ConferenceRecordsTranscriptsEntriesListOptions {
  /**
   * Maximum number of entries to return. The service might return fewer than
   * this value. If unspecified, at most 10 entries are returned. The maximum
   * value is 100; values above 100 are coerced to 100. Maximum might change in
   * the future.
   */
  pageSize?: number;
  /**
   * Page token returned from previous List Call.
   */
  pageToken?: string;
}

/**
 * Additional options for Meet#conferenceRecordsTranscriptsList.
 */
export interface ConferenceRecordsTranscriptsListOptions {
  /**
   * Maximum number of transcripts to return. The service might return fewer
   * than this value. If unspecified, at most 10 transcripts are returned. The
   * maximum value is 100; values above 100 are coerced to 100. Maximum might
   * change in the future.
   */
  pageSize?: number;
  /**
   * Page token returned from previous List Call.
   */
  pageToken?: string;
}

/**
 * Google Docs location where the transcript file is saved.
 */
export interface DocsDestination {
  /**
   * Output only. The document ID for the underlying Google Docs transcript
   * file. For example, "1kuceFZohVoCh6FulBHxwy6I15Ogpc4hP". Use the
   * `documents.get` method of the Google Docs API
   * (https://developers.google.com/docs/api/reference/rest/v1/documents/get) to
   * fetch the content.
   */
  readonly document?: string;
  /**
   * Output only. URI for the Google Docs transcript file. Use
   * `https://docs.google.com/document/d/{$DocumentId}/view` to browse the
   * transcript in the browser.
   */
  readonly exportUri?: string;
}

/**
 * Export location where a recording file is saved in Google Drive.
 */
export interface DriveDestination {
  /**
   * Output only. Link used to play back the recording file in the browser. For
   * example, `https://drive.google.com/file/d/{$fileId}/view`.
   */
  readonly exportUri?: string;
  /**
   * Output only. The `fileId` for the underlying MP4 file. For example,
   * "1kuceFZohVoCh6FulBHxwy6I15Ogpc4hP". Use `$ GET
   * https://www.googleapis.com/drive/v3/files/{$fileId}?alt=media` to download
   * the blob. For more information, see
   * https://developers.google.com/drive/api/v3/reference/files/get.
   */
  readonly file?: string;
}

/**
 * A generic empty message that you can re-use to avoid defining duplicated
 * empty messages in your APIs. A typical example is to use it as the request or
 * the response type of an API method. For instance: service Foo { rpc
 * Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }
 */
export interface Empty {
}

/**
 * Request to end an ongoing conference of a space.
 */
export interface EndActiveConferenceRequest {
}

/**
 * Response of ListConferenceRecords method.
 */
export interface ListConferenceRecordsResponse {
  /**
   * List of conferences in one page.
   */
  conferenceRecords?: ConferenceRecord[];
  /**
   * Token to be circulated back for further List call if current List does NOT
   * include all the Conferences. Unset if all conferences have been returned.
   */
  nextPageToken?: string;
}

/**
 * Response of ListParticipants method.
 */
export interface ListParticipantSessionsResponse {
  /**
   * Token to be circulated back for further List call if current List doesn't
   * include all the participants. Unset if all participants are returned.
   */
  nextPageToken?: string;
  /**
   * List of participants in one page.
   */
  participantSessions?: ParticipantSession[];
}

/**
 * Response of ListParticipants method.
 */
export interface ListParticipantsResponse {
  /**
   * Token to be circulated back for further List call if current List doesn't
   * include all the participants. Unset if all participants are returned.
   */
  nextPageToken?: string;
  /**
   * List of participants in one page.
   */
  participants?: Participant[];
  /**
   * Total, exact number of `participants`. By default, this field isn't
   * included in the response. Set the field mask in
   * [SystemParameterContext](https://cloud.google.com/apis/docs/system-parameters)
   * to receive this field in the response.
   */
  totalSize?: number;
}

/**
 * Response for ListRecordings method.
 */
export interface ListRecordingsResponse {
  /**
   * Token to be circulated back for further List call if current List doesn't
   * include all the recordings. Unset if all recordings are returned.
   */
  nextPageToken?: string;
  /**
   * List of recordings in one page.
   */
  recordings?: Recording[];
}

/**
 * Response for ListTranscriptEntries method.
 */
export interface ListTranscriptEntriesResponse {
  /**
   * Token to be circulated back for further List call if current List doesn't
   * include all the transcript entries. Unset if all entries are returned.
   */
  nextPageToken?: string;
  /**
   * List of TranscriptEntries in one page.
   */
  transcriptEntries?: TranscriptEntry[];
}

/**
 * Response for ListTranscripts method.
 */
export interface ListTranscriptsResponse {
  /**
   * Token to be circulated back for further List call if current List doesn't
   * include all the transcripts. Unset if all transcripts are returned.
   */
  nextPageToken?: string;
  /**
   * List of transcripts in one page.
   */
  transcripts?: Transcript[];
}

/**
 * User who attended or is attending a conference.
 */
export interface Participant {
  /**
   * Anonymous user.
   */
  anonymousUser?: AnonymousUser;
  /**
   * Output only. Time when the participant first joined the meeting.
   */
  readonly earliestStartTime?: Date;
  /**
   * Output only. Time when the participant left the meeting for the last time.
   * This can be null if it's an active meeting.
   */
  readonly latestEndTime?: Date;
  /**
   * Output only. Resource name of the participant. Format:
   * `conferenceRecords/{conference_record}/participants/{participant}`
   */
  readonly name?: string;
  /**
   * User calling from their phone.
   */
  phoneUser?: PhoneUser;
  /**
   * Signed-in user.
   */
  signedinUser?: SignedinUser;
}

/**
 * Refers to each unique join or leave session when a user joins a conference
 * from a device. Note that any time a user joins the conference a new unique ID
 * is assigned. That means if a user joins a space multiple times from the same
 * device, they're assigned different IDs, and are also be treated as different
 * participant sessions.
 */
export interface ParticipantSession {
  /**
   * Output only. Timestamp when the user session ends. Unset if the user
   * session hasn’t ended.
   */
  readonly endTime?: Date;
  /**
   * Identifier. Session id.
   */
  name?: string;
  /**
   * Output only. Timestamp when the user session starts.
   */
  readonly startTime?: Date;
}

/**
 * User dialing in from a phone where the user's identity is unknown because
 * they haven't signed in with a Google Account.
 */
export interface PhoneUser {
  /**
   * Output only. Partially redacted user's phone number when calling.
   */
  readonly displayName?: string;
}

/**
 * Metadata about a recording created during a conference.
 */
export interface Recording {
  /**
   * Output only. Recording is saved to Google Drive as an MP4 file. The
   * `drive_destination` includes the Drive `fileId` that can be used to
   * download the file using the `files.get` method of the Drive API.
   */
  readonly driveDestination?: DriveDestination;
  /**
   * Output only. Timestamp when the recording ended.
   */
  readonly endTime?: Date;
  /**
   * Output only. Resource name of the recording. Format:
   * `conferenceRecords/{conference_record}/recordings/{recording}` where
   * `{recording}` is a 1:1 mapping to each unique recording session during the
   * conference.
   */
  readonly name?: string;
  /**
   * Output only. Timestamp when the recording started.
   */
  readonly startTime?: Date;
  /**
   * Output only. Current state.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "STARTED" | "ENDED" | "FILE_GENERATED";
}

/**
 * A signed-in user can be: a) An individual joining from a personal computer,
 * mobile device, or through companion mode. b) A robot account used by
 * conference room devices.
 */
export interface SignedinUser {
  /**
   * Output only. For a personal device, it's the user's first name and last
   * name. For a robot account, it's the administrator-specified device name.
   * For example, "Altostrat Room".
   */
  readonly displayName?: string;
  /**
   * Output only. Unique ID for the user. Interoperable with Admin SDK API and
   * People API. Format: `users/{user}`
   */
  readonly user?: string;
}

/**
 * Virtual place where conferences are held. Only one active conference can be
 * held in one space at any given time.
 */
export interface Space {
  /**
   * Active conference, if it exists.
   */
  activeConference?: ActiveConference;
  /**
   * Configuration pertaining to the meeting space.
   */
  config?: SpaceConfig;
  /**
   * Output only. Type friendly unique string used to join the meeting. Format:
   * `[a-z]+-[a-z]+-[a-z]+`. For example, `abc-mnop-xyz`. The maximum length is
   * 128 characters. Can only be used as an alias of the space name to get the
   * space.
   */
  readonly meetingCode?: string;
  /**
   * Output only. URI used to join meetings consisting of
   * `https://meet.google.com/` followed by the `meeting_code`. For example,
   * `https://meet.google.com/abc-mnop-xyz`.
   */
  readonly meetingUri?: string;
  /**
   * Immutable. Resource name of the space. Format: `spaces/{space}`. `{space}`
   * is the resource identifier for the space. It's a unique, server-generated
   * ID and is case sensitive. For example, `jQCFfuBOdN5z`. For more
   * information, see [How Meet identifies a meeting
   * space](https://developers.google.com/meet/api/guides/meeting-spaces#identify-meeting-space).
   */
  name?: string;
}

/**
 * The configuration pertaining to a meeting space.
 */
export interface SpaceConfig {
  /**
   * Access type of the meeting space that determines who can join without
   * knocking. Default: The user's default access settings. Controlled by the
   * user's admin for enterprise users or RESTRICTED.
   */
  accessType?:  | "ACCESS_TYPE_UNSPECIFIED" | "OPEN" | "TRUSTED" | "RESTRICTED";
  /**
   * Defines the entry points that can be used to join meetings hosted in this
   * meeting space. Default: EntryPointAccess.ALL
   */
  entryPointAccess?:  | "ENTRY_POINT_ACCESS_UNSPECIFIED" | "ALL" | "CREATOR_APP_ONLY";
}

/**
 * Additional options for Meet#spacesPatch.
 */
export interface SpacesPatchOptions {
  /**
   * Optional. Field mask used to specify the fields to be updated in the
   * space. If update_mask isn't provided(not set, set with empty paths, or only
   * has "" as paths), it defaults to update all fields provided with values in
   * the request. Using "*" as update_mask will update all fields, including
   * deleting fields not set in the request.
   */
  updateMask?: string /* FieldMask */;
}

function serializeSpacesPatchOptions(data: any): SpacesPatchOptions {
  return {
    ...data,
    updateMask: data["updateMask"] !== undefined ? data["updateMask"] : undefined,
  };
}

function deserializeSpacesPatchOptions(data: any): SpacesPatchOptions {
  return {
    ...data,
    updateMask: data["updateMask"] !== undefined ? data["updateMask"] : undefined,
  };
}

/**
 * Metadata for a transcript generated from a conference. It refers to the ASR
 * (Automatic Speech Recognition) result of user's speech during the conference.
 */
export interface Transcript {
  /**
   * Output only. Where the Google Docs transcript is saved.
   */
  readonly docsDestination?: DocsDestination;
  /**
   * Output only. Timestamp when the transcript stopped.
   */
  readonly endTime?: Date;
  /**
   * Output only. Resource name of the transcript. Format:
   * `conferenceRecords/{conference_record}/transcripts/{transcript}`, where
   * `{transcript}` is a 1:1 mapping to each unique transcription session of the
   * conference.
   */
  readonly name?: string;
  /**
   * Output only. Timestamp when the transcript started.
   */
  readonly startTime?: Date;
  /**
   * Output only. Current state.
   */
  readonly state?:  | "STATE_UNSPECIFIED" | "STARTED" | "ENDED" | "FILE_GENERATED";
}

/**
 * Single entry for one user’s speech during a transcript session.
 */
export interface TranscriptEntry {
  /**
   * Output only. Timestamp when the transcript entry ended.
   */
  readonly endTime?: Date;
  /**
   * Output only. Language of spoken text, such as "en-US". IETF BCP 47 syntax
   * (https://tools.ietf.org/html/bcp47)
   */
  readonly languageCode?: string;
  /**
   * Output only. Resource name of the entry. Format:
   * "conferenceRecords/{conference_record}/transcripts/{transcript}/entries/{entry}"
   */
  readonly name?: string;
  /**
   * Output only. Refers to the participant who speaks.
   */
  readonly participant?: string;
  /**
   * Output only. Timestamp when the transcript entry started.
   */
  readonly startTime?: Date;
  /**
   * Output only. The transcribed text of the participant's voice, at maximum
   * 10K words. Note that the limit is subject to change.
   */
  readonly text?: string;
}