generated/googleapis/lib/meet/v2.dart

// Copyright 2024 Google LLC
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd

// This is a generated file (see the discoveryapis_generator project).

// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: doc_directive_unknown
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unintended_html_in_doc_comment
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_string_interpolations

/// Google Meet API - v2
///
/// Create and manage meetings in Google Meet.
///
/// For more information, see <https://developers.google.com/workspace/meet/api>
///
/// Create an instance of [MeetApi] to access these resources:
///
/// - [ConferenceRecordsResource]
///   - [ConferenceRecordsParticipantsResource]
///     - [ConferenceRecordsParticipantsParticipantSessionsResource]
///   - [ConferenceRecordsRecordingsResource]
///   - [ConferenceRecordsSmartNotesResource]
///   - [ConferenceRecordsTranscriptsResource]
///     - [ConferenceRecordsTranscriptsEntriesResource]
/// - [SpacesResource]
library;

import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;

import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
import 'package:http/http.dart' as http;

import '../shared.dart';
import '../src/user_agent.dart';

export 'package:_discoveryapis_commons/_discoveryapis_commons.dart'
    show ApiRequestError, DetailedApiRequestError;

/// Create and manage meetings in Google Meet.
class MeetApi {
  /// Create, edit, and see information about your Google Meet conferences
  /// created by the app.
  static const meetingsSpaceCreatedScope =
      'https://www.googleapis.com/auth/meetings.space.created';

  /// Read information about any of your Google Meet conferences
  static const meetingsSpaceReadonlyScope =
      'https://www.googleapis.com/auth/meetings.space.readonly';

  /// Edit, and see settings for all of your Google Meet calls.
  static const meetingsSpaceSettingsScope =
      'https://www.googleapis.com/auth/meetings.space.settings';

  final commons.ApiRequester _requester;

  ConferenceRecordsResource get conferenceRecords =>
      ConferenceRecordsResource(_requester);
  SpacesResource get spaces => SpacesResource(_requester);

  MeetApi(
    http.Client client, {
    core.String rootUrl = 'https://meet.googleapis.com/',
    core.String servicePath = '',
  }) : _requester = commons.ApiRequester(
         client,
         rootUrl,
         servicePath,
         requestHeaders,
       );
}

class ConferenceRecordsResource {
  final commons.ApiRequester _requester;

  ConferenceRecordsParticipantsResource get participants =>
      ConferenceRecordsParticipantsResource(_requester);
  ConferenceRecordsRecordingsResource get recordings =>
      ConferenceRecordsRecordingsResource(_requester);
  ConferenceRecordsSmartNotesResource get smartNotes =>
      ConferenceRecordsSmartNotesResource(_requester);
  ConferenceRecordsTranscriptsResource get transcripts =>
      ConferenceRecordsTranscriptsResource(_requester);

  ConferenceRecordsResource(commons.ApiRequester client) : _requester = client;

  /// Gets a conference record by conference ID.
  ///
  /// Request parameters:
  ///
  /// [name] - Required. Resource name of the conference.
  /// Value must have pattern `^conferenceRecords/\[^/\]+$`.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [ConferenceRecord].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<ConferenceRecord> get(
    core.String name, {
    core.String? $fields,
  }) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$name');

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return ConferenceRecord.fromJson(
      response_ as core.Map<core.String, core.dynamic>,
    );
  }

  /// Lists the conference records.
  ///
  /// By default, ordered by start time and in descending order.
  ///
  /// Request parameters:
  ///
  /// [filter] - 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`
  ///
  /// [pageSize] - 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.
  ///
  /// [pageToken] - Optional. Page token returned from previous List Call.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [ListConferenceRecordsResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<ListConferenceRecordsResponse> list({
    core.String? filter,
    core.int? pageSize,
    core.String? pageToken,
    core.String? $fields,
  }) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'filter': ?filter == null ? null : [filter],
      'pageSize': ?pageSize == null ? null : ['${pageSize}'],
      'pageToken': ?pageToken == null ? null : [pageToken],
      'fields': ?$fields == null ? null : [$fields],
    };

    const url_ = 'v2/conferenceRecords';

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return ListConferenceRecordsResponse.fromJson(
      response_ as core.Map<core.String, core.dynamic>,
    );
  }
}

class ConferenceRecordsParticipantsResource {
  final commons.ApiRequester _requester;

  ConferenceRecordsParticipantsParticipantSessionsResource
  get participantSessions =>
      ConferenceRecordsParticipantsParticipantSessionsResource(_requester);

  ConferenceRecordsParticipantsResource(commons.ApiRequester client)
    : _requester = client;

  /// Gets a participant by participant ID.
  ///
  /// Request parameters:
  ///
  /// [name] - Required. Resource name of the participant.
  /// Value must have pattern
  /// `^conferenceRecords/\[^/\]+/participants/\[^/\]+$`.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [Participant].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<Participant> get(
    core.String name, {
    core.String? $fields,
  }) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$name');

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return Participant.fromJson(
      response_ as core.Map<core.String, core.dynamic>,
    );
  }

  /// 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'`.
  ///
  /// Request parameters:
  ///
  /// [parent] - Required. Format: `conferenceRecords/{conference_record}`
  /// Value must have pattern `^conferenceRecords/\[^/\]+$`.
  ///
  /// [filter] - 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.
  ///
  /// [pageSize] - 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.
  ///
  /// [pageToken] - Page token returned from previous List Call.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [ListParticipantsResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<ListParticipantsResponse> list(
    core.String parent, {
    core.String? filter,
    core.int? pageSize,
    core.String? pageToken,
    core.String? $fields,
  }) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'filter': ?filter == null ? null : [filter],
      'pageSize': ?pageSize == null ? null : ['${pageSize}'],
      'pageToken': ?pageToken == null ? null : [pageToken],
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$parent') + '/participants';

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return ListParticipantsResponse.fromJson(
      response_ as core.Map<core.String, core.dynamic>,
    );
  }
}

class ConferenceRecordsParticipantsParticipantSessionsResource {
  final commons.ApiRequester _requester;

  ConferenceRecordsParticipantsParticipantSessionsResource(
    commons.ApiRequester client,
  ) : _requester = client;

  /// Gets a participant session by participant session ID.
  ///
  /// Request parameters:
  ///
  /// [name] - Required. Resource name of the participant.
  /// Value must have pattern
  /// `^conferenceRecords/\[^/\]+/participants/\[^/\]+/participantSessions/\[^/\]+$`.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [ParticipantSession].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<ParticipantSession> get(
    core.String name, {
    core.String? $fields,
  }) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$name');

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return ParticipantSession.fromJson(
      response_ as core.Map<core.String, core.dynamic>,
    );
  }

  /// 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'`.
  ///
  /// Request parameters:
  ///
  /// [parent] - Required. Format:
  /// `conferenceRecords/{conference_record}/participants/{participant}`
  /// Value must have pattern
  /// `^conferenceRecords/\[^/\]+/participants/\[^/\]+$`.
  ///
  /// [filter] - 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.
  ///
  /// [pageSize] - 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.
  ///
  /// [pageToken] - Optional. Page token returned from previous List Call.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [ListParticipantSessionsResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<ListParticipantSessionsResponse> list(
    core.String parent, {
    core.String? filter,
    core.int? pageSize,
    core.String? pageToken,
    core.String? $fields,
  }) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'filter': ?filter == null ? null : [filter],
      'pageSize': ?pageSize == null ? null : ['${pageSize}'],
      'pageToken': ?pageToken == null ? null : [pageToken],
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ =
        'v2/' + core.Uri.encodeFull('$parent') + '/participantSessions';

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return ListParticipantSessionsResponse.fromJson(
      response_ as core.Map<core.String, core.dynamic>,
    );
  }
}

class ConferenceRecordsRecordingsResource {
  final commons.ApiRequester _requester;

  ConferenceRecordsRecordingsResource(commons.ApiRequester client)
    : _requester = client;

  /// Gets a recording by recording ID.
  ///
  /// Request parameters:
  ///
  /// [name] - Required. Resource name of the recording.
  /// Value must have pattern `^conferenceRecords/\[^/\]+/recordings/\[^/\]+$`.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [Recording].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<Recording> get(core.String name, {core.String? $fields}) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$name');

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return Recording.fromJson(response_ as core.Map<core.String, core.dynamic>);
  }

  /// Lists the recording resources from the conference record.
  ///
  /// By default, ordered by start time and in ascending order.
  ///
  /// Request parameters:
  ///
  /// [parent] - Required. Format: `conferenceRecords/{conference_record}`
  /// Value must have pattern `^conferenceRecords/\[^/\]+$`.
  ///
  /// [pageSize] - 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.
  ///
  /// [pageToken] - Page token returned from previous List Call.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [ListRecordingsResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<ListRecordingsResponse> list(
    core.String parent, {
    core.int? pageSize,
    core.String? pageToken,
    core.String? $fields,
  }) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'pageSize': ?pageSize == null ? null : ['${pageSize}'],
      'pageToken': ?pageToken == null ? null : [pageToken],
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$parent') + '/recordings';

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return ListRecordingsResponse.fromJson(
      response_ as core.Map<core.String, core.dynamic>,
    );
  }
}

class ConferenceRecordsSmartNotesResource {
  final commons.ApiRequester _requester;

  ConferenceRecordsSmartNotesResource(commons.ApiRequester client)
    : _requester = client;

  /// Gets smart notes by smart note ID.
  ///
  /// Request parameters:
  ///
  /// [name] - Required. Resource name of the smart note. Format:
  /// conferenceRecords/{conference_record}/smartNotes/{smart_note}
  /// Value must have pattern `^conferenceRecords/\[^/\]+/smartNotes/\[^/\]+$`.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [SmartNote].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<SmartNote> get(core.String name, {core.String? $fields}) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$name');

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return SmartNote.fromJson(response_ as core.Map<core.String, core.dynamic>);
  }

  /// Lists the set of smart notes from the conference record.
  ///
  /// By default, ordered by start time and in ascending order.
  ///
  /// Request parameters:
  ///
  /// [parent] - Required. Format: `conferenceRecords/{conference_record}`
  /// Value must have pattern `^conferenceRecords/\[^/\]+$`.
  ///
  /// [pageSize] - Optional. Maximum number of smart notes to return. The
  /// service might return fewer than this value. If unspecified, at most 10
  /// smart notes are returned. The maximum value is 100; values above 100 are
  /// coerced to 100. Maximum might change in the future.
  ///
  /// [pageToken] - Optional. Page token returned from previous List Call.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [ListSmartNotesResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<ListSmartNotesResponse> list(
    core.String parent, {
    core.int? pageSize,
    core.String? pageToken,
    core.String? $fields,
  }) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'pageSize': ?pageSize == null ? null : ['${pageSize}'],
      'pageToken': ?pageToken == null ? null : [pageToken],
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$parent') + '/smartNotes';

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return ListSmartNotesResponse.fromJson(
      response_ as core.Map<core.String, core.dynamic>,
    );
  }
}

class ConferenceRecordsTranscriptsResource {
  final commons.ApiRequester _requester;

  ConferenceRecordsTranscriptsEntriesResource get entries =>
      ConferenceRecordsTranscriptsEntriesResource(_requester);

  ConferenceRecordsTranscriptsResource(commons.ApiRequester client)
    : _requester = client;

  /// Gets a transcript by transcript ID.
  ///
  /// Request parameters:
  ///
  /// [name] - Required. Resource name of the transcript.
  /// Value must have pattern `^conferenceRecords/\[^/\]+/transcripts/\[^/\]+$`.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [Transcript].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<Transcript> get(core.String name, {core.String? $fields}) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$name');

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return Transcript.fromJson(
      response_ as core.Map<core.String, core.dynamic>,
    );
  }

  /// Lists the set of transcripts from the conference record.
  ///
  /// By default, ordered by start time and in ascending order.
  ///
  /// Request parameters:
  ///
  /// [parent] - Required. Format: `conferenceRecords/{conference_record}`
  /// Value must have pattern `^conferenceRecords/\[^/\]+$`.
  ///
  /// [pageSize] - 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.
  ///
  /// [pageToken] - Page token returned from previous List Call.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [ListTranscriptsResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<ListTranscriptsResponse> list(
    core.String parent, {
    core.int? pageSize,
    core.String? pageToken,
    core.String? $fields,
  }) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'pageSize': ?pageSize == null ? null : ['${pageSize}'],
      'pageToken': ?pageToken == null ? null : [pageToken],
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$parent') + '/transcripts';

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return ListTranscriptsResponse.fromJson(
      response_ as core.Map<core.String, core.dynamic>,
    );
  }
}

class ConferenceRecordsTranscriptsEntriesResource {
  final commons.ApiRequester _requester;

  ConferenceRecordsTranscriptsEntriesResource(commons.ApiRequester client)
    : _requester = client;

  /// 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 1) we have interleaved speakers within milliseconds, or 2) the
  /// Google Docs transcript file is modified after generation.
  ///
  /// Request parameters:
  ///
  /// [name] - Required. Resource name of the `TranscriptEntry`.
  /// Value must have pattern
  /// `^conferenceRecords/\[^/\]+/transcripts/\[^/\]+/entries/\[^/\]+$`.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [TranscriptEntry].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<TranscriptEntry> get(
    core.String name, {
    core.String? $fields,
  }) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$name');

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return TranscriptEntry.fromJson(
      response_ as core.Map<core.String, core.dynamic>,
    );
  }

  /// 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 1) we have interleaved speakers within milliseconds, or 2) the Google
  /// Docs transcript file is modified after generation.
  ///
  /// Request parameters:
  ///
  /// [parent] - Required. Format:
  /// `conferenceRecords/{conference_record}/transcripts/{transcript}`
  /// Value must have pattern `^conferenceRecords/\[^/\]+/transcripts/\[^/\]+$`.
  ///
  /// [pageSize] - 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.
  ///
  /// [pageToken] - Page token returned from previous List Call.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [ListTranscriptEntriesResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<ListTranscriptEntriesResponse> list(
    core.String parent, {
    core.int? pageSize,
    core.String? pageToken,
    core.String? $fields,
  }) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'pageSize': ?pageSize == null ? null : ['${pageSize}'],
      'pageToken': ?pageToken == null ? null : [pageToken],
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$parent') + '/entries';

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return ListTranscriptEntriesResponse.fromJson(
      response_ as core.Map<core.String, core.dynamic>,
    );
  }
}

class SpacesResource {
  final commons.ApiRequester _requester;

  SpacesResource(commons.ApiRequester client) : _requester = client;

  /// Creates a space.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [Space].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<Space> create(Space request, {core.String? $fields}) async {
    final body_ = convert.json.encode(request);
    final queryParams_ = <core.String, core.List<core.String>>{
      'fields': ?$fields == null ? null : [$fields],
    };

    const url_ = 'v2/spaces';

    final response_ = await _requester.request(
      url_,
      'POST',
      body: body_,
      queryParams: queryParams_,
    );
    return Space.fromJson(response_ as core.Map<core.String, core.dynamic>);
  }

  /// Ends an active conference (if there's one).
  ///
  /// For an example, see
  /// [End active conference](https://developers.google.com/workspace/meet/api/guides/meeting-spaces#end-active-conference).
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [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/workspace/meet/api/guides/meeting-spaces#identify-meeting-space).
  /// Value must have pattern `^spaces/\[^/\]+$`.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [Empty].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<Empty> endActiveConference(
    EndActiveConferenceRequest request,
    core.String name, {
    core.String? $fields,
  }) async {
    final body_ = convert.json.encode(request);
    final queryParams_ = <core.String, core.List<core.String>>{
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$name') + ':endActiveConference';

    final response_ = await _requester.request(
      url_,
      'POST',
      body: body_,
      queryParams: queryParams_,
    );
    return Empty.fromJson(response_ as core.Map<core.String, core.dynamic>);
  }

  /// Gets details about a meeting space.
  ///
  /// For an example, see
  /// [Get a meeting space](https://developers.google.com/workspace/meet/api/guides/meeting-spaces#get-meeting-space).
  ///
  /// Request parameters:
  ///
  /// [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/workspace/meet/api/guides/meeting-spaces#identify-meeting-space).
  /// Value must have pattern `^spaces/\[^/\]+$`.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [Space].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<Space> get(core.String name, {core.String? $fields}) async {
    final queryParams_ = <core.String, core.List<core.String>>{
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$name');

    final response_ = await _requester.request(
      url_,
      'GET',
      queryParams: queryParams_,
    );
    return Space.fromJson(response_ as core.Map<core.String, core.dynamic>);
  }

  /// Updates details about a meeting space.
  ///
  /// For an example, see
  /// [Update a meeting space](https://developers.google.com/workspace/meet/api/guides/meeting-spaces#update-meeting-space).
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [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/workspace/meet/api/guides/meeting-spaces#identify-meeting-space).
  /// Value must have pattern `^spaces/\[^/\]+$`.
  ///
  /// [updateMask] - 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.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [Space].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<Space> patch(
    Space request,
    core.String name, {
    core.String? updateMask,
    core.String? $fields,
  }) async {
    final body_ = convert.json.encode(request);
    final queryParams_ = <core.String, core.List<core.String>>{
      'updateMask': ?updateMask == null ? null : [updateMask],
      'fields': ?$fields == null ? null : [$fields],
    };

    final url_ = 'v2/' + core.Uri.encodeFull('$name');

    final response_ = await _requester.request(
      url_,
      'PATCH',
      body: body_,
      queryParams: queryParams_,
    );
    return Space.fromJson(response_ as core.Map<core.String, core.dynamic>);
  }
}

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

  ActiveConference({this.conferenceRecord});

  ActiveConference.fromJson(core.Map json_)
    : this(conferenceRecord: json_['conferenceRecord'] as core.String?);

  core.Map<core.String, core.dynamic> toJson() {
    final conferenceRecord = this.conferenceRecord;
    return {'conferenceRecord': ?conferenceRecord};
  }
}

/// User who joins anonymously (meaning not signed into a Google Account).
class AnonymousUser {
  /// User provided name when they join a conference anonymously.
  ///
  /// Output only.
  core.String? displayName;

  AnonymousUser({this.displayName});

  AnonymousUser.fromJson(core.Map json_)
    : this(displayName: json_['displayName'] as core.String?);

  core.Map<core.String, core.dynamic> toJson() {
    final displayName = this.displayName;
    return {'displayName': ?displayName};
  }
}

/// Configuration related to meeting artifacts potentially generated by this
/// meeting space.
class ArtifactConfig {
  /// Configuration for recording.
  RecordingConfig? recordingConfig;

  /// Configuration for auto-smart-notes.
  SmartNotesConfig? smartNotesConfig;

  /// Configuration for auto-transcript.
  TranscriptionConfig? transcriptionConfig;

  ArtifactConfig({
    this.recordingConfig,
    this.smartNotesConfig,
    this.transcriptionConfig,
  });

  ArtifactConfig.fromJson(core.Map json_)
    : this(
        recordingConfig: json_.containsKey('recordingConfig')
            ? RecordingConfig.fromJson(
                json_['recordingConfig'] as core.Map<core.String, core.dynamic>,
              )
            : null,
        smartNotesConfig: json_.containsKey('smartNotesConfig')
            ? SmartNotesConfig.fromJson(
                json_['smartNotesConfig']
                    as core.Map<core.String, core.dynamic>,
              )
            : null,
        transcriptionConfig: json_.containsKey('transcriptionConfig')
            ? TranscriptionConfig.fromJson(
                json_['transcriptionConfig']
                    as core.Map<core.String, core.dynamic>,
              )
            : null,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final recordingConfig = this.recordingConfig;
    final smartNotesConfig = this.smartNotesConfig;
    final transcriptionConfig = this.transcriptionConfig;
    return {
      'recordingConfig': ?recordingConfig,
      'smartNotesConfig': ?smartNotesConfig,
      'transcriptionConfig': ?transcriptionConfig,
    };
  }
}

/// Single instance of a meeting held in a space.
class ConferenceRecord {
  /// Timestamp when the conference ended.
  ///
  /// Set for past conferences. Unset if the conference is ongoing.
  ///
  /// Output only.
  core.String? endTime;

  /// Server enforced expiration time for when this conference record resource
  /// is deleted.
  ///
  /// The resource is deleted 30 days after the conference ends.
  ///
  /// Output only.
  core.String? expireTime;

  /// 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.
  core.String? name;

  /// The space where the conference was held.
  ///
  /// Output only.
  core.String? space;

  /// Timestamp when the conference started.
  ///
  /// Always set.
  ///
  /// Output only.
  core.String? startTime;

  ConferenceRecord({
    this.endTime,
    this.expireTime,
    this.name,
    this.space,
    this.startTime,
  });

  ConferenceRecord.fromJson(core.Map json_)
    : this(
        endTime: json_['endTime'] as core.String?,
        expireTime: json_['expireTime'] as core.String?,
        name: json_['name'] as core.String?,
        space: json_['space'] as core.String?,
        startTime: json_['startTime'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final endTime = this.endTime;
    final expireTime = this.expireTime;
    final name = this.name;
    final space = this.space;
    final startTime = this.startTime;
    return {
      'endTime': ?endTime,
      'expireTime': ?expireTime,
      'name': ?name,
      'space': ?space,
      'startTime': ?startTime,
    };
  }
}

/// Google Docs location where the transcript file is saved.
class DocsDestination {
  /// 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.
  ///
  /// Output only.
  core.String? document;

  /// URI for the Google Docs transcript file.
  ///
  /// Use `https://docs.google.com/document/d/{$DocumentId}/view` to browse the
  /// transcript in the browser.
  ///
  /// Output only.
  core.String? exportUri;

  DocsDestination({this.document, this.exportUri});

  DocsDestination.fromJson(core.Map json_)
    : this(
        document: json_['document'] as core.String?,
        exportUri: json_['exportUri'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final document = this.document;
    final exportUri = this.exportUri;
    return {'document': ?document, 'exportUri': ?exportUri};
  }
}

/// Export location where a recording file is saved in Google Drive.
class DriveDestination {
  /// Link used to play back the recording file in the browser.
  ///
  /// For example, `https://drive.google.com/file/d/{$fileId}/view`.
  ///
  /// Output only.
  core.String? exportUri;

  /// 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.
  ///
  /// Output only.
  core.String? file;

  DriveDestination({this.exportUri, this.file});

  DriveDestination.fromJson(core.Map json_)
    : this(
        exportUri: json_['exportUri'] as core.String?,
        file: json_['file'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final exportUri = this.exportUri;
    final file = this.file;
    return {'exportUri': ?exportUri, 'file': ?file};
  }
}

/// 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); }
typedef Empty = $Empty;

/// Request to end an ongoing conference of a space.
typedef EndActiveConferenceRequest = $Empty;

/// Details how to join the conference through a SIP gateway.
class GatewaySipAccess {
  /// The permanent numeric code for manual entry on specially configured
  /// devices.
  core.String? sipAccessCode;

  /// The Session Initiation Protocol (SIP) URI the conference can be reached
  /// through.
  ///
  /// The string is in one of these formats: * "sip:USER_ID@GATEWAY_ADDRESS" *
  /// "sips:USER_ID@GATEWAY_ADDRESS" where USER_ID is the 13-digit universal pin
  /// (with the future option to support using a Meet meeting code as well), and
  /// GATEWAY_ADDRESS is a valid address to be resolved using a DNS SRV lookup,
  /// or a dotted quad.
  core.String? uri;

  GatewaySipAccess({this.sipAccessCode, this.uri});

  GatewaySipAccess.fromJson(core.Map json_)
    : this(
        sipAccessCode: json_['sipAccessCode'] as core.String?,
        uri: json_['uri'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final sipAccessCode = this.sipAccessCode;
    final uri = this.uri;
    return {'sipAccessCode': ?sipAccessCode, 'uri': ?uri};
  }
}

/// Response of ListConferenceRecords method.
class ListConferenceRecordsResponse {
  /// List of conferences in one page.
  core.List<ConferenceRecord>? conferenceRecords;

  /// 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.
  core.String? nextPageToken;

  ListConferenceRecordsResponse({this.conferenceRecords, this.nextPageToken});

  ListConferenceRecordsResponse.fromJson(core.Map json_)
    : this(
        conferenceRecords: (json_['conferenceRecords'] as core.List?)
            ?.map(
              (value) => ConferenceRecord.fromJson(
                value as core.Map<core.String, core.dynamic>,
              ),
            )
            .toList(),
        nextPageToken: json_['nextPageToken'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final conferenceRecords = this.conferenceRecords;
    final nextPageToken = this.nextPageToken;
    return {
      'conferenceRecords': ?conferenceRecords,
      'nextPageToken': ?nextPageToken,
    };
  }
}

/// Response of ListParticipants method.
class 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.
  core.String? nextPageToken;

  /// List of participants in one page.
  core.List<ParticipantSession>? participantSessions;

  ListParticipantSessionsResponse({
    this.nextPageToken,
    this.participantSessions,
  });

  ListParticipantSessionsResponse.fromJson(core.Map json_)
    : this(
        nextPageToken: json_['nextPageToken'] as core.String?,
        participantSessions: (json_['participantSessions'] as core.List?)
            ?.map(
              (value) => ParticipantSession.fromJson(
                value as core.Map<core.String, core.dynamic>,
              ),
            )
            .toList(),
      );

  core.Map<core.String, core.dynamic> toJson() {
    final nextPageToken = this.nextPageToken;
    final participantSessions = this.participantSessions;
    return {
      'nextPageToken': ?nextPageToken,
      'participantSessions': ?participantSessions,
    };
  }
}

/// Response of ListParticipants method.
class 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.
  core.String? nextPageToken;

  /// List of participants in one page.
  core.List<Participant>? participants;

  /// 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.
  core.int? totalSize;

  ListParticipantsResponse({
    this.nextPageToken,
    this.participants,
    this.totalSize,
  });

  ListParticipantsResponse.fromJson(core.Map json_)
    : this(
        nextPageToken: json_['nextPageToken'] as core.String?,
        participants: (json_['participants'] as core.List?)
            ?.map(
              (value) => Participant.fromJson(
                value as core.Map<core.String, core.dynamic>,
              ),
            )
            .toList(),
        totalSize: json_['totalSize'] as core.int?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final nextPageToken = this.nextPageToken;
    final participants = this.participants;
    final totalSize = this.totalSize;
    return {
      'nextPageToken': ?nextPageToken,
      'participants': ?participants,
      'totalSize': ?totalSize,
    };
  }
}

/// Response for ListRecordings method.
class 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.
  core.String? nextPageToken;

  /// List of recordings in one page.
  core.List<Recording>? recordings;

  ListRecordingsResponse({this.nextPageToken, this.recordings});

  ListRecordingsResponse.fromJson(core.Map json_)
    : this(
        nextPageToken: json_['nextPageToken'] as core.String?,
        recordings: (json_['recordings'] as core.List?)
            ?.map(
              (value) => Recording.fromJson(
                value as core.Map<core.String, core.dynamic>,
              ),
            )
            .toList(),
      );

  core.Map<core.String, core.dynamic> toJson() {
    final nextPageToken = this.nextPageToken;
    final recordings = this.recordings;
    return {'nextPageToken': ?nextPageToken, 'recordings': ?recordings};
  }
}

/// Response for ListSmartNotes method.
class ListSmartNotesResponse {
  /// Token to be circulated back for further List call if current List doesn't
  /// include all the smart notes.
  ///
  /// Unset if all smart notes are returned.
  core.String? nextPageToken;

  /// List of smart notes in one page.
  core.List<SmartNote>? smartNotes;

  ListSmartNotesResponse({this.nextPageToken, this.smartNotes});

  ListSmartNotesResponse.fromJson(core.Map json_)
    : this(
        nextPageToken: json_['nextPageToken'] as core.String?,
        smartNotes: (json_['smartNotes'] as core.List?)
            ?.map(
              (value) => SmartNote.fromJson(
                value as core.Map<core.String, core.dynamic>,
              ),
            )
            .toList(),
      );

  core.Map<core.String, core.dynamic> toJson() {
    final nextPageToken = this.nextPageToken;
    final smartNotes = this.smartNotes;
    return {'nextPageToken': ?nextPageToken, 'smartNotes': ?smartNotes};
  }
}

/// Response for ListTranscriptEntries method.
class 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.
  core.String? nextPageToken;

  /// List of TranscriptEntries in one page.
  core.List<TranscriptEntry>? transcriptEntries;

  ListTranscriptEntriesResponse({this.nextPageToken, this.transcriptEntries});

  ListTranscriptEntriesResponse.fromJson(core.Map json_)
    : this(
        nextPageToken: json_['nextPageToken'] as core.String?,
        transcriptEntries: (json_['transcriptEntries'] as core.List?)
            ?.map(
              (value) => TranscriptEntry.fromJson(
                value as core.Map<core.String, core.dynamic>,
              ),
            )
            .toList(),
      );

  core.Map<core.String, core.dynamic> toJson() {
    final nextPageToken = this.nextPageToken;
    final transcriptEntries = this.transcriptEntries;
    return {
      'nextPageToken': ?nextPageToken,
      'transcriptEntries': ?transcriptEntries,
    };
  }
}

/// Response for ListTranscripts method.
class 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.
  core.String? nextPageToken;

  /// List of transcripts in one page.
  core.List<Transcript>? transcripts;

  ListTranscriptsResponse({this.nextPageToken, this.transcripts});

  ListTranscriptsResponse.fromJson(core.Map json_)
    : this(
        nextPageToken: json_['nextPageToken'] as core.String?,
        transcripts: (json_['transcripts'] as core.List?)
            ?.map(
              (value) => Transcript.fromJson(
                value as core.Map<core.String, core.dynamic>,
              ),
            )
            .toList(),
      );

  core.Map<core.String, core.dynamic> toJson() {
    final nextPageToken = this.nextPageToken;
    final transcripts = this.transcripts;
    return {'nextPageToken': ?nextPageToken, 'transcripts': ?transcripts};
  }
}

/// Defines restrictions for features when the meeting is moderated.
class ModerationRestrictions {
  /// Defines who has permission to send chat messages in the meeting space.
  /// Possible string values are:
  /// - "RESTRICTION_TYPE_UNSPECIFIED" : Default value specified by user policy.
  /// This should never be returned.
  /// - "HOSTS_ONLY" : Meeting owner and co-host have the permission.
  /// - "NO_RESTRICTION" : All Participants have permissions.
  core.String? chatRestriction;

  /// Defines whether to restrict the default role assigned to users as viewer.
  /// Possible string values are:
  /// - "DEFAULT_JOIN_AS_VIEWER_TYPE_UNSPECIFIED" : Default value specified by
  /// user policy. This should never be returned.
  /// - "ON" : Users will by default join as viewers.
  /// - "OFF" : Users will by default join as contributors.
  core.String? defaultJoinAsViewerType;

  /// Defines who has permission to share their screen in the meeting space.
  /// Possible string values are:
  /// - "RESTRICTION_TYPE_UNSPECIFIED" : Default value specified by user policy.
  /// This should never be returned.
  /// - "HOSTS_ONLY" : Meeting owner and co-host have the permission.
  /// - "NO_RESTRICTION" : All Participants have permissions.
  core.String? presentRestriction;

  /// Defines who has permission to send reactions in the meeting space.
  /// Possible string values are:
  /// - "RESTRICTION_TYPE_UNSPECIFIED" : Default value specified by user policy.
  /// This should never be returned.
  /// - "HOSTS_ONLY" : Meeting owner and co-host have the permission.
  /// - "NO_RESTRICTION" : All Participants have permissions.
  core.String? reactionRestriction;

  ModerationRestrictions({
    this.chatRestriction,
    this.defaultJoinAsViewerType,
    this.presentRestriction,
    this.reactionRestriction,
  });

  ModerationRestrictions.fromJson(core.Map json_)
    : this(
        chatRestriction: json_['chatRestriction'] as core.String?,
        defaultJoinAsViewerType:
            json_['defaultJoinAsViewerType'] as core.String?,
        presentRestriction: json_['presentRestriction'] as core.String?,
        reactionRestriction: json_['reactionRestriction'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final chatRestriction = this.chatRestriction;
    final defaultJoinAsViewerType = this.defaultJoinAsViewerType;
    final presentRestriction = this.presentRestriction;
    final reactionRestriction = this.reactionRestriction;
    return {
      'chatRestriction': ?chatRestriction,
      'defaultJoinAsViewerType': ?defaultJoinAsViewerType,
      'presentRestriction': ?presentRestriction,
      'reactionRestriction': ?reactionRestriction,
    };
  }
}

/// User who attended or is attending a conference.
class Participant {
  /// Anonymous user.
  AnonymousUser? anonymousUser;

  /// Time when the participant first joined the meeting.
  ///
  /// Output only.
  core.String? earliestStartTime;

  /// Time when the participant left the meeting for the last time.
  ///
  /// This can be null if it's an active meeting.
  ///
  /// Output only.
  core.String? latestEndTime;

  /// Resource name of the participant.
  ///
  /// Format: `conferenceRecords/{conference_record}/participants/{participant}`
  ///
  /// Output only.
  core.String? name;

  /// User calling from their phone.
  PhoneUser? phoneUser;

  /// Signed-in user.
  SignedinUser? signedinUser;

  Participant({
    this.anonymousUser,
    this.earliestStartTime,
    this.latestEndTime,
    this.name,
    this.phoneUser,
    this.signedinUser,
  });

  Participant.fromJson(core.Map json_)
    : this(
        anonymousUser: json_.containsKey('anonymousUser')
            ? AnonymousUser.fromJson(
                json_['anonymousUser'] as core.Map<core.String, core.dynamic>,
              )
            : null,
        earliestStartTime: json_['earliestStartTime'] as core.String?,
        latestEndTime: json_['latestEndTime'] as core.String?,
        name: json_['name'] as core.String?,
        phoneUser: json_.containsKey('phoneUser')
            ? PhoneUser.fromJson(
                json_['phoneUser'] as core.Map<core.String, core.dynamic>,
              )
            : null,
        signedinUser: json_.containsKey('signedinUser')
            ? SignedinUser.fromJson(
                json_['signedinUser'] as core.Map<core.String, core.dynamic>,
              )
            : null,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final anonymousUser = this.anonymousUser;
    final earliestStartTime = this.earliestStartTime;
    final latestEndTime = this.latestEndTime;
    final name = this.name;
    final phoneUser = this.phoneUser;
    final signedinUser = this.signedinUser;
    return {
      'anonymousUser': ?anonymousUser,
      'earliestStartTime': ?earliestStartTime,
      'latestEndTime': ?latestEndTime,
      'name': ?name,
      'phoneUser': ?phoneUser,
      '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.
class ParticipantSession {
  /// Timestamp when the user session ends.
  ///
  /// Unset if the user session hasn’t ended.
  ///
  /// Output only.
  core.String? endTime;

  /// Identifier.
  ///
  /// Session id.
  core.String? name;

  /// Timestamp when the user session starts.
  ///
  /// Output only.
  core.String? startTime;

  ParticipantSession({this.endTime, this.name, this.startTime});

  ParticipantSession.fromJson(core.Map json_)
    : this(
        endTime: json_['endTime'] as core.String?,
        name: json_['name'] as core.String?,
        startTime: json_['startTime'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final endTime = this.endTime;
    final name = this.name;
    final startTime = this.startTime;
    return {'endTime': ?endTime, 'name': ?name, 'startTime': ?startTime};
  }
}

/// Phone access contains information required to dial into a conference using a
/// regional phone number and a PIN that is specific to that phone number.
class PhoneAccess {
  /// The BCP 47/LDML language code for the language associated with this phone
  /// access.
  ///
  /// To be parsed by the i18n LanguageCode utility. Examples: "es-419" for
  /// Latin American Spanish, "fr-CA" for Canadian French.
  core.String? languageCode;

  /// The phone number to dial for this meeting space in E.164 format.
  ///
  /// Full phone number with a leading '+' character.
  core.String? phoneNumber;

  /// The PIN that users must enter after dialing the given number.
  ///
  /// The PIN consists of only decimal digits and the length may vary.
  core.String? pin;

  /// The CLDR/ISO 3166 region code for the country associated with this phone
  /// access.
  ///
  /// To be parsed by the i18n RegionCode utility. Example: "SE" for Sweden.
  core.String? regionCode;

  PhoneAccess({this.languageCode, this.phoneNumber, this.pin, this.regionCode});

  PhoneAccess.fromJson(core.Map json_)
    : this(
        languageCode: json_['languageCode'] as core.String?,
        phoneNumber: json_['phoneNumber'] as core.String?,
        pin: json_['pin'] as core.String?,
        regionCode: json_['regionCode'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final languageCode = this.languageCode;
    final phoneNumber = this.phoneNumber;
    final pin = this.pin;
    final regionCode = this.regionCode;
    return {
      'languageCode': ?languageCode,
      'phoneNumber': ?phoneNumber,
      'pin': ?pin,
      'regionCode': ?regionCode,
    };
  }
}

/// User dialing in from a phone where the user's identity is unknown because
/// they haven't signed in with a Google Account.
class PhoneUser {
  /// Partially redacted user's phone number when calling.
  ///
  /// Output only.
  core.String? displayName;

  PhoneUser({this.displayName});

  PhoneUser.fromJson(core.Map json_)
    : this(displayName: json_['displayName'] as core.String?);

  core.Map<core.String, core.dynamic> toJson() {
    final displayName = this.displayName;
    return {'displayName': ?displayName};
  }
}

/// Metadata about a recording created during a conference.
class Recording {
  /// 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.
  ///
  /// Output only.
  DriveDestination? driveDestination;

  /// Timestamp when the recording ended.
  ///
  /// Output only.
  core.String? endTime;

  /// 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.
  ///
  /// Output only.
  core.String? name;

  /// Timestamp when the recording started.
  ///
  /// Output only.
  core.String? startTime;

  /// Current state.
  ///
  /// Output only.
  /// Possible string values are:
  /// - "STATE_UNSPECIFIED" : Default, never used.
  /// - "STARTED" : An active recording session has started.
  /// - "ENDED" : This recording session has ended, but the recording file
  /// hasn't been generated yet.
  /// - "FILE_GENERATED" : Recording file is generated and ready to download.
  core.String? state;

  Recording({
    this.driveDestination,
    this.endTime,
    this.name,
    this.startTime,
    this.state,
  });

  Recording.fromJson(core.Map json_)
    : this(
        driveDestination: json_.containsKey('driveDestination')
            ? DriveDestination.fromJson(
                json_['driveDestination']
                    as core.Map<core.String, core.dynamic>,
              )
            : null,
        endTime: json_['endTime'] as core.String?,
        name: json_['name'] as core.String?,
        startTime: json_['startTime'] as core.String?,
        state: json_['state'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final driveDestination = this.driveDestination;
    final endTime = this.endTime;
    final name = this.name;
    final startTime = this.startTime;
    final state = this.state;
    return {
      'driveDestination': ?driveDestination,
      'endTime': ?endTime,
      'name': ?name,
      'startTime': ?startTime,
      'state': ?state,
    };
  }
}

/// Configuration related to recording in a meeting space.
class RecordingConfig {
  /// Defines whether a meeting space is automatically recorded when someone
  /// with the privilege to record joins the meeting.
  /// Possible string values are:
  /// - "AUTO_GENERATION_TYPE_UNSPECIFIED" : Default value specified by user
  /// policy. This should never be returned.
  /// - "ON" : The artifact is generated automatically.
  /// - "OFF" : The artifact is not generated automatically.
  core.String? autoRecordingGeneration;

  RecordingConfig({this.autoRecordingGeneration});

  RecordingConfig.fromJson(core.Map json_)
    : this(
        autoRecordingGeneration:
            json_['autoRecordingGeneration'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final autoRecordingGeneration = this.autoRecordingGeneration;
    return {'autoRecordingGeneration': ?autoRecordingGeneration};
  }
}

/// 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.
class SignedinUser {
  /// 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".
  ///
  /// Output only.
  core.String? displayName;

  /// Unique ID for the user.
  ///
  /// Interoperable with Admin SDK API and People API. Format: `users/{user}`
  ///
  /// Output only.
  core.String? user;

  SignedinUser({this.displayName, this.user});

  SignedinUser.fromJson(core.Map json_)
    : this(
        displayName: json_['displayName'] as core.String?,
        user: json_['user'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final displayName = this.displayName;
    final user = this.user;
    return {'displayName': ?displayName, 'user': ?user};
  }
}

/// Metadata for a smart note generated from a conference.
///
/// It refers to the notes generated from Take Notes with Gemini during the
/// conference.
class SmartNote {
  /// The Google Doc destination where the smart notes are saved.
  ///
  /// Output only.
  DocsDestination? docsDestination;

  /// Timestamp when the smart notes stopped.
  ///
  /// Output only.
  core.String? endTime;

  /// Identifier.
  ///
  /// Resource name of the smart notes. Format:
  /// `conferenceRecords/{conference_record}/smartNotes/{smart_note}`, where
  /// `{smart_note}` is a 1:1 mapping to each unique smart notes session of the
  /// conference.
  ///
  /// Output only.
  core.String? name;

  /// Timestamp when the smart notes started.
  ///
  /// Output only.
  core.String? startTime;

  /// Current state.
  ///
  /// Output only.
  /// Possible string values are:
  /// - "STATE_UNSPECIFIED" : Default, never used.
  /// - "STARTED" : An active smart notes session has started.
  /// - "ENDED" : This smart notes session has ended, but the smart notes file
  /// hasn't been generated yet.
  /// - "FILE_GENERATED" : Smart notes file is generated and ready to download.
  core.String? state;

  SmartNote({
    this.docsDestination,
    this.endTime,
    this.name,
    this.startTime,
    this.state,
  });

  SmartNote.fromJson(core.Map json_)
    : this(
        docsDestination: json_.containsKey('docsDestination')
            ? DocsDestination.fromJson(
                json_['docsDestination'] as core.Map<core.String, core.dynamic>,
              )
            : null,
        endTime: json_['endTime'] as core.String?,
        name: json_['name'] as core.String?,
        startTime: json_['startTime'] as core.String?,
        state: json_['state'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final docsDestination = this.docsDestination;
    final endTime = this.endTime;
    final name = this.name;
    final startTime = this.startTime;
    final state = this.state;
    return {
      'docsDestination': ?docsDestination,
      'endTime': ?endTime,
      'name': ?name,
      'startTime': ?startTime,
      'state': ?state,
    };
  }
}

/// Configuration related to smart notes in a meeting space.
///
/// For more information about smart notes, see \["Take notes for me" in Google
/// Meet\](https://support.google.com/meet/answer/14754931).
class SmartNotesConfig {
  /// Defines whether to automatically generate a summary and recap of the
  /// meeting for all invitees in the organization when someone with the
  /// privilege to enable smart notes joins the meeting.
  /// Possible string values are:
  /// - "AUTO_GENERATION_TYPE_UNSPECIFIED" : Default value specified by user
  /// policy. This should never be returned.
  /// - "ON" : The artifact is generated automatically.
  /// - "OFF" : The artifact is not generated automatically.
  core.String? autoSmartNotesGeneration;

  SmartNotesConfig({this.autoSmartNotesGeneration});

  SmartNotesConfig.fromJson(core.Map json_)
    : this(
        autoSmartNotesGeneration:
            json_['autoSmartNotesGeneration'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final autoSmartNotesGeneration = this.autoSmartNotesGeneration;
    return {'autoSmartNotesGeneration': ?autoSmartNotesGeneration};
  }
}

/// Virtual place where conferences are held.
///
/// Only one active conference can be held in one space at any given time.
class Space {
  /// Active conference, if it exists.
  ActiveConference? activeConference;

  /// Configuration pertaining to the meeting space.
  SpaceConfig? config;

  /// The SIP-based access methods that can be used to join the conference.
  ///
  /// Can be empty.
  ///
  /// Output only.
  core.List<GatewaySipAccess>? gatewaySipAccess;

  /// 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.
  ///
  /// Output only.
  core.String? meetingCode;

  /// 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`.
  ///
  /// Output only.
  core.String? meetingUri;

  /// 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/workspace/meet/api/guides/meeting-spaces#identify-meeting-space).
  ///
  /// Immutable.
  core.String? name;

  /// All regional phone access methods for this meeting space.
  ///
  /// Can be empty.
  ///
  /// Output only.
  core.List<PhoneAccess>? phoneAccess;

  Space({
    this.activeConference,
    this.config,
    this.gatewaySipAccess,
    this.meetingCode,
    this.meetingUri,
    this.name,
    this.phoneAccess,
  });

  Space.fromJson(core.Map json_)
    : this(
        activeConference: json_.containsKey('activeConference')
            ? ActiveConference.fromJson(
                json_['activeConference']
                    as core.Map<core.String, core.dynamic>,
              )
            : null,
        config: json_.containsKey('config')
            ? SpaceConfig.fromJson(
                json_['config'] as core.Map<core.String, core.dynamic>,
              )
            : null,
        gatewaySipAccess: (json_['gatewaySipAccess'] as core.List?)
            ?.map(
              (value) => GatewaySipAccess.fromJson(
                value as core.Map<core.String, core.dynamic>,
              ),
            )
            .toList(),
        meetingCode: json_['meetingCode'] as core.String?,
        meetingUri: json_['meetingUri'] as core.String?,
        name: json_['name'] as core.String?,
        phoneAccess: (json_['phoneAccess'] as core.List?)
            ?.map(
              (value) => PhoneAccess.fromJson(
                value as core.Map<core.String, core.dynamic>,
              ),
            )
            .toList(),
      );

  core.Map<core.String, core.dynamic> toJson() {
    final activeConference = this.activeConference;
    final config = this.config;
    final gatewaySipAccess = this.gatewaySipAccess;
    final meetingCode = this.meetingCode;
    final meetingUri = this.meetingUri;
    final name = this.name;
    final phoneAccess = this.phoneAccess;
    return {
      'activeConference': ?activeConference,
      'config': ?config,
      'gatewaySipAccess': ?gatewaySipAccess,
      'meetingCode': ?meetingCode,
      'meetingUri': ?meetingUri,
      'name': ?name,
      'phoneAccess': ?phoneAccess,
    };
  }
}

/// The configuration pertaining to a meeting space.
class 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.
  /// Possible string values are:
  /// - "ACCESS_TYPE_UNSPECIFIED" : Default value specified by the user's
  /// organization. Note: This is never returned, as the configured access type
  /// is returned instead.
  /// - "OPEN" : Anyone with the join information (for example, the URL or phone
  /// access information) can join without knocking.
  /// - "TRUSTED" : Members of the host's organization, invited external users,
  /// and dial-in users can join without knocking. Everyone else must knock.
  /// - "RESTRICTED" : Only invitees can join without knocking. Everyone else
  /// must knock.
  core.String? accessType;

  /// Configuration pertaining to the auto-generated artifacts that the meeting
  /// supports.
  ArtifactConfig? artifactConfig;

  /// Whether attendance report is enabled for the meeting space.
  /// Possible string values are:
  /// - "ATTENDANCE_REPORT_GENERATION_TYPE_UNSPECIFIED" : Default value
  /// specified by user policy. This should never be returned.
  /// - "GENERATE_REPORT" : Attendance report will be generated and sent to
  /// drive/email.
  /// - "DO_NOT_GENERATE" : Attendance report will not be generated.
  core.String? attendanceReportGenerationType;

  /// Defines the entry points that can be used to join meetings hosted in this
  /// meeting space.
  ///
  /// Default: EntryPointAccess.ALL
  /// Possible string values are:
  /// - "ENTRY_POINT_ACCESS_UNSPECIFIED" : Unused.
  /// - "ALL" : All entry points are allowed.
  /// - "CREATOR_APP_ONLY" : Only entry points owned by the Google Cloud project
  /// that created the space can be used to join meetings in this space. Apps
  /// can use the Meet Embed SDK Web or mobile Meet SDKs to create owned entry
  /// points.
  core.String? entryPointAccess;

  /// The pre-configured moderation mode for the Meeting.
  ///
  /// Default: Controlled by the user's policies.
  /// Possible string values are:
  /// - "MODERATION_UNSPECIFIED" : Moderation type is not specified. This is
  /// used to indicate the user hasn't specified any value as the user does not
  /// intend to update the state. Users are not allowed to set the value as
  /// unspecified.
  /// - "OFF" : Moderation is off.
  /// - "ON" : Moderation is on.
  core.String? moderation;

  /// When moderation.ON, these restrictions go into effect for the meeting.
  ///
  /// When moderation.OFF, will be reset to default ModerationRestrictions.
  ModerationRestrictions? moderationRestrictions;

  SpaceConfig({
    this.accessType,
    this.artifactConfig,
    this.attendanceReportGenerationType,
    this.entryPointAccess,
    this.moderation,
    this.moderationRestrictions,
  });

  SpaceConfig.fromJson(core.Map json_)
    : this(
        accessType: json_['accessType'] as core.String?,
        artifactConfig: json_.containsKey('artifactConfig')
            ? ArtifactConfig.fromJson(
                json_['artifactConfig'] as core.Map<core.String, core.dynamic>,
              )
            : null,
        attendanceReportGenerationType:
            json_['attendanceReportGenerationType'] as core.String?,
        entryPointAccess: json_['entryPointAccess'] as core.String?,
        moderation: json_['moderation'] as core.String?,
        moderationRestrictions: json_.containsKey('moderationRestrictions')
            ? ModerationRestrictions.fromJson(
                json_['moderationRestrictions']
                    as core.Map<core.String, core.dynamic>,
              )
            : null,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final accessType = this.accessType;
    final artifactConfig = this.artifactConfig;
    final attendanceReportGenerationType = this.attendanceReportGenerationType;
    final entryPointAccess = this.entryPointAccess;
    final moderation = this.moderation;
    final moderationRestrictions = this.moderationRestrictions;
    return {
      'accessType': ?accessType,
      'artifactConfig': ?artifactConfig,
      'attendanceReportGenerationType': ?attendanceReportGenerationType,
      'entryPointAccess': ?entryPointAccess,
      'moderation': ?moderation,
      'moderationRestrictions': ?moderationRestrictions,
    };
  }
}

/// Metadata for a transcript generated from a conference.
///
/// It refers to the ASR (Automatic Speech Recognition) result of user's speech
/// during the conference.
class Transcript {
  /// Where the Google Docs transcript is saved.
  ///
  /// Output only.
  DocsDestination? docsDestination;

  /// Timestamp when the transcript stopped.
  ///
  /// Output only.
  core.String? endTime;

  /// 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.
  ///
  /// Output only.
  core.String? name;

  /// Timestamp when the transcript started.
  ///
  /// Output only.
  core.String? startTime;

  /// Current state.
  ///
  /// Output only.
  /// Possible string values are:
  /// - "STATE_UNSPECIFIED" : Default, never used.
  /// - "STARTED" : An active transcript session has started.
  /// - "ENDED" : This transcript session has ended, but the transcript file
  /// hasn't been generated yet.
  /// - "FILE_GENERATED" : Transcript file is generated and ready to download.
  core.String? state;

  Transcript({
    this.docsDestination,
    this.endTime,
    this.name,
    this.startTime,
    this.state,
  });

  Transcript.fromJson(core.Map json_)
    : this(
        docsDestination: json_.containsKey('docsDestination')
            ? DocsDestination.fromJson(
                json_['docsDestination'] as core.Map<core.String, core.dynamic>,
              )
            : null,
        endTime: json_['endTime'] as core.String?,
        name: json_['name'] as core.String?,
        startTime: json_['startTime'] as core.String?,
        state: json_['state'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final docsDestination = this.docsDestination;
    final endTime = this.endTime;
    final name = this.name;
    final startTime = this.startTime;
    final state = this.state;
    return {
      'docsDestination': ?docsDestination,
      'endTime': ?endTime,
      'name': ?name,
      'startTime': ?startTime,
      'state': ?state,
    };
  }
}

/// Single entry for one user’s speech during a transcript session.
class TranscriptEntry {
  /// Timestamp when the transcript entry ended.
  ///
  /// Output only.
  core.String? endTime;

  /// Language of spoken text, such as "en-US".
  ///
  /// IETF BCP 47 syntax (https://tools.ietf.org/html/bcp47)
  ///
  /// Output only.
  core.String? languageCode;

  /// Resource name of the entry.
  ///
  /// Format:
  /// "conferenceRecords/{conference_record}/transcripts/{transcript}/entries/{entry}"
  ///
  /// Output only.
  core.String? name;

  /// Refers to the participant who speaks.
  ///
  /// Output only.
  core.String? participant;

  /// Timestamp when the transcript entry started.
  ///
  /// Output only.
  core.String? startTime;

  /// The transcribed text of the participant's voice, at maximum 10K words.
  ///
  /// Note that the limit is subject to change.
  ///
  /// Output only.
  core.String? text;

  TranscriptEntry({
    this.endTime,
    this.languageCode,
    this.name,
    this.participant,
    this.startTime,
    this.text,
  });

  TranscriptEntry.fromJson(core.Map json_)
    : this(
        endTime: json_['endTime'] as core.String?,
        languageCode: json_['languageCode'] as core.String?,
        name: json_['name'] as core.String?,
        participant: json_['participant'] as core.String?,
        startTime: json_['startTime'] as core.String?,
        text: json_['text'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final endTime = this.endTime;
    final languageCode = this.languageCode;
    final name = this.name;
    final participant = this.participant;
    final startTime = this.startTime;
    final text = this.text;
    return {
      'endTime': ?endTime,
      'languageCode': ?languageCode,
      'name': ?name,
      'participant': ?participant,
      'startTime': ?startTime,
      'text': ?text,
    };
  }
}

/// Configuration related to transcription in a meeting space.
class TranscriptionConfig {
  /// Defines whether the content of a meeting is automatically transcribed when
  /// someone with the privilege to transcribe joins the meeting.
  /// Possible string values are:
  /// - "AUTO_GENERATION_TYPE_UNSPECIFIED" : Default value specified by user
  /// policy. This should never be returned.
  /// - "ON" : The artifact is generated automatically.
  /// - "OFF" : The artifact is not generated automatically.
  core.String? autoTranscriptionGeneration;

  TranscriptionConfig({this.autoTranscriptionGeneration});

  TranscriptionConfig.fromJson(core.Map json_)
    : this(
        autoTranscriptionGeneration:
            json_['autoTranscriptionGeneration'] as core.String?,
      );

  core.Map<core.String, core.dynamic> toJson() {
    final autoTranscriptionGeneration = this.autoTranscriptionGeneration;
    return {'autoTranscriptionGeneration': ?autoTranscriptionGeneration};
  }
}