// Copyright 2022 Luca Casonato. All rights reserved. MIT license.
/**
 * Document AI Warehouse API Client for Deno
 * =========================================
 * 
 * 
 * 
 * Docs: https://cloud.google.com/document-warehouse
 * Source: https://googleapis.deno.dev/v1/contentwarehouse:v1.ts
 */

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

export class contentWarehouse {
  #client: CredentialsClient | undefined;
  #baseUrl: string;

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

  /**
   * Gets the access control policy for a resource. Returns NOT_FOUND error if
   * the resource does not exist. Returns an empty policy if the resource exists
   * but does not have a policy set.
   *
   * @param resource Required. REQUIRED: The resource for which the policy is being requested. Format for document: projects/{project_number}/locations/{location}/documents/{document_id}. Format for project: projects/{project_number}.
   */
  async projectsFetchAcl(resource: string, req: GoogleCloudContentwarehouseV1FetchAclRequest): Promise<GoogleCloudContentwarehouseV1FetchAclResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ resource }:fetchAcl`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1FetchAclResponse(data);
  }

  /**
   * Creates a collection.
   *
   * @param parent Required. The parent name.
   */
  async projectsLocationsCollectionsCreate(parent: string, req: GoogleCloudContentwarehouseV1Collection): Promise<GoogleCloudContentwarehouseV1Collection> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/collections`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleCloudContentwarehouseV1Collection;
  }

  /**
   * Deletes a collection.
   *
   * @param name Required. The name of the collection to delete.
   */
  async projectsLocationsCollectionsDelete(name: string): Promise<GoogleProtobufEmpty> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as GoogleProtobufEmpty;
  }

  /**
   * Gets the access control policy for the collection. Returns NOT_FOUND error
   * if the collection does not exist. Returns an empty policy if the collection
   * exists but does not have a policy set.
   *
   * @param name Required. The name of the collection. projects/{project_number}/locations/{location}/collections/{document_id}.
   */
  async projectsLocationsCollectionsFetchCollectionAcl(name: string, req: GoogleCloudContentwarehouseV1FetchCollectionAclRequest): Promise<GoogleCloudContentwarehouseV1FetchCollectionAclResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:fetchCollectionAcl`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1FetchCollectionAclResponse(data);
  }

  /**
   * Gets a collection.
   *
   * @param name Required. The name of the collection to retrieve.
   */
  async projectsLocationsCollectionsGet(name: string): Promise<GoogleCloudContentwarehouseV1Collection> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as GoogleCloudContentwarehouseV1Collection;
  }

  /**
   * Searches for collections using provided SearchCollectionsRequest. This
   * call only returns collections that the caller has permission to search
   * against.
   *
   * @param parent Required. The parent, which owns the collections. Format: projects/{project_number}/locations/{location}.
   */
  async projectsLocationsCollectionsSearch(parent: string, req: GoogleCloudContentwarehouseV1SearchCollectionsRequest): Promise<GoogleCloudContentwarehouseV1SearchCollectionsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/collections:search`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleCloudContentwarehouseV1SearchCollectionsResponse;
  }

  /**
   * Sets the access control policy for the collection. Replaces any existing
   * policy.
   *
   * @param name Required. The name of the collection for which the policy is being set. projects/{project_number}/locations/{location}/collections/{document_id}.
   */
  async projectsLocationsCollectionsSetCollectionAcl(name: string, req: GoogleCloudContentwarehouseV1SetCollectionAclRequest): Promise<GoogleCloudContentwarehouseV1SetCollectionAclResponse> {
    req = serializeGoogleCloudContentwarehouseV1SetCollectionAclRequest(req);
    const url = new URL(`${this.#baseUrl}v1/${ name }:setCollectionAcl`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1SetCollectionAclResponse(data);
  }

  /**
   * Creates a document schema.
   *
   * @param parent Required. The parent name.
   */
  async projectsLocationsDocumentSchemasCreate(parent: string, req: GoogleCloudContentwarehouseV1DocumentSchema): Promise<GoogleCloudContentwarehouseV1DocumentSchema> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/documentSchemas`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleCloudContentwarehouseV1DocumentSchema;
  }

  /**
   * Deletes a document schema. Returns NOT_FOUND if the document schema does
   * not exist. Returns BAD_REQUEST if the document schema has documents
   * depending on it.
   *
   * @param name Required. The name of the document schema to delete.
   */
  async projectsLocationsDocumentSchemasDelete(name: string): Promise<GoogleProtobufEmpty> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as GoogleProtobufEmpty;
  }

  /**
   * Gets a document schema. Returns NOT_FOUND if the document schema does not
   * exist.
   *
   * @param name Required. The name of the document schema to retrieve.
   */
  async projectsLocationsDocumentSchemasGet(name: string): Promise<GoogleCloudContentwarehouseV1DocumentSchema> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as GoogleCloudContentwarehouseV1DocumentSchema;
  }

  /**
   * Lists document schemas.
   *
   * @param parent Required. The parent, which owns this collection of document schemas. Format: projects/{project_number}/locations/{location}.
   */
  async projectsLocationsDocumentSchemasList(parent: string, opts: ProjectsLocationsDocumentSchemasListOptions = {}): Promise<GoogleCloudContentwarehouseV1ListDocumentSchemasResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/documentSchemas`);
    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 GoogleCloudContentwarehouseV1ListDocumentSchemasResponse;
  }

  /**
   * Updates a Document Schema. Returns INVALID_ARGUMENT if the name of the
   * Document Schema is non-empty and does not equal the existing name. Supports
   * only appending new properties, adding new ENUM possible values, and
   * updating the EnumTypeOptions.validation_check_disabled flag for ENUM
   * possible values. Updating existing properties will result into
   * INVALID_ARGUMENT.
   *
   * @param name Required. The name of the document schema to update. Format: projects/{project_number}/locations/{location}/documentSchemas/{document_schema_id}.
   */
  async projectsLocationsDocumentSchemasPatch(name: string, req: GoogleCloudContentwarehouseV1UpdateDocumentSchemaRequest): Promise<GoogleCloudContentwarehouseV1DocumentSchema> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as GoogleCloudContentwarehouseV1DocumentSchema;
  }

  /**
   * Creates a document.
   *
   * @param parent Required. The parent name. Format: projects/{project_number}/locations/{location}.
   */
  async projectsLocationsDocumentsCreate(parent: string, req: GoogleCloudContentwarehouseV1CreateDocumentRequest): Promise<GoogleCloudContentwarehouseV1CreateDocumentResponse> {
    req = serializeGoogleCloudContentwarehouseV1CreateDocumentRequest(req);
    const url = new URL(`${this.#baseUrl}v1/${ parent }/documents`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1CreateDocumentResponse(data);
  }

  /**
   * Deletes a document. Returns NOT_FOUND if the document does not exist.
   *
   * @param name Required. The name of the document to delete. Format: projects/{project_number}/locations/{location}/documents/{document_id} or projects/{project_number}/locations/{location}/documents/referenceId/{reference_id}.
   */
  async projectsLocationsDocumentsDelete(name: string, req: GoogleCloudContentwarehouseV1DeleteDocumentRequest): Promise<GoogleProtobufEmpty> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:delete`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleProtobufEmpty;
  }

  /**
   * Create a link between a source document and a target document.
   *
   * @param parent Required. Parent of the document-link to be created. parent of document-link should be a document. Format: projects/{project_number}/locations/{location}/documents/{source_document_id}.
   */
  async projectsLocationsDocumentsDocumentLinksCreate(parent: string, req: GoogleCloudContentwarehouseV1CreateDocumentLinkRequest): Promise<GoogleCloudContentwarehouseV1DocumentLink> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/documentLinks`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleCloudContentwarehouseV1DocumentLink;
  }

  /**
   * Remove the link between the source and target documents.
   *
   * @param name Required. The name of the document-link to be deleted. Format: projects/{project_number}/locations/{location}/documents/{source_document_id}/documentLinks/{document_link_id}.
   */
  async projectsLocationsDocumentsDocumentLinksDelete(name: string, req: GoogleCloudContentwarehouseV1DeleteDocumentLinkRequest): Promise<GoogleProtobufEmpty> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:delete`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleProtobufEmpty;
  }

  /**
   * Gets the access control policy for a resource. Returns NOT_FOUND error if
   * the resource does not exist. Returns an empty policy if the resource exists
   * but does not have a policy set.
   *
   * @param resource Required. REQUIRED: The resource for which the policy is being requested. Format for document: projects/{project_number}/locations/{location}/documents/{document_id}. Format for project: projects/{project_number}.
   */
  async projectsLocationsDocumentsFetchAcl(resource: string, req: GoogleCloudContentwarehouseV1FetchAclRequest): Promise<GoogleCloudContentwarehouseV1FetchAclResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ resource }:fetchAcl`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1FetchAclResponse(data);
  }

  /**
   * Gets a document. Returns NOT_FOUND if the document does not exist.
   *
   * @param name Required. The name of the document to retrieve. Format: projects/{project_number}/locations/{location}/documents/{document_id} or projects/{project_number}/locations/{location}/documents/referenceId/{reference_id}.
   */
  async projectsLocationsDocumentsGet(name: string, req: GoogleCloudContentwarehouseV1GetDocumentRequest): Promise<GoogleCloudContentwarehouseV1Document> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:get`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1Document(data);
  }

  /**
   * Return all source document-links from the document.
   *
   * @param parent Required. The name of the document, for which all source links are returned. Format: projects/{project_number}/locations/{location}/documents/{source_document_id}.
   */
  async projectsLocationsDocumentsLinkedSources(parent: string, req: GoogleCloudContentwarehouseV1ListLinkedSourcesRequest): Promise<GoogleCloudContentwarehouseV1ListLinkedSourcesResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/linkedSources`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleCloudContentwarehouseV1ListLinkedSourcesResponse;
  }

  /**
   * Return all target document-links from the document.
   *
   * @param parent Required. The name of the document, for which all target links are returned. Format: projects/{project_number}/locations/{location}/documents/{target_document_id}.
   */
  async projectsLocationsDocumentsLinkedTargets(parent: string, req: GoogleCloudContentwarehouseV1ListLinkedTargetsRequest): Promise<GoogleCloudContentwarehouseV1ListLinkedTargetsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/linkedTargets`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleCloudContentwarehouseV1ListLinkedTargetsResponse;
  }

  /**
   * Lock the document so the document cannot be updated by other users.
   *
   * @param name Required. The name of the document to lock. Format: projects/{project_number}/locations/{location}/documents/{document}.
   */
  async projectsLocationsDocumentsLock(name: string, req: GoogleCloudContentwarehouseV1LockDocumentRequest): Promise<GoogleCloudContentwarehouseV1Document> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:lock`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1Document(data);
  }

  /**
   * Updates a document. Returns INVALID_ARGUMENT if the name of the document
   * is non-empty and does not equal the existing name.
   *
   * @param name Required. The name of the document to update. Format: projects/{project_number}/locations/{location}/documents/{document_id} or projects/{project_number}/locations/{location}/documents/referenceId/{reference_id}.
   */
  async projectsLocationsDocumentsPatch(name: string, req: GoogleCloudContentwarehouseV1UpdateDocumentRequest): Promise<GoogleCloudContentwarehouseV1UpdateDocumentResponse> {
    req = serializeGoogleCloudContentwarehouseV1UpdateDocumentRequest(req);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1UpdateDocumentResponse(data);
  }

  /**
   * Deletes a document. Returns NOT_FOUND if the document does not exist.
   *
   * @param name Required. The name of the document to delete. Format: projects/{project_number}/locations/{location}/documents/{document_id} or projects/{project_number}/locations/{location}/documents/referenceId/{reference_id}.
   */
  async projectsLocationsDocumentsReferenceIdDelete(name: string, req: GoogleCloudContentwarehouseV1DeleteDocumentRequest): Promise<GoogleProtobufEmpty> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:delete`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleProtobufEmpty;
  }

  /**
   * Gets a document. Returns NOT_FOUND if the document does not exist.
   *
   * @param name Required. The name of the document to retrieve. Format: projects/{project_number}/locations/{location}/documents/{document_id} or projects/{project_number}/locations/{location}/documents/referenceId/{reference_id}.
   */
  async projectsLocationsDocumentsReferenceIdGet(name: string, req: GoogleCloudContentwarehouseV1GetDocumentRequest): Promise<GoogleCloudContentwarehouseV1Document> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:get`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1Document(data);
  }

  /**
   * Updates a document. Returns INVALID_ARGUMENT if the name of the document
   * is non-empty and does not equal the existing name.
   *
   * @param name Required. The name of the document to update. Format: projects/{project_number}/locations/{location}/documents/{document_id} or projects/{project_number}/locations/{location}/documents/referenceId/{reference_id}.
   */
  async projectsLocationsDocumentsReferenceIdPatch(name: string, req: GoogleCloudContentwarehouseV1UpdateDocumentRequest): Promise<GoogleCloudContentwarehouseV1UpdateDocumentResponse> {
    req = serializeGoogleCloudContentwarehouseV1UpdateDocumentRequest(req);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1UpdateDocumentResponse(data);
  }

  /**
   * Searches for documents using provided SearchDocumentsRequest. This call
   * only returns documents that the caller has permission to search against.
   *
   * @param parent Required. The parent, which owns this collection of documents. Format: projects/{project_number}/locations/{location}.
   */
  async projectsLocationsDocumentsSearch(parent: string, req: GoogleCloudContentwarehouseV1SearchDocumentsRequest): Promise<GoogleCloudContentwarehouseV1SearchDocumentsResponse> {
    req = serializeGoogleCloudContentwarehouseV1SearchDocumentsRequest(req);
    const url = new URL(`${this.#baseUrl}v1/${ parent }/documents:search`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1SearchDocumentsResponse(data);
  }

  /**
   * Sets the access control policy for a resource. Replaces any existing
   * policy.
   *
   * @param resource Required. REQUIRED: The resource for which the policy is being requested. Format for document: projects/{project_number}/locations/{location}/documents/{document_id}. Format for project: projects/{project_number}.
   */
  async projectsLocationsDocumentsSetAcl(resource: string, req: GoogleCloudContentwarehouseV1SetAclRequest): Promise<GoogleCloudContentwarehouseV1SetAclResponse> {
    req = serializeGoogleCloudContentwarehouseV1SetAclRequest(req);
    const url = new URL(`${this.#baseUrl}v1/${ resource }:setAcl`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1SetAclResponse(data);
  }

  /**
   * Provisions resources for given tenant project. Returns a long running
   * operation.
   *
   * @param location Required. The location to be initialized Format: projects/{project_number}/locations/{location}.
   */
  async projectsLocationsInitialize(location: string, req: GoogleCloudContentwarehouseV1InitializeProjectRequest): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ location }:initialize`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleLongrunningOperation;
  }

  /**
   * Creates a link.
   *
   * @param parent Required. The parent name.
   */
  async projectsLocationsLinksCreate(parent: string, req: GoogleCloudContentwarehouseV1Link): Promise<GoogleCloudContentwarehouseV1Link> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/links`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleCloudContentwarehouseV1Link;
  }

  /**
   * Deletes a link between a collection and a document.
   *
   * @param name Required. The name of the link to delete.
   */
  async projectsLocationsLinksDelete(name: string): Promise<GoogleProtobufEmpty> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as GoogleProtobufEmpty;
  }

  /**
   * Gets a link.
   *
   * @param name Required. The name of the link to retrieve.
   */
  async projectsLocationsLinksGet(name: string): Promise<GoogleCloudContentwarehouseV1Link> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as GoogleCloudContentwarehouseV1Link;
  }

  /**
   * Updates the link using provided UpdateLinkRequest.
   *
   * @param name The resource name of the link. Format: projects/{project_number}/locations/{location}/links/{link}. The name is ignored when creating a link.
   */
  async projectsLocationsLinksPatch(linksId: string, name: string, req: GoogleCloudContentwarehouseV1Link): Promise<GoogleCloudContentwarehouseV1Link> {
    const url = new URL(`${this.#baseUrl}v1/${ name }/links/${ linksId }`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as GoogleCloudContentwarehouseV1Link;
  }

  /**
   * Gets the latest state of a long-running operation. Clients can use this
   * method to poll the operation result at intervals as recommended by the API
   * service.
   *
   * @param name The name of the operation resource.
   */
  async projectsLocationsOperationsGet(name: string): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as GoogleLongrunningOperation;
  }

  /**
   * Creates a ruleset.
   *
   * @param parent Required. The parent name. Format: projects/{project_number}/locations/{location}.
   */
  async projectsLocationsRuleSetsCreate(parent: string, req: GoogleCloudContentwarehouseV1RuleSet): Promise<GoogleCloudContentwarehouseV1RuleSet> {
    req = serializeGoogleCloudContentwarehouseV1RuleSet(req);
    const url = new URL(`${this.#baseUrl}v1/${ parent }/ruleSets`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1RuleSet(data);
  }

  /**
   * Deletes a ruleset. Returns NOT_FOUND if the document does not exist.
   *
   * @param name Required. The name of the rule set to delete. Format: projects/{project_number}/locations/{location}/ruleSets/{rule_set_id}.
   */
  async projectsLocationsRuleSetsDelete(name: string): Promise<GoogleProtobufEmpty> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as GoogleProtobufEmpty;
  }

  /**
   * Gets a ruleset. Returns NOT_FOUND if the ruleset does not exist.
   *
   * @param name Required. The name of the rule set to retrieve. Format: projects/{project_number}/locations/{location}/ruleSets/{rule_set_id}.
   */
  async projectsLocationsRuleSetsGet(name: string): Promise<GoogleCloudContentwarehouseV1RuleSet> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return deserializeGoogleCloudContentwarehouseV1RuleSet(data);
  }

  /**
   * Lists rulesets.
   *
   * @param parent Required. The parent, which owns this collection of document. Format: projects/{project_number}/locations/{location}.
   */
  async projectsLocationsRuleSetsList(parent: string, opts: ProjectsLocationsRuleSetsListOptions = {}): Promise<GoogleCloudContentwarehouseV1ListRuleSetsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/ruleSets`);
    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 deserializeGoogleCloudContentwarehouseV1ListRuleSetsResponse(data);
  }

  /**
   * Updates a ruleset. Returns INVALID_ARGUMENT if the name of the ruleset is
   * non-empty and does not equal the existing name.
   *
   * @param name Required. The name of the rule set to update. Format: projects/{project_number}/locations/{location}/ruleSets/{rule_set_id}.
   */
  async projectsLocationsRuleSetsPatch(name: string, req: GoogleCloudContentwarehouseV1UpdateRuleSetRequest): Promise<GoogleCloudContentwarehouseV1RuleSet> {
    req = serializeGoogleCloudContentwarehouseV1UpdateRuleSetRequest(req);
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1RuleSet(data);
  }

  /**
   * Run a predefined pipeline.
   *
   * @param name Required. The resource name which owns the resources of the pipeline. Format: projects/{project_number}/locations/{location}.
   */
  async projectsLocationsRunPipeline(name: string, req: GoogleCloudContentwarehouseV1RunPipelineRequest): Promise<GoogleLongrunningOperation> {
    const url = new URL(`${this.#baseUrl}v1/${ name }:runPipeline`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleLongrunningOperation;
  }

  /**
   * Creates a SynonymSet for a single context. Throws an ALREADY_EXISTS
   * exception if a synonymset already exists for the context.
   *
   * @param parent Required. The parent name. Format: projects/{project_number}/locations/{location}.
   */
  async projectsLocationsSynonymSetsCreate(parent: string, req: GoogleCloudContentwarehouseV1SynonymSet): Promise<GoogleCloudContentwarehouseV1SynonymSet> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/synonymSets`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleCloudContentwarehouseV1SynonymSet;
  }

  /**
   * Deletes a SynonymSet for a given context. Throws a NOT_FOUND exception if
   * the SynonymSet is not found.
   *
   * @param name Required. The name of the synonymSet to delete Format: projects/{project_number}/locations/{location}/synonymSets/{context}.
   */
  async projectsLocationsSynonymSetsDelete(name: string): Promise<GoogleProtobufEmpty> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "DELETE",
    });
    return data as GoogleProtobufEmpty;
  }

  /**
   * Gets a SynonymSet for a particular context. Throws a NOT_FOUND exception
   * if the Synonymset does not exist
   *
   * @param name Required. The name of the synonymSet to retrieve Format: projects/{project_number}/locations/{location}/synonymSets/{context}.
   */
  async projectsLocationsSynonymSetsGet(name: string): Promise<GoogleCloudContentwarehouseV1SynonymSet> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as GoogleCloudContentwarehouseV1SynonymSet;
  }

  /**
   * Returns all SynonymSets (for all contexts) for the specified location.
   *
   * @param parent Required. The parent name. Format: projects/{project_number}/locations/{location}.
   */
  async projectsLocationsSynonymSetsList(parent: string, opts: ProjectsLocationsSynonymSetsListOptions = {}): Promise<GoogleCloudContentwarehouseV1ListSynonymSetsResponse> {
    const url = new URL(`${this.#baseUrl}v1/${ parent }/synonymSets`);
    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 GoogleCloudContentwarehouseV1ListSynonymSetsResponse;
  }

  /**
   * Remove the existing SynonymSet for the context and replaces it with a new
   * one. Throws a NOT_FOUND exception if the SynonymSet is not found.
   *
   * @param name Required. The name of the synonymSet to update Format: projects/{project_number}/locations/{location}/synonymSets/{context}.
   */
  async projectsLocationsSynonymSetsPatch(name: string, req: GoogleCloudContentwarehouseV1SynonymSet): Promise<GoogleCloudContentwarehouseV1SynonymSet> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "PATCH",
      body,
    });
    return data as GoogleCloudContentwarehouseV1SynonymSet;
  }

  /**
   * Sets the access control policy for a resource. Replaces any existing
   * policy.
   *
   * @param resource Required. REQUIRED: The resource for which the policy is being requested. Format for document: projects/{project_number}/locations/{location}/documents/{document_id}. Format for project: projects/{project_number}.
   */
  async projectsSetAcl(resource: string, req: GoogleCloudContentwarehouseV1SetAclRequest): Promise<GoogleCloudContentwarehouseV1SetAclResponse> {
    req = serializeGoogleCloudContentwarehouseV1SetAclRequest(req);
    const url = new URL(`${this.#baseUrl}v1/${ resource }:setAcl`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleCloudContentwarehouseV1SetAclResponse(data);
  }
}

export interface AbuseiamAbuseType {
  id?:  | "NONE" | "OTHER_ABUSE" | "CHILD_PORN" | "PORNOGRAPHY" | "SPAM" | "PHISHING" | "HATE" | "TOS_OTHER" | "MALWARE" | "MALICIOUS_JAVASCRIPT" | "NOT_FAMILY_SAFE" | "IMPERSONATION" | "PEDOPHILIA" | "PERSONAL_INFO" | "COPYRIGHT" | "HIGH_RISK" | "VIOLENCE" | "UNSAFE_RACY" | "UNSAFE_OTHER" | "FAKE_USER" | "NAME_VIOLATION" | "PLUSONE_VIOLATION" | "DEFAMATION" | "TRADEMARK" | "COURT_ORDER" | "GOVERNMENT_ORDER" | "LOCAL_LAWS" | "PRIVACY" | "ES_BLACKLIST" | "ES_COMMENTS_BLACKLIST" | "HARASSMENT" | "COMPROMISED" | "LOW_QUALITY" | "API_VIOLATION" | "REGULATED" | "CAROUSEL_FRAME_BLACKLIST" | "QUOTA_EXCEEDED" | "FOUNTAIN_BLACKLIST" | "COPPA_REGULATED" | "DOXXING" | "SOFT_HATE" | "SOFT_HARASSMENT" | "OBNOXIOUS" | "UNWANTED" | "NOT_UNICORN_SAFE" | "FAKE_ENGAGEMENT" | "COUNTERFEIT" | "CTM";
  /**
   * Optional client specific subtype of abuse that is too specific to belong
   * in the above enumeration. For example, some client may want to
   * differentiate nudity from graphic sex, but both are PORNOGRAPHY.
   */
  subtype?: string;
}

export interface AbuseiamAgeRestriction {
  /**
   * This restriction applies if the user is between [min_age_years, age_years)
   * years old.
   */
  ageYears?: number;
  minAgeYears?: number;
}

export interface AbuseiamAndRestriction {
  /**
   * This restriction applies if all of the children apply.
   */
  child?: AbuseiamUserRestriction[];
}

/**
 * A client is be a Google product, or subproduct that provides content for
 * AbuseIAm to classify.
 */
export interface AbuseiamClient {
  id?:  | "ABUSE_TEAM" | "SQE" | "SEARCH" | "POSTINI" | "BLOGGER" | "ORKUT" | "ZIPIT" | "GROUPS" | "RIPTIDE" | "GADGETS" | "SITES" | "READER" | "DOCS" | "U2U" | "YOUTUBE" | "POPTART" | "COSMO" | "PROFILES" | "KNOL" | "SKETCHUP" | "CALENDAR" | "HOTSHOTS" | "TRIKI" | "MAPS" | "COMMUNITY_TRANSLATION" | "WRITELY" | "SPREADSHEET_FORM" | "SPREADSHEET" | "EXPLORER" | "FINANCE" | "GMR" | "LAIBA" | "CONFUCIUS" | "PRESENTATION" | "CHROME_EXTENSION" | "WENDA" | "TACOTOWN" | "KRAKEN" | "URL_SHORTENER" | "WAREHOUSE" | "ANDROID_VM" | "CODESITE" | "FRIEND_CONNECT" | "GEOWIKI" | "GOOGLE_LABS" | "HELP_CENTER" | "SEARCHWIKI" | "SIDEWIKI" | "TOPIC_SEARCH" | "VIDEO" | "GOOGLEBASE" | "FEEDBURNER" | "PUBLISHER_QUALITY" | "NOTEBOOK" | "SMARTLISTS" | "ENTERPRISE_MARKETPLACE" | "BOOKS" | "IGOOGLE" | "USENET" | "TRANSLATE" | "PERFECT_STREAM" | "PHOTOS" | "AFMA" | "LIKES" | "QUESTIONS" | "SKYJAM" | "MIC" | "ANDROID_MARKET" | "CHROME_WEBSTORE" | "FINSKY" | "BARNOWL" | "STREET_VIEW" | "ADCONNECT" | "ES" | "HELLO" | "TRADER" | "SCHEMER" | "ANDROID" | "MINE" | "GAIA" | "GOGGLES" | "SIGNUP" | "BABEL" | "CHECKOUT" | "TASTEMAKER" | "STRATUS" | "DRAGONFLY" | "APIARY" | "CAROUSEL" | "FOUNTAIN" | "GEOPIX" | "VILLAGE" | "KIX" | "AMARNA" | "GINKGO" | "TEE" | "SHOPPING" | "SLAM" | "APPENGINE" | "GUNS" | "CULTURAL" | "COMPUTEENGINE" | "BIGSTORE" | "COPACABANA" | "ANALYTICS" | "GRANDCENTRAL" | "GMAIL" | "GLASS" | "CRISIS_RESPONSE" | "GJOBS" | "HAZMAT" | "SAFE_BROWSING" | "CLOUD" | "PANTHEON" | "CLUSTER" | "KEEP" | "APP_HISTORY" | "COMMERCIAL_ENTITY" | "ARES_DATA_PROVIDER" | "ARES_DATA_WRITER" | "BIZBUILDER" | "RITZ" | "POLLS" | "APPINVITE";
  /**
   * The name of the subservice within a client. This subservice can be used to
   * affect the flow of decision script, or selection of backend classifiers.
   * For example, StreetView may want to specify a panel is insufficiently
   * blurred (maybe there is a lisense plate or public sex, etc), which requires
   * manual review then the subservice might be "blurring".
   */
  subservice?: string;
}

/**
 * Extra information regarding evaluations received through cluster review.
 */
export interface AbuseiamClusterEvaluationContext {
  /**
   * The family of the cluster where the case received the evaluation.
   */
  clusterFamily?: string;
  /**
   * The AbuseIAm rowkey of the cluster where the case received an evaluation.
   */
  clusterRowkey?: string;
  /**
   * The gaia id of a mail box that ops can send inquiries to for appeals. Used
   * only by user clusters to fill a required gatekeeper param. See
   * gaia_disableserver.DisableSpec.escalate_to field.
   */
  gaiaIdToEscalate?: bigint;
}

function serializeAbuseiamClusterEvaluationContext(data: any): AbuseiamClusterEvaluationContext {
  return {
    ...data,
    gaiaIdToEscalate: data["gaiaIdToEscalate"] !== undefined ? String(data["gaiaIdToEscalate"]) : undefined,
  };
}

function deserializeAbuseiamClusterEvaluationContext(data: any): AbuseiamClusterEvaluationContext {
  return {
    ...data,
    gaiaIdToEscalate: data["gaiaIdToEscalate"] !== undefined ? BigInt(data["gaiaIdToEscalate"]) : undefined,
  };
}

export interface AbuseiamConstantRestriction {
  /**
   * A constant of type TRUE always applies, and of type FALSE never applies.
   */
  type?:  | "ALWAYS_TRUE" | "ALWAYS_FALSE";
}

/**
 * Pair of Verdicts used for ProjectR age/geo gating. See http://go/projectr
 * for more information.
 */
export interface AbuseiamContentRestriction {
  /**
   * Takedowns specified by admins via AbuseIAm
   */
  adminVerdict?: AbuseiamVerdict[];
  /**
   * User-specified takedowns
   */
  userVerdict?: AbuseiamVerdict[];
}

function serializeAbuseiamContentRestriction(data: any): AbuseiamContentRestriction {
  return {
    ...data,
    adminVerdict: data["adminVerdict"] !== undefined ? data["adminVerdict"].map((item: any) => (serializeAbuseiamVerdict(item))) : undefined,
    userVerdict: data["userVerdict"] !== undefined ? data["userVerdict"].map((item: any) => (serializeAbuseiamVerdict(item))) : undefined,
  };
}

function deserializeAbuseiamContentRestriction(data: any): AbuseiamContentRestriction {
  return {
    ...data,
    adminVerdict: data["adminVerdict"] !== undefined ? data["adminVerdict"].map((item: any) => (deserializeAbuseiamVerdict(item))) : undefined,
    userVerdict: data["userVerdict"] !== undefined ? data["userVerdict"].map((item: any) => (deserializeAbuseiamVerdict(item))) : undefined,
  };
}

/**
 * Backends return Evaluations to AbuseIAm. One of the things Evaluations are
 * used for is to explain Verdicts.
 */
export interface AbuseiamEvaluation {
  abuseType?: AbuseiamAbuseType;
  /**
   * Who creates this Evaluation. This field is required.
   */
  backend?:  | "UNKNOWN" | "ADMIN" | "GRADS" | "OCELOT" | "SPAMIAM" | "MANUAL_REVIEW" | "MAWLER" | "SNEAKY_JS" | "DOWNLOADER" | "PORN_CLASSIFIER" | "GIBBERISH_DETECTOR" | "ANTIVIRUS" | "GAUSS" | "REALUSERS" | "USERRANK" | "GRADS_AGGRESSIVE" | "BULK_ACTION" | "BADWORD" | "GAIA" | "LINKS_COUNT" | "RE_RULE" | "SLAM" | "AUTHORRANK" | "USERRANK_BADNESS" | "GAUSS_EXPLICIT" | "GAUSS_IMPLICIT" | "RETRIEVE_MESSAGE" | "SPAM_REPORT" | "SQUEAL" | "BLOGGER_LOGS" | "TRUSTRANK_PHISHING" | "CATFOOD" | "IMAGE_PORN_CLASSIFIER" | "OCELOT_IMPORT" | "FIFE_IMAGE_FETCHER" | "FAST_RISING_FEATURES" | "BOTGUARD" | "NAME_CHECKER" | "CHEETAH" | "GALLIFREY" | "OCELOT_DELETE" | "RULE" | "FOCUS" | "VIDEO_THUMBNAILER" | "PATTERNLIST" | "METADATA" | "METADATA_IMPORT" | "NAME_DETECTOR" | "SHINGLE_COMPUTER" | "WIGGUM" | "BINARY_EXPLORATION" | "REVNET" | "FURS" | "YOUTUBE_CLASSIFIER" | "IDV" | "CLUSTERCAT" | "CHEETAH_IMPORT" | "CHEETAH_READ" | "BOTGUARD_DECODE" | "QUOTASERVER" | "YOUTUBE" | "BLOGGER" | "SOCIAL_GRAPH" | "WEB_SIGNALS" | "TRAWLER" | "NOTIFICATIONS" | "CASES" | "BADURLS" | "LINK_IMPORT" | "SHINGLE_DEDUPER" | "DEV_CONSOLE" | "METADATA_QUERY" | "PLUS_PAGE" | "YOUTUBE_VIDEO_INFO" | "GOOGLE_ADMIN" | "RESPAY" | "COOKBOOK" | "EASY_LEARN" | "QUALITY_SAMPLER" | "BLOBSTORE" | "OWNER" | "POLICY" | "EXTERNAL" | "ABUSEIAM_FEEDBACK" | "BIGSTORE" | "PHOTO_SERVICE" | "GRADS_RELATED" | "REAPER" | "GATEKEEPER" | "VIPER" | "MSISDN" | "VIDEO_REVIEW" | "CSAI_MATCH" | "REDQUEEN" | "STREAMER_INDEXER" | "DREMEL" | "VISUAL_SEARCH_SERVICE_PORN" | "VISUAL_SEARCH_SERVICE_OCR" | "IMPLICIT_SOCIAL_GRAPH" | "EASY_LEARN_BLEND" | "USER_AURA" | "GOOPS" | "ANDROID_CHECKIN" | "ARES_DATA_PROVIDER" | "DROIDGUARD_VERDICT" | "ARES_DATA_WRITER" | "ADAPTIVE_QUOTA" | "AIAPLX" | "INFAME" | "ARES" | "VISUAL_SEARCH_SERVICE_ICA" | "VISUAL_SEARCH_SERVICE_BUTTON_DETECTION" | "VISUAL_SEARCH_SERVICE_LOGO_DETECTION";
  /**
   * Extra information regarding the cluster review context where the case
   * received the evaluation.
   */
  clusterEvaluationContext?: AbuseiamClusterEvaluationContext;
  /**
   * Backends can choose to put some debug info in addition to abuse_type,
   * score, and status.
   */
  comment?: string;
  /**
   * A set of repeated features to allow adapters to return semi structured
   * data. Please, prefer using feature instead of the old misc_data field since
   * it supports richer and more structured data to be passed back.
   */
  feature?: AbuseiamFeature[];
  /**
   * Information about the manual review, for manual review evaluations. Do NOT
   * expect this field to be set if `backend != MANUAL_REVIEW`.
   */
  manualReviewInfo?: AbuseiamManualReviewEvaluationInfo;
  /**
   * This field is used to store miscellaneous information that Backend might
   * provide. If you find youself here considering to use this field, please
   * prefer using the repeated feature field below instead. It supports a richer
   * structure for passing complex data back from the backend.
   */
  miscData?: AbuseiamNameValuePair[];
  /**
   * When the evaluation was processed by the decision script.
   */
  processedMicros?: bigint;
  /**
   * Time in milliseconds when the Backend processed this Evaluation.
   */
  processTimeMillisecs?: bigint;
  /**
   * The list of regions where the evaluation applies.
   */
  region?: AbuseiamRegion[];
  score?: number;
  status?:  | "OK" | "ERROR";
  target?: AbuseiamTarget;
  /**
   * When the Evaluation was generated.
   */
  timestampMicros?: bigint;
  /**
   * A boolean expression tree used to define the restrictions where the
   * verdict applies. Please use
   * java/com/google/ccc/abuse/abuseiam/client/TakedownManager.java to evaluate
   * this proto.
   */
  userRestriction?: AbuseiamUserRestriction;
  /**
   * Version of Backend. For rules, this string is the only way to
   * differentiate between them.
   */
  version?: string;
  /**
   * Information about the video review, for video review evaluations. Do NOT
   * expect this field to be set if `backend != VIDEO_REVIEW`.
   */
  videoReviewData?: AbuseiamVideoReviewData;
}

function serializeAbuseiamEvaluation(data: any): AbuseiamEvaluation {
  return {
    ...data,
    clusterEvaluationContext: data["clusterEvaluationContext"] !== undefined ? serializeAbuseiamClusterEvaluationContext(data["clusterEvaluationContext"]) : undefined,
    feature: data["feature"] !== undefined ? data["feature"].map((item: any) => (serializeAbuseiamFeature(item))) : undefined,
    miscData: data["miscData"] !== undefined ? data["miscData"].map((item: any) => (serializeAbuseiamNameValuePair(item))) : undefined,
    processedMicros: data["processedMicros"] !== undefined ? String(data["processedMicros"]) : undefined,
    processTimeMillisecs: data["processTimeMillisecs"] !== undefined ? String(data["processTimeMillisecs"]) : undefined,
    timestampMicros: data["timestampMicros"] !== undefined ? String(data["timestampMicros"]) : undefined,
    videoReviewData: data["videoReviewData"] !== undefined ? serializeAbuseiamVideoReviewData(data["videoReviewData"]) : undefined,
  };
}

function deserializeAbuseiamEvaluation(data: any): AbuseiamEvaluation {
  return {
    ...data,
    clusterEvaluationContext: data["clusterEvaluationContext"] !== undefined ? deserializeAbuseiamClusterEvaluationContext(data["clusterEvaluationContext"]) : undefined,
    feature: data["feature"] !== undefined ? data["feature"].map((item: any) => (deserializeAbuseiamFeature(item))) : undefined,
    miscData: data["miscData"] !== undefined ? data["miscData"].map((item: any) => (deserializeAbuseiamNameValuePair(item))) : undefined,
    processedMicros: data["processedMicros"] !== undefined ? BigInt(data["processedMicros"]) : undefined,
    processTimeMillisecs: data["processTimeMillisecs"] !== undefined ? BigInt(data["processTimeMillisecs"]) : undefined,
    timestampMicros: data["timestampMicros"] !== undefined ? BigInt(data["timestampMicros"]) : undefined,
    videoReviewData: data["videoReviewData"] !== undefined ? deserializeAbuseiamVideoReviewData(data["videoReviewData"]) : undefined,
  };
}

export interface AbuseiamFeature {
  /**
   * Exactly one of the following should be filled in.
   */
  booleanValue?: boolean;
  doubleValue?: number;
  /**
   * Useful for applications that need to know how many times a specific
   * feature occurs
   */
  featureCount?: bigint;
  /**
   * Useful for timestamps, or for numerical features where it is helpful for
   * decision scripts to have exact values.
   */
  int64Value?: bigint;
  /**
   * integer value field is deprecated and shall only be used for passing the
   * following features hardcoded in spamiam::SpamIAmMessage:
   * spamiam::OrkutSenderId spamiam::OrkutPostnumReports
   * spamiam::BloggerNumComments spamiam::BloggerNumCommentsByOthers Another
   * hard-coded spamiam feature is spamiam::BlogName, which can be specified via
   * string value.
   */
  integerValue?: number;
  name?: string;
  stringValue?: string[];
  /**
   * This field should only be used to store a sequence of timestamps
   * associated with the feature.
   */
  timestampSequence?: bigint[];
}

function serializeAbuseiamFeature(data: any): AbuseiamFeature {
  return {
    ...data,
    featureCount: data["featureCount"] !== undefined ? String(data["featureCount"]) : undefined,
    int64Value: data["int64Value"] !== undefined ? String(data["int64Value"]) : undefined,
    timestampSequence: data["timestampSequence"] !== undefined ? data["timestampSequence"].map((item: any) => (String(item))) : undefined,
  };
}

function deserializeAbuseiamFeature(data: any): AbuseiamFeature {
  return {
    ...data,
    featureCount: data["featureCount"] !== undefined ? BigInt(data["featureCount"]) : undefined,
    int64Value: data["int64Value"] !== undefined ? BigInt(data["int64Value"]) : undefined,
    timestampSequence: data["timestampSequence"] !== undefined ? data["timestampSequence"].map((item: any) => (BigInt(item))) : undefined,
  };
}

/**
 * A node representing a table of regions and restrictions that apply to those
 * regions. This table understands region inclusion and knows to apply the most
 * specific rule, for example, a rule for France would override a rule for the
 * EU for a user in France.
 */
export interface AbuseiamGeoRestriction {
  locale?: AbuseiamGeoRestrictionLocale[];
}

export interface AbuseiamGeoRestrictionLocale {
  /**
   * The location where the restriction applies. Defaults to the "The world".
   * See go/iii.
   */
  location?: string;
  /**
   * The UserRestriction that applies to this location. If not specified
   * evaluates to true.
   */
  restriction?: AbuseiamUserRestriction;
}

/**
 * Information about various hashes that can be computed on a message ex:
 * simhash, attachment hash, etc
 */
export interface AbuseiamHash {
  /**
   * 64 bit hash in the hex form.
   */
  hash?: string;
  type?: string;
}

export interface AbuseiamManualReviewerInfo {
  credential?:  | "UNKNOWN" | "LEGAL" | "POLICY" | "ANALYST" | "LEGAL_PANEL"[];
  username?: string;
}

/**
 * Relevant information for manual review evaluations.
 */
export interface AbuseiamManualReviewEvaluationInfo {
  /**
   * Reviewer performing the manual review.
   */
  reviewer?: AbuseiamManualReviewerInfo;
  /**
   * Tool used to perform the manual review.
   */
  tool?: AbuseiamManualReviewTool;
}

export interface AbuseiamManualReviewTool {
  experimentId?: string;
  name?:  | "UNKNOWN" | "NUFF" | "GOOGLE_ADMIN" | "YOUTUBE";
}

export interface AbuseiamNameValuePair {
  name?: string;
  nonUtf8Value?: Uint8Array;
  value?: string;
}

function serializeAbuseiamNameValuePair(data: any): AbuseiamNameValuePair {
  return {
    ...data,
    nonUtf8Value: data["nonUtf8Value"] !== undefined ? encodeBase64(data["nonUtf8Value"]) : undefined,
  };
}

function deserializeAbuseiamNameValuePair(data: any): AbuseiamNameValuePair {
  return {
    ...data,
    nonUtf8Value: data["nonUtf8Value"] !== undefined ? decodeBase64(data["nonUtf8Value"] as string) : undefined,
  };
}

export interface AbuseiamNotRestriction {
  /**
   * This restriction applies if the child does not apply. Only one is allowed.
   * "repeated" is used to avoid breaking Sawzall (See b/6758277).
   */
  child?: AbuseiamUserRestriction[];
}

export interface AbuseiamOrRestriction {
  /**
   * This restriction applies if any of the children apply.
   */
  child?: AbuseiamUserRestriction[];
}

export interface AbuseiamRegion {
  /**
   * This is a CLDR Region Code: http://wiki/Main/IIIHowTo#using_region It is
   * used to denote the region affected by a verdict.
   */
  region?: string;
}

/**
 * A SpecialRestriction is a standardized UserRestriction which lives in a
 * table maintained via CDD.
 */
export interface AbuseiamSpecialRestriction {
  type?:  | "ALCOHOL";
}

export interface AbuseiamTarget {
  id?: string;
  type?:  | "MESSAGE_ID" | "CHUNK_ID" | "IMAGE_URL" | "URL" | "USER_ID" | "IP" | "SITE" | "SITEDOMAIN" | "ENTITY_ID" | "PERFECT_STREAM_ID" | "ACTIVITY_ID" | "COMMENT_ID" | "AD_ID" | "TEXT" | "TEXT_FRAGMENT" | "CLUSTER_MEMBER_ID" | "EMBED_ID" | "ANDROID_ID";
}

/**
 * A structure used to configure a notification to a user.
 */
export interface AbuseiamUserNotification {
  channel?:  | "UNKNOWN" | "BUILT_IN" | "EMAIL" | "GAIA";
}

/**
 * Describes restrictions on where the verdict applies. Please use {@code
 * TakedownManager} to evaluate this proto.
 */
export interface AbuseiamUserRestriction {
  ageRestriction?: AbuseiamAgeRestriction;
  /**
   * Operators
   */
  andRestriction?: AbuseiamAndRestriction;
  /**
   * Constant
   */
  constantRestriction?: AbuseiamConstantRestriction;
  /**
   * Leaf Nodes
   */
  geoRestriction?: AbuseiamGeoRestriction;
  notRestriction?: AbuseiamNotRestriction;
  orRestriction?: AbuseiamOrRestriction;
  specialRestriction?: AbuseiamSpecialRestriction;
}

/**
 * Verdict against a target. AbuseIAm generates a verdict based on evaluations.
 * AbuseIAm can send such verdicts to clients for enforcement.
 */
export interface AbuseiamVerdict {
  /**
   * Target client of the verdict. It can be used to differentiate verdicts
   * from multiple clients when such verdicts are processed in one common place.
   */
  client?: AbuseiamClient;
  /**
   * Additional info regarding the verdict.
   */
  comment?: string;
  decision?:  | "ERROR" | "NO_ACTION" | "GOOD" | "DELETE" | "INTERSTITIAL" | "HIDE" | "BLACK_LIST" | "MARK_AS_SPAM" | "REWRITE_LINKS" | "HIDE_AND_NOTIFY" | "FREEZE_SERVICE" | "SUSPEND_SERVICE" | "SMS_DISABLE" | "NOTIFY";
  /**
   * Time duration (in minutes) of the verdict.
   */
  durationMins?: number;
  /**
   * Evaluations relevant to this verdict. Every Verdict should contain at
   * least one Evaluation.
   */
  evaluation?: AbuseiamEvaluation[];
  /**
   * Details of all the hashes that can be computed on a message, such as
   * simhash and attachment hash
   */
  hashes?: AbuseiamHash[];
  /**
   * Is this verdict issued by legal?
   */
  isLegalIssued?: boolean;
  /**
   * This field is used to pass relevant / necessary scores to our clients. For
   * eg: ASBE propogates these scores to moonshine.
   */
  miscScores?: AbuseiamNameValuePair[];
  /**
   * A short description of the reason why the verdict decision is made.
   */
  reasonCode?: string;
  /**
   * The regions in which this verdict should be enforced. Absence of this
   * field indicates that the verdict is applicable everywhere.
   */
  region?: AbuseiamRegion[];
  /**
   * Restrictions on where this verdict applies. If any restriction is met, the
   * verdict is applied there. If no restrictions are present, the verdict is
   * considered global.
   */
  restriction?: AbuseiamVerdictRestriction[];
  /**
   * Category of the strike if this is a strike verdict.
   */
  strikeCategory?:  | "ES" | "CP" | "COPYRIGHT" | "BLOGGER" | "GRANDCENTRAL" | "DRIVE" | "CLOUD" | "SITES";
  target?: AbuseiamTarget;
  /**
   * The timestamp of the target. E.g., the time when the target was updated.
   */
  targetTimestampMicros?: bigint;
  /**
   * When the verdict is generated
   */
  timestampMicros?: bigint;
  /**
   * Extra notification(s) to be delivered to target user or message owner
   * about the verdict.
   */
  userNotification?: AbuseiamUserNotification[];
  /**
   * version of decision script
   */
  version?: string;
}

function serializeAbuseiamVerdict(data: any): AbuseiamVerdict {
  return {
    ...data,
    evaluation: data["evaluation"] !== undefined ? data["evaluation"].map((item: any) => (serializeAbuseiamEvaluation(item))) : undefined,
    miscScores: data["miscScores"] !== undefined ? data["miscScores"].map((item: any) => (serializeAbuseiamNameValuePair(item))) : undefined,
    targetTimestampMicros: data["targetTimestampMicros"] !== undefined ? String(data["targetTimestampMicros"]) : undefined,
    timestampMicros: data["timestampMicros"] !== undefined ? String(data["timestampMicros"]) : undefined,
  };
}

function deserializeAbuseiamVerdict(data: any): AbuseiamVerdict {
  return {
    ...data,
    evaluation: data["evaluation"] !== undefined ? data["evaluation"].map((item: any) => (deserializeAbuseiamEvaluation(item))) : undefined,
    miscScores: data["miscScores"] !== undefined ? data["miscScores"].map((item: any) => (deserializeAbuseiamNameValuePair(item))) : undefined,
    targetTimestampMicros: data["targetTimestampMicros"] !== undefined ? BigInt(data["targetTimestampMicros"]) : undefined,
    timestampMicros: data["timestampMicros"] !== undefined ? BigInt(data["timestampMicros"]) : undefined,
  };
}

/**
 * Describes restrictions on where the verdict applies.
 */
export interface AbuseiamVerdictRestriction {
  /**
   * For a restriction to apply, all contexts must be satisfied. For example,
   * if context[0] is COUNTRY/'GERMANY' and context[1] is
   * DESTINATION_STREAM/'gplus:SQUARE:knitting_discussion', then the verdict
   * applies only when the 'knitting discussion' square is viewed from inside
   * Germany. Please note that this is present for legacy reasons and users of
   * this field would be migrated to use the user_restriction field defined
   * below.
   */
  context?: AbuseiamVerdictRestrictionContext[];
  /**
   * A boolean expression tree used to define the restrictions where the
   * verdict applies. Please use
   * java/com/google/ccc/abuse/abuseiam/client/TakedownManager.java to evaluate
   * this proto.
   */
  userRestriction?: AbuseiamUserRestriction;
}

/**
 * Describes a dimension of a context where a verdict applies.
 */
export interface AbuseiamVerdictRestrictionContext {
  /**
   * String identifying the context.
   */
  id?: string;
  type?:  | "UNKNOWN" | "DESTINATION_STREAM";
}

/**
 * Information about a video review.
 */
export interface AbuseiamVideoReviewData {
  /**
   * Serialized repeated youtube_admin.adminmatch.csai.ReferenceFragment
   */
  referenceFragment?: Uint8Array[];
  /**
   * Information about the video reviewer.
   */
  reviewer?: AbuseiamVideoReviewer;
  /**
   * The Viper id of the video.
   */
  videoId?: string;
}

function serializeAbuseiamVideoReviewData(data: any): AbuseiamVideoReviewData {
  return {
    ...data,
    referenceFragment: data["referenceFragment"] !== undefined ? data["referenceFragment"].map((item: any) => (encodeBase64(item))) : undefined,
  };
}

function deserializeAbuseiamVideoReviewData(data: any): AbuseiamVideoReviewData {
  return {
    ...data,
    referenceFragment: data["referenceFragment"] !== undefined ? data["referenceFragment"].map((item: any) => (decodeBase64(item as string))) : undefined,
  };
}

/**
 * Information about video reviewers.
 */
export interface AbuseiamVideoReviewer {
  type?:  | "UNKNOWN" | "CRT" | "TIERED_CRT" | "POLICY" | "ANALYSTS" | "LEGAL" | "LEGAL_CSAI" | "LEGAL_REMOVALS" | "HIJACKING_TEAM" | "CRT_CSAI" | "LEGAL_CSAI_LOW_PRIORITY";
  /**
   * The username of the person doing the video review.
   */
  username?: string;
}

/**
 * The serialized form of a SORI id. NOTE that this proto is stored in V4/O4
 * index and that new fields should not be added without getting an agreement
 * from the serving team as well.
 */
export interface AdsShoppingReportingOffersSerializedSoriId {
  highId?: bigint;
  lowId1?: bigint;
  lowId2?: bigint;
}

function serializeAdsShoppingReportingOffersSerializedSoriId(data: any): AdsShoppingReportingOffersSerializedSoriId {
  return {
    ...data,
    highId: data["highId"] !== undefined ? String(data["highId"]) : undefined,
    lowId1: data["lowId1"] !== undefined ? String(data["lowId1"]) : undefined,
    lowId2: data["lowId2"] !== undefined ? String(data["lowId2"]) : undefined,
  };
}

function deserializeAdsShoppingReportingOffersSerializedSoriId(data: any): AdsShoppingReportingOffersSerializedSoriId {
  return {
    ...data,
    highId: data["highId"] !== undefined ? BigInt(data["highId"]) : undefined,
    lowId1: data["lowId1"] !== undefined ? BigInt(data["lowId1"]) : undefined,
    lowId2: data["lowId2"] !== undefined ? BigInt(data["lowId2"]) : undefined,
  };
}

export interface Anchors {
  anchor?: AnchorsAnchor[];
  /**
   * The total # of local homepage anchors dropped in AnchorAccumulator.
   */
  homepageAnchorsDropped?: bigint;
  /**
   * The index tier from which the anchors were extracted. Note that this is
   * only valid in the anchor record written by linkextractor. The value can be
   * one of the enum values defined in segindexer/types.h.
   */
  indexTier?: number;
  /**
   * The total # of local non-homepage anchors dropped in AnchorAccumulator.
   */
  localAnchorsDropped?: bigint;
  /**
   * The total # of non-local anchors dropped in AnchorAccumulator.
   */
  nonlocalAnchorsDropped?: bigint;
  redundantanchorinfo?: AnchorsRedundantAnchorInfo[];
  /**
   * The *_anchors_dropped fields below are not populated by Alexandria, which
   * uses cdoc.anchor_stats instead. The total # of redundant anchors dropped in
   * linkextractor.
   */
  redundantAnchorsDropped?: bigint;
  /**
   * The total # of supplemental anchors dropped in AnchorAccumulator. ##
   * DEPRECATED.
   */
  supplementalAnchorsDropped?: bigint;
  /**
   * may be implicit
   */
  targetDocid?: bigint;
  /**
   * HOST_LEVEL site chunking.
   */
  targetSite?: string;
  /**
   * This is produced during link extraction but not written out in the
   * linklogs in order to save space.
   */
  targetUrl?: string;
}

function serializeAnchors(data: any): Anchors {
  return {
    ...data,
    anchor: data["anchor"] !== undefined ? data["anchor"].map((item: any) => (serializeAnchorsAnchor(item))) : undefined,
    homepageAnchorsDropped: data["homepageAnchorsDropped"] !== undefined ? String(data["homepageAnchorsDropped"]) : undefined,
    localAnchorsDropped: data["localAnchorsDropped"] !== undefined ? String(data["localAnchorsDropped"]) : undefined,
    nonlocalAnchorsDropped: data["nonlocalAnchorsDropped"] !== undefined ? String(data["nonlocalAnchorsDropped"]) : undefined,
    redundantanchorinfo: data["redundantanchorinfo"] !== undefined ? data["redundantanchorinfo"].map((item: any) => (serializeAnchorsRedundantAnchorInfo(item))) : undefined,
    redundantAnchorsDropped: data["redundantAnchorsDropped"] !== undefined ? String(data["redundantAnchorsDropped"]) : undefined,
    supplementalAnchorsDropped: data["supplementalAnchorsDropped"] !== undefined ? String(data["supplementalAnchorsDropped"]) : undefined,
    targetDocid: data["targetDocid"] !== undefined ? String(data["targetDocid"]) : undefined,
  };
}

function deserializeAnchors(data: any): Anchors {
  return {
    ...data,
    anchor: data["anchor"] !== undefined ? data["anchor"].map((item: any) => (deserializeAnchorsAnchor(item))) : undefined,
    homepageAnchorsDropped: data["homepageAnchorsDropped"] !== undefined ? BigInt(data["homepageAnchorsDropped"]) : undefined,
    localAnchorsDropped: data["localAnchorsDropped"] !== undefined ? BigInt(data["localAnchorsDropped"]) : undefined,
    nonlocalAnchorsDropped: data["nonlocalAnchorsDropped"] !== undefined ? BigInt(data["nonlocalAnchorsDropped"]) : undefined,
    redundantanchorinfo: data["redundantanchorinfo"] !== undefined ? data["redundantanchorinfo"].map((item: any) => (deserializeAnchorsRedundantAnchorInfo(item))) : undefined,
    redundantAnchorsDropped: data["redundantAnchorsDropped"] !== undefined ? BigInt(data["redundantAnchorsDropped"]) : undefined,
    supplementalAnchorsDropped: data["supplementalAnchorsDropped"] !== undefined ? BigInt(data["supplementalAnchorsDropped"]) : undefined,
    targetDocid: data["targetDocid"] !== undefined ? BigInt(data["targetDocid"]) : undefined,
  };
}

export interface AnchorsAnchor {
  bucket?: number;
  /**
   * CATfish tags attached to a link. These are similar to link tags, except
   * the values are created on the fly within Cookbook. See:
   * http://sites/cookbook/exporting/indexing
   */
  catfishTags?: number[];
  /**
   * If the anchor contained images, these image urls are stored here in
   * compressed form.
   */
  compressedImageUrls?: Uint8Array[];
  /**
   * The anchor's original target url, compressed. Available only in Alexandria
   * docjoins when the anchor is forwarded.
   */
  compressedOriginalTargetUrl?: Uint8Array;
  context?: number;
  /**
   * This is a hash of terms near the anchor. (This is a second-generation hash
   * replacing the value stored in the 'context' field.)
   */
  context2?: number;
  /**
   * used for history - the first and last time we have seen this anchor.
   * creation_date also used for Freshdocs Twitter indexing, a retweet is an
   * anchor of the original tweet. This field records the time when a retweet is
   * created.
   */
  creationDate?: number;
  deleted?: boolean;
  deletionDate?: number;
  /**
   * DEPRECATED
   */
  demotionreason?: number;
  /**
   * Encoded data containing information about newsiness of anchor. Populated
   * only if anchor is classified as coming from a newsy, high quality site.
   * Encoded data for anchor sources are being stored in
   * googledata/quality/freshness/news_anchors/encoded_news_anchors_data.txt
   * Scores are being computed with quality/freshness/news_anchors/ routines.
   */
  encodedNewsAnchorData?: number;
  /**
   * If true, the anchor is for experimental purposes and should not be used in
   * serving.
   */
  experimental?: boolean;
  /**
   * true iff exp domain
   */
  expired?: boolean;
  /**
   * # days past Dec 31, 1994, 23:00:00 UTC (Unix time @788914800) that this
   * link was first seen. Should never occupy more than 15 bits. NOTE: this is
   * NOT the same as creation_date; firstseen_date is filled during link
   * extraction
   */
  firstseenDate?: number;
  /**
   * true if we think 'firstseen_date' is an accurate estimate of when the link
   * was actually added to the source page. false if it may have existed for
   * some time before we saw it.
   */
  firstseenNearCreation?: boolean;
  fontsize?: number;
  /**
   * How the anchor is forwarded to the canonical, available only for forwarded
   * anchors (i.e., the field is set). The forwarding types are defined in
   * URLForwardingUtil (segindexer/segment-indexer-util.h). Always use
   * URLForwardingUtil to access this field and use
   * URLForwardingUtil::GetAnchorForwardingReason to get the explanation how the
   * anchor is forwarded to the canonical. NOTE: Use with caution as it is only
   * set for docjoins generated using the urlmap from repository/updater.
   */
  forwardingTypes?: number;
  /**
   * The URL fragment for this anchor (the foo in http://www.google.com#foo)
   */
  fragment?: string;
  /**
   * The full context. These are not written out in the linklogs.
   */
  fullLeftContext?: bigint[];
  fullRightContext?: bigint[];
  /**
   * The bit ~roughly~ indicates whether an anchor's source and target pages
   * are on the same domain. Note: this plays no role in determining whether an
   * anchor is onsite, ondomain, or offdomain in mustang (i.e., the bit above).
   */
  isLocal?: boolean;
  /**
   * Used for history and freshness tracking - the timestamp this anchor is
   * updated in indexing.
   */
  lastUpdateTimestamp?: number;
  /**
   * Additional information related to the anchor, such as additional anchor
   * text or scores.
   */
  linkAdditionalInfo?: Proto2BridgeMessageSet;
  /**
   * Contains info on link type, source page, etc.
   */
  linkTags?: number[];
  /**
   * For ranking purposes, the quality of an anchor is measured by its
   * "locality" and "bucket". See quality/anchors/definitions.h for more
   * information.
   */
  locality?: number;
  /**
   * This is the offset for the first term in the anchor - it can be used as a
   * unique ID for the anchor within the document and compared against all
   * per-tag data. This is measured in bytes from the start of the document. We
   * write this out to the linklogs to recover the original order of links after
   * source/target forwarding. This is necessary for computing the global
   * related data.
   */
  offset?: number;
  /**
   * The docid of the anchor's original target. This field is available if and
   * only if the anchor is forwarded.
   */
  originalTargetDocid?: bigint;
  /**
   * Original text, including capitalization and punctuation. Runs of
   * whitespace are collapsed into a single space.
   */
  origText?: string;
  /**
   * Weight to be stored in linkmaps for pageranker
   */
  pagerankWeight?: number;
  /**
   * The number of additional links from the same source page to the same
   * target domain. Not populated if is_local is true.
   */
  parallelLinks?: number;
  /**
   * DEPRECATED. It used to be set if firstseen_date is not set. It's to
   * indicate that the anchor is possibly old, but we don't have enough
   * information to tell until the linkage map is updated. TODO(hxu) rename it
   * to possibly_old_firstseen_date_DEPRECATED after clean up other
   * dependencies.
   */
  possiblyOldFirstseenDate?: boolean;
  /**
   * TEMPORARY
   */
  setiPagerankWeight?: number;
  source?: AnchorsAnchorSource;
  /**
   * is to record the quality of the anchor's source page and is correlated
   * with but not identical to the index tier of the source page. In the
   * docjoins built by the indexing pipeline (Alexandria), - Anchors marked
   * TYPE_HIGH_QUALITY are from base documents. - Anchors marked
   * TYPE_MEDIUM_QUALITY are from documents of medium quality (roughly but not
   * exactly supplemental tier documents). - Anchors marked TYPE_LOW_QUALITY are
   * from documents of low quality (roughly but not exactly blackhole
   * documents). Note that the source_type can also be used as an importance
   * indicator of an anchor (a lower source_type value indicates a more
   * important anchor), so it is important to enforce that TYPE_HIGH_QUALITY <
   * TYPE_MEDIUM_QUALITY < TYPE_LOW_QUALITY To add a new source type in future,
   * please maintain the proper relationship among the types as well.
   * TYPE_FRESHDOCS, only available in freshdocs indexing, is a special case and
   * is considered the same type as TYPE_HIGH_QUALITY for the purpose of anchor
   * importance in duplicate anchor removal.
   */
  sourceType?: number;
  /**
   * A given target URL may be found in different encodings in different
   * documents. We store the URL encoding with each source anchor so that we can
   * count them later to find the encoding most likely to be expected by the Web
   * site. Around 0.7% of target URLs are expected to require a non-default
   * value here. The default value 0 is referenced in C++ as
   * webutil::kDefaultUrlEncoding. See also webutil/urlencoding.
   */
  targetUrlEncoding?: number;
  /**
   * Space-delimited anchor words. Text that needs segmentation (like CJK or
   * Thai) is unsegmented, since we set FLAGS_segment_during_lexing to false in
   * mr-linkextractor.cc .
   */
  text?: string;
  /**
   * This field is DEPRECATED and no longer filled. For source page crawl
   * timestamp, use Source.crawl_timestamp. Next tag id should be 62.
   */
  timestamp?: bigint;
  /**
   * DEPRECATED: Now in link_tags
   */
  type?: number;
  /**
   * weights are 0-127
   */
  weight?: number;
}

function serializeAnchorsAnchor(data: any): AnchorsAnchor {
  return {
    ...data,
    compressedImageUrls: data["compressedImageUrls"] !== undefined ? data["compressedImageUrls"].map((item: any) => (encodeBase64(item))) : undefined,
    compressedOriginalTargetUrl: data["compressedOriginalTargetUrl"] !== undefined ? encodeBase64(data["compressedOriginalTargetUrl"]) : undefined,
    fullLeftContext: data["fullLeftContext"] !== undefined ? data["fullLeftContext"].map((item: any) => (String(item))) : undefined,
    fullRightContext: data["fullRightContext"] !== undefined ? data["fullRightContext"].map((item: any) => (String(item))) : undefined,
    originalTargetDocid: data["originalTargetDocid"] !== undefined ? String(data["originalTargetDocid"]) : undefined,
    source: data["source"] !== undefined ? serializeAnchorsAnchorSource(data["source"]) : undefined,
    timestamp: data["timestamp"] !== undefined ? String(data["timestamp"]) : undefined,
  };
}

function deserializeAnchorsAnchor(data: any): AnchorsAnchor {
  return {
    ...data,
    compressedImageUrls: data["compressedImageUrls"] !== undefined ? data["compressedImageUrls"].map((item: any) => (decodeBase64(item as string))) : undefined,
    compressedOriginalTargetUrl: data["compressedOriginalTargetUrl"] !== undefined ? decodeBase64(data["compressedOriginalTargetUrl"] as string) : undefined,
    fullLeftContext: data["fullLeftContext"] !== undefined ? data["fullLeftContext"].map((item: any) => (BigInt(item))) : undefined,
    fullRightContext: data["fullRightContext"] !== undefined ? data["fullRightContext"].map((item: any) => (BigInt(item))) : undefined,
    originalTargetDocid: data["originalTargetDocid"] !== undefined ? BigInt(data["originalTargetDocid"]) : undefined,
    source: data["source"] !== undefined ? deserializeAnchorsAnchorSource(data["source"]) : undefined,
    timestamp: data["timestamp"] !== undefined ? BigInt(data["timestamp"]) : undefined,
  };
}

/**
 * attributes of the source document for the link
 */
export interface AnchorsAnchorSource {
  /**
   * Additional information related to the source, such as news hub info.
   */
  additionalInfo?: Proto2BridgeMessageSet;
  /**
   * anchor++ cluster id
   */
  cluster?: number;
  /**
   * compressed source url
   */
  compressedUrl?: Uint8Array;
  /**
   * Source page crawl timestamp.
   */
  crawlTimestamp?: bigint;
  /**
   * The docid field used to be "required", but it is now "optional" because it
   * is not present when anchors are stored in webtable. When anchors are stored
   * as part of docjoin files in the segment indexer, however, docid should be
   * considered required.
   */
  docid?: bigint;
  /**
   * necessary for anything?
   */
  doclength?: number;
  /**
   * Information about if the source page is a home page. It can be one of the
   * enum values defined in PerDocData::HomePageInfo (NOT_HOMEPAGE, NOT_TRUSTED,
   * PARTIALLY_TRUSTED, and FULLY_TRUSTED).
   */
  homePageInfo?: number;
  /**
   * uint16 scale
   */
  indyrank?: number;
  /**
   * DEPRECATED, use packed_ipaddress
   */
  ipaddr?: number;
  /**
   * default -> English
   */
  language?: number;
  /**
   * 0 -> no hash
   */
  linkhash?: bigint;
  /**
   * Countries to which the source page is local/most relevant; stored as III
   * identifiers for country/region codes (see http://go/iii).
   */
  localCountryCodes?: number[];
  /**
   * This NSR value has range [0,1000] and is the original value [0.0,1.0]
   * multiplied by 1000 rounded to an integer.
   */
  nsr?: number;
  outdegree?: number;
  /**
   * approx num of pointed-to sites
   */
  outsites?: number;
  /**
   * string in IPAddress::ToPackedString() format.
   */
  packedIpaddress?: Uint8Array;
  /**
   * uint16 scale
   */
  pagerank?: number;
  /**
   * unit16 scale
   */
  pagerankNs?: number;
  /**
   * Page tags are described by enum PageTag in PerDocData. Page tags are used
   * in anchors to identify properties of the linking page. These are
   * DEPRECATED: in the future, use link_tags instead. DEPRECATED
   */
  pageTags?: number[];
  /**
   * DEPRECATED
   */
  seglanguage?: number;
  site?: string;
  /**
   * uint16 scale
   */
  spamrank?: number;
  /**
   * deprecated, to be removed after October 20. 0-127 scale
   */
  spamscore1?: number;
  /**
   * 0-127 scale
   */
  spamscore2?: number;
  /**
   * Webtable key of source
   */
  webtableKey?: string;
}

function serializeAnchorsAnchorSource(data: any): AnchorsAnchorSource {
  return {
    ...data,
    compressedUrl: data["compressedUrl"] !== undefined ? encodeBase64(data["compressedUrl"]) : undefined,
    crawlTimestamp: data["crawlTimestamp"] !== undefined ? String(data["crawlTimestamp"]) : undefined,
    docid: data["docid"] !== undefined ? String(data["docid"]) : undefined,
    linkhash: data["linkhash"] !== undefined ? String(data["linkhash"]) : undefined,
    packedIpaddress: data["packedIpaddress"] !== undefined ? encodeBase64(data["packedIpaddress"]) : undefined,
  };
}

function deserializeAnchorsAnchorSource(data: any): AnchorsAnchorSource {
  return {
    ...data,
    compressedUrl: data["compressedUrl"] !== undefined ? decodeBase64(data["compressedUrl"] as string) : undefined,
    crawlTimestamp: data["crawlTimestamp"] !== undefined ? BigInt(data["crawlTimestamp"]) : undefined,
    docid: data["docid"] !== undefined ? BigInt(data["docid"]) : undefined,
    linkhash: data["linkhash"] !== undefined ? BigInt(data["linkhash"]) : undefined,
    packedIpaddress: data["packedIpaddress"] !== undefined ? decodeBase64(data["packedIpaddress"] as string) : undefined,
  };
}

/**
 * NOTE: in docjoins, the following anchor sampling information is only ##
 * available in the first record of a document (under the same docid). The total
 * number of redundant anchors dropped per (domain, text) in linkextractor. If
 * we receive a large number of anchors from a particular domain, then we'll
 * throw out all but a sampling of them from that domain. The data is sorted by
 * the (domain,text) pairs. This field is not populated by Alexandria, which
 * uses cdoc.anchor_stats instead.
 */
export interface AnchorsRedundantAnchorInfo {
  anchorsDropped?: bigint;
  domain?: string;
  text?: string;
}

function serializeAnchorsRedundantAnchorInfo(data: any): AnchorsRedundantAnchorInfo {
  return {
    ...data,
    anchorsDropped: data["anchorsDropped"] !== undefined ? String(data["anchorsDropped"]) : undefined,
  };
}

function deserializeAnchorsRedundantAnchorInfo(data: any): AnchorsRedundantAnchorInfo {
  return {
    ...data,
    anchorsDropped: data["anchorsDropped"] !== undefined ? BigInt(data["anchorsDropped"]) : undefined,
  };
}

/**
 * Represents a GSuite customer ID. Obfuscated with CustomerIdObfuscator.
 */
export interface AppsDynamiteCustomerId {
  customerId?: string;
}

/**
 * Contains info about the entity that something is, or is owned by.
 */
export interface AppsDynamiteSharedOrganizationInfo {
  consumerInfo?: AppsDynamiteSharedOrganizationInfoConsumerInfo;
  customerInfo?: AppsDynamiteSharedOrganizationInfoCustomerInfo;
}

/**
 * Intentionally empty. Used to disambiguate consumer and customer use cases in
 * oneof below.
 */
export interface AppsDynamiteSharedOrganizationInfoConsumerInfo {
}

export interface AppsDynamiteSharedOrganizationInfoCustomerInfo {
  customerId?: AppsDynamiteCustomerId;
}

/**
 * A DestinationStream is a /namespace/id[0]/id[1]/.../id[n] that represents a
 * collection of Activities. Example destinations: -The Profile Stream on
 * http://plus.google.com/+JohnDoe/posts -A Square Stream on
 * http://plus.google.com/squares/123 -A "comment Stream" (Fountain) on
 * http://www.youtube.com/watch?id=123 It's possible for a single Activity to
 * show in each of these destinations - and it might behave/look slightly
 * differently for each one. Destinations can have their own business logic
 * associated with them at both write-time and read-time server-side (these are
 * documented below). Each DestinationStream is indexed and can be retrieved
 * using the GetDestinationStreamRequest. For the repeated ID space indexing
 * happens at all levels, e.g. if you have: /square/123/abc /square/123/efd
 * /square/456 You can fetch /square/123/abc directly or /square/123 (which
 * includes all Activities in both /square/123/abc and /square/123/efd), or even
 * /square which retrieves all Activities in the Square namespace (visible for
 * that user). On the storage layer, we represent DestinationStream as Channel
 * (http://cs/#google3/social/common/channel/channel.proto), since the storage
 * does not have the concept of a Stream. Both terms are used interchangeably
 * within the service layer, but client of Social Infrastructure should use the
 * term DestinationStream. Next ID: 3
 */
export interface AppsPeopleActivityBackendDestinationStream {
  /**
   * The hierarchy of IDs. Each individual ID is "flat" and the repeated list
   * defines the hierarchy. Namespaces define the "validity" of this hierachy
   * (depth, naming convention, etc) and the server will reject invalid IDs.
   */
  id?: string[];
  namespace?:  | "UNKNOWN_DESTINATION_NAMESPACE" | "SQUARES" | "FOUNTAIN" | "PROFILE" | "COLLEXIONS" | "TEST" | "HIGHLIGHT" | "SOCIETY" | "MEMEGEN" | "PHOTOS" | "SUPPLY_CHAIN_CENTRAL" | "PAISA" | "SOCIETY_CHAT" | "PLUS_ENTERPRISE_LOG" | "SEARCH_UGC" | "LOUPE" | "MINDSEARCH" | "SOS_LIVE_COMMENTS" | "SBE_LOADTEST" | "SYSTEM1" | "G_PLUS" | "YOUTUBE" | "EVENTS" | "DEPRECATED_COLLECTIONS" | "REVIEWS" | "BACKSTAGE" | "SPACES";
}

/**
 * Stores the number of different kind of user engagement actions. Abuse Report
 * is also consider an engagement. Currently we only have abuse report
 * engagements but in future we might add other types of engagements as well.
 */
export interface AppsPeopleActivityStreamqualityDistillerEngagements {
  /**
   * Corresponds on "This account might be compromised or hacked" reporting
   * action.
   */
  reportCompromised?: bigint;
  /**
   * Corresponds on "Harassment or bullying" reporting action.
   */
  reportHarassment?: bigint;
  /**
   * Corresponds on "Hate speach or graphic violence" reporting action.
   */
  reportHate?: bigint;
  /**
   * Corresponds on "Pornography or sexually explicit material" reporting
   * action.
   */
  reportPorn?: bigint;
  /**
   * Corresponds on "Unwanted commercial content or spam" reporting action.
   */
  reportSpam?: bigint;
  /**
   * Number of times this activity was served out of asbe/stanza.
   */
  serveCount?: bigint;
  /**
   * Timestamp in seconds for which time this record is valid.
   */
  timeSec?: bigint;
  /**
   * Corresponds on Distiller comment thumbs down action.
   */
  ytThumbsDown?: bigint;
}

function serializeAppsPeopleActivityStreamqualityDistillerEngagements(data: any): AppsPeopleActivityStreamqualityDistillerEngagements {
  return {
    ...data,
    reportCompromised: data["reportCompromised"] !== undefined ? String(data["reportCompromised"]) : undefined,
    reportHarassment: data["reportHarassment"] !== undefined ? String(data["reportHarassment"]) : undefined,
    reportHate: data["reportHate"] !== undefined ? String(data["reportHate"]) : undefined,
    reportPorn: data["reportPorn"] !== undefined ? String(data["reportPorn"]) : undefined,
    reportSpam: data["reportSpam"] !== undefined ? String(data["reportSpam"]) : undefined,
    serveCount: data["serveCount"] !== undefined ? String(data["serveCount"]) : undefined,
    timeSec: data["timeSec"] !== undefined ? String(data["timeSec"]) : undefined,
    ytThumbsDown: data["ytThumbsDown"] !== undefined ? String(data["ytThumbsDown"]) : undefined,
  };
}

function deserializeAppsPeopleActivityStreamqualityDistillerEngagements(data: any): AppsPeopleActivityStreamqualityDistillerEngagements {
  return {
    ...data,
    reportCompromised: data["reportCompromised"] !== undefined ? BigInt(data["reportCompromised"]) : undefined,
    reportHarassment: data["reportHarassment"] !== undefined ? BigInt(data["reportHarassment"]) : undefined,
    reportHate: data["reportHate"] !== undefined ? BigInt(data["reportHate"]) : undefined,
    reportPorn: data["reportPorn"] !== undefined ? BigInt(data["reportPorn"]) : undefined,
    reportSpam: data["reportSpam"] !== undefined ? BigInt(data["reportSpam"]) : undefined,
    serveCount: data["serveCount"] !== undefined ? BigInt(data["serveCount"]) : undefined,
    timeSec: data["timeSec"] !== undefined ? BigInt(data["timeSec"]) : undefined,
    ytThumbsDown: data["ytThumbsDown"] !== undefined ? BigInt(data["ytThumbsDown"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiAbout {
  contentType?:  | "TEXT_PLAIN" | "TEXT_HTML";
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * Sanitized HTML value that is only populated when the SANITIZE_ABOUT_HTML
   * extension is requested.
   */
  safeHtmlValue?: WebutilHtmlTypesSafeHtmlProto;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiAbout(data: any): AppsPeopleOzExternalMergedpeopleapiAbout {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiAbout(data: any): AppsPeopleOzExternalMergedpeopleapiAbout {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Extension data for use in AboutMe.
 */
export interface AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedData {
  nameDisplayOptions?: AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataNameDisplayOptions;
  photosCompareData?: AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataPhotosCompareData;
  profileEditability?: AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataProfileEditability;
  profileNameModificationHistory?: AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataProfileNameModificationHistory;
}

function serializeAppsPeopleOzExternalMergedpeopleapiAboutMeExtendedData(data: any): AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedData {
  return {
    ...data,
    photosCompareData: data["photosCompareData"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataPhotosCompareData(data["photosCompareData"]) : undefined,
    profileNameModificationHistory: data["profileNameModificationHistory"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataProfileNameModificationHistory(data["profileNameModificationHistory"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiAboutMeExtendedData(data: any): AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedData {
  return {
    ...data,
    photosCompareData: data["photosCompareData"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataPhotosCompareData(data["photosCompareData"]) : undefined,
    profileNameModificationHistory: data["profileNameModificationHistory"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataProfileNameModificationHistory(data["profileNameModificationHistory"]) : undefined,
  };
}

/**
 * See NameDisplayOptions in //depot/google3/focus/backend/proto/backend.proto.
 * See also go/nickname-mess.
 */
export interface AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataNameDisplayOptions {
  nicknameOption?:  | "UNKNOWN_NICKNAME_OPTION" | "QUOTED_NICKNAME" | "PAREN_NICKNAME";
}

export interface AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataPhotosCompareData {
  diffData?: AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataPhotosCompareDataDiffData;
  highResUrl?: string;
  /**
   * True if photo diff is greater than 0.01 on any color band, or if the user
   * has a low res photo but no high res photo. This field is primarily for use
   * in About Me and for other uses it's recommended to use the DiffData values
   * directly instead. The cutoff is based on a heuristic determined in
   * go/comparing-profile-photos
   */
  inconsistentPhoto?: boolean;
  /**
   * Only present if the photo diff is greater than 0.01 on any color band.
   */
  lowResData?: Uint8Array;
  lowResUrl?: string;
  monogramUrl?: string;
  /**
   * True if the low-res photo has a private ACL set.
   */
  privateLowResAcl?: boolean;
}

function serializeAppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataPhotosCompareData(data: any): AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataPhotosCompareData {
  return {
    ...data,
    lowResData: data["lowResData"] !== undefined ? encodeBase64(data["lowResData"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataPhotosCompareData(data: any): AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataPhotosCompareData {
  return {
    ...data,
    lowResData: data["lowResData"] !== undefined ? decodeBase64(data["lowResData"] as string) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataPhotosCompareDataDiffData {
  blueDiff?: number;
  greenDiff?: number;
  redDiff?: number;
}

/**
 * See UserEditedLockedMask in
 * //depot/google3/focus/backend/proto/backend.proto.
 */
export interface AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataProfileEditability {
  /**
   * Read-only set of zero or more field paths that are locked for update on
   * this person, such as "person.name", "person.email", etc. The set of fields
   * is only populated for the requester's profile. Fields in the set cannot be
   * edited, added, or deleted from the profile. Attempting to update any of
   * these fields will result in an exception.
   */
  lockedField?: string[];
}

/**
 * See ABUSE_NAME_LAST_MODIFIED in
 * //depot/google3/focus/backend/proto/backend.proto which maps to
 * //depot/google3/focus/proto/profileattribute.proto
 */
export interface AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataProfileNameModificationHistory {
  /**
   * The number of name changes remaining at RPC request time. This can be more
   * than name_changes_remaining, if user hasn't changed name for some time and
   * accrued quota since last change.
   */
  computedNameChangesRemaining?: number;
  /**
   * The number of nickname changes remaining at RPC request time. This can be
   * more than nickname_changes_remaining, if user hasn't changed nickname for
   * some time and accrued quota since last change.
   */
  computedNicknameChangesRemaining?: number;
  /**
   * The number of name changes remaining at the time the name was last
   * modified.
   */
  nameChangesRemaining?: number;
  /**
   * The last time the profile name was modified in milliseconds UTC.
   */
  nameLastModified?: bigint;
  /**
   * The number of nickname changes remaining at the time the nickname was last
   * modified.
   */
  nicknameChangesRemaining?: number;
  /**
   * The last time the profile nickname was modified in milliseconds UTC.
   */
  nicknameLastModified?: bigint;
  quotaEnforcementStatus?:  | "UNKNOWN_QUOTA_ENFORCEMENT_STATUS" | "ENFORCED" | "NOT_ENFORCED" | "NOT_APPLICABLE";
}

function serializeAppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataProfileNameModificationHistory(data: any): AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataProfileNameModificationHistory {
  return {
    ...data,
    nameLastModified: data["nameLastModified"] !== undefined ? String(data["nameLastModified"]) : undefined,
    nicknameLastModified: data["nicknameLastModified"] !== undefined ? String(data["nicknameLastModified"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataProfileNameModificationHistory(data: any): AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedDataProfileNameModificationHistory {
  return {
    ...data,
    nameLastModified: data["nameLastModified"] !== undefined ? BigInt(data["nameLastModified"]) : undefined,
    nicknameLastModified: data["nicknameLastModified"] !== undefined ? BigInt(data["nicknameLastModified"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiAccountEmail {
  email?: string;
}

/**
 * Additional information about a container. TO BE DELETED: replaced by
 * DeviceContactInfo.
 */
export interface AppsPeopleOzExternalMergedpeopleapiAdditionalContainerInfo {
  /**
   * When the container is a DEVICE_CONTACT, this list provides account
   * information from the raw contact which is the source of this field.
   */
  rawDeviceContactInfo?: AppsPeopleOzExternalMergedpeopleapiRawDeviceContactInfo[];
}

function serializeAppsPeopleOzExternalMergedpeopleapiAdditionalContainerInfo(data: any): AppsPeopleOzExternalMergedpeopleapiAdditionalContainerInfo {
  return {
    ...data,
    rawDeviceContactInfo: data["rawDeviceContactInfo"] !== undefined ? data["rawDeviceContactInfo"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiRawDeviceContactInfo(item))) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiAdditionalContainerInfo(data: any): AppsPeopleOzExternalMergedpeopleapiAdditionalContainerInfo {
  return {
    ...data,
    rawDeviceContactInfo: data["rawDeviceContactInfo"] !== undefined ? data["rawDeviceContactInfo"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiRawDeviceContactInfo(item))) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiAddress {
  country?: string;
  countryCode?: string;
  /**
   * FeatureId associated with the address. The format is the same as that used
   * for ids in PLACE containers in SourceIdentity.
   */
  encodedPlaceId?: string;
  extendedAddress?: string;
  formatted?: string;
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  locality?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  poBox?: string;
  pointSpec?: AppsPeopleOzExternalMergedpeopleapiPointSpec;
  postalCode?: string;
  region?: string;
  streetAddress?: string;
  /**
   * The type of the address. The type can be free form or one of these
   * predefined values: * `home` * `work` * `other`
   */
  type?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiAddress(data: any): AppsPeopleOzExternalMergedpeopleapiAddress {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiAddress(data: any): AppsPeopleOzExternalMergedpeopleapiAddress {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Similar to social.graph.storage.Affinity, but pared down to what the clients
 * of the People API are interested in.
 */
export interface AppsPeopleOzExternalMergedpeopleapiAffinity {
  /**
   * Contains extra ranking information returned by DAS.
   */
  affinityMetadata?: SocialGraphWireProtoPeopleapiAffinityMetadata;
  affinityType?:  | "AFFINITY_TYPE_UNKNOWN" | "EMAIL_AUTOCOMPLETE" | "CONTACTS_PLUS_FREQUENTLY_CONTACTED" | "CHAT_AUTOCOMPLETE" | "GPLUS_AUTOCOMPLETE" | "GLASS_AFFINITY" | "PEOPLE_AUTOCOMPLETE_SOCIAL" | "FIELD_AUTOCOMPLETE_SOCIAL" | "CONTACTS_PLUS_EMAIL" | "PHOTOS_PEOPLE_TO_SHARE_WITH_SUGGESTIONS" | "PHOTOS_FIELDS_TO_SHARE_WITH_SUGGESTIONS" | "INBOX_AFFINITY" | "DYNAMITE_AFFINITY" | "PHOTOS_SUGGESTIONS_AFFINITY" | "PHOTOS_SUGGESTED_TARGETS" | "PHOTOS_ASSISTANT_SUGGESTIONS_AFFINITY" | "DRIVE_AUTOCOMPLETE" | "WALLET_PEOPLE_TO_PAY_SUGGESTIONS" | "CONTACTS_PLUS_CONTACT_CENTRIC" | "POMEROY_AFFINITY" | "CALENDAR_AFFINITY" | "SPACES_APP_PEOPLE_AFFINITY" | "HOMEROOM_AFFINITY" | "PEOPLE_PLAYGROUND_AFFINITY" | "FAMILY_AFFINITY" | "CONTACTS_ASSISTANT_SUGGESTED_CONTACTS" | "TRIPS_AFFINITY" | "GOOGLE_VOICE_AFFINITY" | "PHOTOS_FACE_AFFINITY" | "G3DOC_AUTOCOMPLETE" | "LOUPE_SUGGESTIONS_AFFINITY" | "MAPS_SHARING_AFFINITY" | "CLOUD_SEARCH_AFFINITY" | "YOUTUBE_UNPLUGGED" | "JAM_AFFINITY" | "ITEM_SUGGEST_AFFINITY" | "ISSUE_TRACKER_AFFINITY" | "APPS_ASSISTANT_AFFINITY" | "APDL_CONTACT_CENTRIC_DEFAULT_AFFINITY" | "APDL_PROFILE_CENTRIC_DEFAULT_AFFINITY" | "SOCIAL_RECOVERY" | "TEZ_AFFINITY" | "NEWS_AFFINITY" | "ALLO_AFFINITY" | "GPLUS_PEOPLE_RECOMMENDATIONS" | "GPLUS_PEOPLE_RECOMMENDATIONS_SAME_DOMAIN" | "DRIVE_AFFINITY" | "PODIUM_AFFINITY" | "ZOOM_SIGHTS_EMAIL_AFFINITY" | "AIRDROME_AFFINITY" | "HANGOUTS_MEET_AFFINITY" | "GALLERY_AFFINITY" | "AGSA_AFFINITY" | "PAY_AFFINITY" | "SAVES_AFFINITY" | "JASPER_AFFINITY" | "GOOGLE_HOME_APP_AFFINITY" | "TOPAZ_TEAMS_AFFINITY" | "DYNAMITE_OUT_OF_DOMAIN_AFFINITY" | "GOOGLE_VOICE_SIRI_EXTENSION_AFFINITY" | "COURSE_KIT_AFFINITY" | "FORMS_AFFINITY" | "NOVITAS_AFFINITY" | "GTI_PEER_INTERACTIONS_AFFINITY" | "ANDROID_EMERGENCY_AFFINITY" | "DATA_STUDIO_AFFINITY" | "SPUR_AFFINITY" | "PLAY_GAMES_SERVICES_AFFINITY" | "GROUPS_ADD_MEMBER_AFFINITY" | "DUO_AFFINITY" | "MY_BUSINESS_AFFINITY" | "GMAIL_COMPOSE" | "NON_GPLUS_AFFINITY" | "ABUSE_AFFINITY" | "ABUSE_AFFINITY_LITE" | "CALENDAR_PEEK_AFFINITY" | "HUB_CALL_AFFINITY" | "GSUITE_WORKFLOW_AFFINITY" | "VR_POLY_PRO_AFFINITY" | "TASKS_AFFINITY" | "GOOGLE_ONE_AFFINITY" | "TRAVEL_AFFINITY" | "GEO_DISCOVERY_FOLLOW_AFFINITY" | "GMAIL_WEB_AFFINITY" | "ASSISTANT_SETTINGS_WEB_UI_AFFINITY" | "ARTIFEX_AFFINITY" | "CONTACT_STORE_DEFAULT_AFFINITY" | "CONTACT_STORE_SELF_EXCLUSIVE" | "PHOTOS_FACE_STALE_AFFINITY" | "LANDSPEEDER_AFFINITY" | "GOOGLE_FI_AFFINITY" | "CONTACTS_PLUS_DOMAIN_ONLY" | "PHOTOS_SUGGESTED_TARGETS_IN_APP_ONLY" | "SOCIETY_AFFINITY" | "NANDHI_TEST_SCHEDULER_AFFINITY" | "HIJACKING_HIGH_RISK_AFFINITY" | "TRUECOLOURS_AFFINITY" | "ESPRESSO_AFFINITY" | "TAG_AFFINITY" | "CORPBOT_AFFINITY" | "SHOPPING_LIST_AFFINITY" | "INTEGRATION_PLATFORM_AFFINITY" | "HOT_ORDERS_UI_AFFINITY" | "TELLY_MOBILE_APP_AFFINITY" | "NGA_SUGGESTION_RESOLUTION_AFFINITY" | "DUC_COMPANION_AFFINITY" | "TOG_AFFINITY" | "ANDROID_SYSTEM_INTELLIGENCE_AFFINITY" | "EARTH_AFFINITY" | "SHORTCUT_AFFINITY" | "CHROME_OS_SCALING_AFFINITY" | "SHOWTIME_AFFINITY" | "PLAY_GAMES_SERVICES_EXPERIMENTAL" | "GUPPEEPS_AFFINITY" | "NEST_AFFINITY" | "BLOGGER_AFFINITY" | "INDIVIDUAL_OUTGOING_INTERACTIONS_RECENCY_RANK" | "ASSISTANT_TOOLCHAIN_AFFINITY" | "CHAT_CONSERVER_FAVORITE_CONTACTS_AFFINITY" | "CHAT_CONSERVER_INVITEE_AFFINITY" | "GANTRY_AFFINITY" | "KINTARO_AFFINITY" | "KEEP_AFFINITY" | "INCIDENTFLOW_AFFINITY" | "DRIVE_MENTION_AFFINITY" | "DRIVE_LOOKUP_AFFINITY" | "PODCASTS_MANAGER_AFFINITY" | "EMAIL_AUTOCOMPLETE_GG" | "ONE_REVIEWER_TOOL_AFFINITY" | "ASSISTANT_FAMILY_VERTICAL_AFFINITY" | "STADIA_AFFINITY" | "ATLAS_AFFINITY" | "CONSTELLATION_AFFINITY" | "CORONADO_AFFINITY" | "WALLET_GOLDEN_GATE_AFFINITY" | "PUMICE_AFFINITY" | "DEMO_AFFINITY_DEFAULT_ALGO" | "DEMO_AFFINITY_DEFAULT_ALGO_DOMAIN_ONLY" | "DEMO_AFFINITY_EMAIL_ALGO" | "DEMO_AFFINITY_EMAIL_ALGO_DOMAIN_ONLY" | "BACKLIGHT_AFFINITY" | "DYNAMITE_GROUPS_AFFINITY" | "DYNAMITE_OUT_OF_DOMAIN_GROUPS_AFFINITY" | "GLOSSARY_MANAGER_AFFINITY" | "ONEDEV_WORKFLOW_AFFINITY" | "GSUITE_HUB_CALL_AFFINITY" | "AVALANCHE_AFFINITY" | "SANDTROUT_DEVICE_CONTACTS_AFFINITY" | "DYNAMITE_ROOM_AFFINITY" | "DESKBOOKING_AFFINITY" | "TEZ_EXTENDED_AFFINITY" | "DRIVE_PROFILE_ONLY_AFFINITY" | "OFFSEC_AFFINITY" | "GOOGLE_HOME_FAMILY_AFFINITY" | "ONEMARKET_CALENDAR_AFFINITY" | "GPAY_MERCHANT_CONSOLE_AFFINITY" | "WORDFLOW_AFFINITY" | "YOUTUBE_CREATOR_STUDIO_AFFINITY" | "BRICKS_AFFINITY" | "BUG_OBSERVER_AFFINITY" | "ALPHASCHEDULE_AFFINITY" | "BURROW_AFFINITY" | "TEAMSPACES_AFFINITY" | "GMAIL_SMARTADDRESS_REPLACE_AFFINITY" | "GMAIL_SMARTADDRESS_EXPAND_AFFINITY" | "ASSISTANT_OPA_AFFINITY" | "POLYGLOT_AFFINITY" | "TRANSLATION_MEMORY_MANAGER_AFFINITY" | "THREADIT_AFFINITY" | "RESOURCE_SYMPHONY_AFFINITY" | "HOUSEHOLD_CONTACTS_PICKER_AFFINITY" | "L10N_INFRA_SHARED_AFFINITY" | "WORK_TRACKER_AFFINITY" | "ARIANE_AFFINITY" | "DRIVE_ROOM_AFFINITY" | "MOMA_SEARCH_AFFINITY" | "COLAB_INTERNAL_AFFINITY" | "COLAB_EXTERNAL_AFFINITY" | "TALENT_GROW_AFFINITY" | "SOCIAL_CONNECTION_CHECKER_AFFINITY" | "GMS_PEOPLE_AFFINITY" | "ROCKET_LABS_AFFINITY" | "DYNAMITE_ROOM_AND_INDIVIDUAL_ONLY_AFFINITY" | "TEZ_PHONE_SEARCH_AFFINITY" | "MY_GOOGLE_FAMILIES_AFFINITY" | "DYNAMITE_UNIFIED_AFFINITY" | "SHORTCUT_SERVER_AFFINITY" | "LEGAL_CONTRACTS_AFFINITY" | "CALENDAR_WEB_AFFINITY" | "DATA_CATALOG_AFFINITY" | "BRIEF_API_AFFINITY" | "HARDWARE_MFG_DATA_VENUS_AFFINITY" | "BETTERBUG_AFFINITY" | "DCMS_AFFINITY" | "PLAY_BOOKS_PUBENG_AFFINITY" | "YAQS_AFFINITY" | "RESPONSIBLE_FEATURE_ACCESS_AFFINITY" | "PROSPER_AFFINITY" | "PEOPLE_TO_ADD_BIRTHDAY_FOR_AFFINITY" | "FLOURISH_AFFINITY" | "CAMPAIGN_MANAGEMENT_TOOL_AFFINITY" | "RECORDER_AFFINITY" | "CLASSROOM_SEARCH_AFFINITY" | "HIRING_AFFINITY" | "DATACENTER_SOFTWARE_AFFINITY" | "PHOTOS_INVITE_AFFINITY" | "PHOTOS_PARTNER_SHARING_AFFINITY" | "MARKETING_WORKFLOWS_AFFINITY" | "INTROSPECT_AFFINITY" | "YOUTUBE_PARENT_TOOLS_AFFINITY" | "RELIABILITY_INSIGHTS_PST_AFFINITY" | "GMAIL_ANDROID_AFFINITY" | "CUSTOMER_CARE_PORTAL_AFFINITY" | "MOMAHOME_3C_AFFINITY" | "DIGITAL_CAR_KEY_AFFINITY" | "PLAY_BOOKS_DISTRIBUTION_AFFINITY" | "GOOGLE_ASSIGNMENTS_AFFINITY" | "TEST_FUSION_AFFINITY" | "PRODUCTION2020_UIE_AFFINITY" | "SPEAKEASY_AFFINITY" | "DOCS_TASKS_AFFINITY" | "DYNAMITE_SEARCH_AFFINITY" | "GPAY_RELEASE_OPS_AFFINITY" | "VOICE_PBX_AFFINITY" | "VOICE_WEB_AFFINITY" | "SKILLSSTACK_AFFINITY" | "WHOSTORY_AFFINITY" | "PHOTOS_PARTNER_SHARING_EMAIL_ONLY" | "MEMORIZE_AFFINITY" | "BETTANY_AFFINITY" | "BASECAMP_AFFINITY" | "DRIVE_SEARCH_FILTER_AFFINITY" | "CULTURE_EVENTS_CALENDAR_AFFINITY" | "DATABRIDGE_CONSOLE_AFFINITY" | "COMMSTAR_AFFINITY" | "CDDB_AFFINITY" | "DATA_STUDIO_SPACES_AFFINITY" | "SOJI_AFFINITY" | "PLAY_MOVIES_ANDROID_AFFINITY" | "DATA_STUDIO_DOMAIN_ONLY_AFFINITY" | "MONOSPACE_AFFINITY" | "MY_ACCOUNT_AFFINITY" | "NUDGEIT_CAMPAIGN_MANAGER_AFFINITY" | "LEGAL_CONTRACTS_EXTERNAL_AFFINITY" | "CONTACTS_TO_STAR_AFFINITY" | "DECS_AFFINITY";
  /**
   * The ID of the container
   */
  containerId?: string;
  /**
   * The type of container to which this affinity applies
   */
  containerType?:  | "UNKNOWN_CONTAINER" | "PROFILE" | "CONTACT" | "CIRCLE" | "PLACE" | "ACCOUNT" | "EXTERNAL_ACCOUNT" | "DOMAIN_PROFILE" | "DOMAIN_CONTACT" | "DEVICE_CONTACT" | "GOOGLE_GROUP" | "NAMED_CHAT_ROOM" | "UNNAMED_CHAT_ROOM" | "AFFINITY" | "RAW_DEVICE_CONTACT" | "CONTACT_ANNOTATION" | "DELEGATED_CONTACT";
  /**
   * Used to log events for this affinity value, for disco diagnostic-purposes.
   * See go/disco-diagnostics.
   */
  loggingId?: string;
  /**
   * Affinity value. Frequently represented as an inverse ranking, sometimes
   * with additional data encoded. If data_formats.affinity_formats.score_format
   * is set to RAW_SCORE then the value will be the score returned by DAS.
   */
  value?: number;
}

/**
 * Please read go/people-api-howto:age on how to get age data. Message for the
 * `Person.age_range_repeated` field. Replaces the existing `Person.age_range`
 * field.
 */
export interface AppsPeopleOzExternalMergedpeopleapiAgeRangeType {
  /**
   * Please read go/people-api-howto:age on how to get age data. Age of the
   * user. The field is set based on profile storage fields such as account
   * birthday. If the source fields are not present, `age_in_years` will be left
   * unset.
   */
  ageInYears?: number;
  /**
   * Deprecated. Use go/supervised-accounts#capabilities-for-child-accounts
   * instead. Denotes whether the user is under the region based Age of Consent.
   * The user's region is based on ClientUserInfo.GlobalTos.AgreedLocation The
   * age is inferred from Birthday field or CertifiedBornBefore field. The
   * region based AoC is specified at go/aoc.
   */
  ageOfConsentStatus?:  | "AOC_STATUS_UNKNOWN" | "UNDER_AOC" | "AT_OR_ABOVE_AOC";
  /**
   * Deprecated. Please read go/people-api-howto:age on how to get age data.
   * Age range is populated based on `account_birthday` and
   * `certified_born_before`, which may not be set for dasher users.
   */
  ageRange?:  | "UNKNOWN" | "LESS_THAN_EIGHTEEN" | "TWENTY_ONE_OR_OLDER" | "EIGHTEEN_TO_TWENTY";
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiAgeRangeType(data: any): AppsPeopleOzExternalMergedpeopleapiAgeRangeType {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiAgeRangeType(data: any): AppsPeopleOzExternalMergedpeopleapiAgeRangeType {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Store all app unique info that are needed for app action fulfillment.
 */
export interface AppsPeopleOzExternalMergedpeopleapiAppUniqueInfo {
  /**
   * Store the app unique id endpoint. This will be passed over to app to
   * fulfill the action. For example, app_unique_id for Whatsapp will be
   * "11234567890@s.whatsapp.net"
   */
  appUniqueId?: string;
  /**
   * Store third party endpoint that is displayed to users. For example,
   * display_app_unique_id for Whatsapp will be "Message +11234567890".
   */
  displayAppUniqueId?: string;
  /**
   * Store third party endpoint label. For example, "HOME", "WORK"
   */
  label?: string;
  /**
   * Store mimetype of this endpoint. We will use this as the differentiator
   * for Assistant to know whether to use the RawContact for messaging, call or
   * video call. For example, send message mimetype for whatsapp:
   * "vnd.android.cursor.item/vnd.com.whatsapp.profile" voice call mimetype for
   * whatsapp: "vnd.android.cursor.item/vnd.com.whatsapp.voip.call"
   */
  mimetype?: string;
}

/**
 * The best suggested name to use for the Person from the available source
 * fields, which may include FileAs, Name, Org, Email, IM, Phone, ... Rough
 * source container priority order is Contact, then Profile, then Place.
 */
export interface AppsPeopleOzExternalMergedpeopleapiBestDisplayName {
  /**
   * The container the suggested name was sourced from
   */
  containerType?:  | "UNKNOWN_CONTAINER" | "PROFILE" | "CONTACT" | "CIRCLE" | "PLACE" | "ACCOUNT" | "EXTERNAL_ACCOUNT" | "DOMAIN_PROFILE" | "DOMAIN_CONTACT" | "DEVICE_CONTACT" | "GOOGLE_GROUP" | "NAMED_CHAT_ROOM" | "UNNAMED_CHAT_ROOM" | "AFFINITY" | "RAW_DEVICE_CONTACT" | "CONTACT_ANNOTATION" | "DELEGATED_CONTACT";
  /**
   * The display name. This name is intended to be the best name to display for
   * this Person. It may be built from a variety of fields, even if those fields
   * are not explicitly requested in the request mask. Generally, the display
   * name is formatted in 'first last' format. If the name appears to be a CJK
   * name (as determined by a heuristic), the 'last first' format will be used.
   * There may be other cases that the 'last first' format is used which are not
   * documented here. See the code at:
   * http://google3/java/com/google/focus/backend/client/DisplayNameFormatter.java?l=659&rcl=351360938
   */
  displayName?: string;
  /**
   * The display name, always in 'last first' format. This field does not
   * depend on the format of `display_name` and will always be in 'last first'
   * format.
   */
  displayNameLastFirst?: string;
}

/**
 * IMPORTANT NOTES: - Requesting person.birthday requires membership in the
 * purpose limited data ACL group sgbe-ac-d-birthday-(read|mutate). Contact
 * people-api-eng@ for assistance with initial setup. - The birthday field
 * should not be used to calculate the requester's age! To determine the
 * requester's age, use person.age_range_repeated. - For more details about age
 * see go/peopleapi-howto/age Birthday value may not be present: - Consumer
 * users generally required to have account birthday set (required at account
 * creation), though some users created via legacy flows may not have birthday
 * present. - Dasher users generally don't require birthday, but could
 * optionally have it set by users. - Any other types of accounts (e.g. robot,
 * service) do not have birthdays. - Account Birthday field may be present but
 * without birthday value set for grace period birthday (provisional new
 * birthday). For users that do have birthday data: - "Profile Birthday"
 * (person.birthday.metadata.container is PROFILE) may not have a year set if
 * user "hides" the year. - "Account Birthday" (see api-specific notes below)
 * will only be returned for the requester's own profile. - People API
 * (go/peopleapi): * Account birthday is only supported in GetPeople for
 * PeopleAPI. * If account birthday is needed, use a request mask with:
 * `include_field { paths: "person.birthday" }` `include_container: ACCOUNT` -
 * People API++ (go/peopleapi++): * Account birthday is supported for most apis
 * in PeopleAPI++. * If account birthday is needed, use a request mask with:
 * `include_field { paths: "person.account_birthday" }` `include_container:
 * PROFILE` (note: it will also need `include_container: DOMAIN_PROFILE` because
 * they must be requested together: go/people-api-masks#profile-domain_profile)
 * - See go/papi-vs-papi++#birthday for more details.
 */
export interface AppsPeopleOzExternalMergedpeopleapiBirthday {
  /**
   * Only supported for PROFILE/DOMAIN_PROFILE/ACCOUNT container.
   */
  ageDisableGracePeriod?: AppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriod;
  /**
   * Whether the user has opted in to display their birthday via photo
   * decorations. Only supported for PROFILE/DOMAIN_PROFILE container.
   */
  birthdayDecoration?: SocialGraphApiProtoBirthdayDecoration;
  /**
   * Only supported for PROFILE/DOMAIN_PROFILE/ACCOUNT container.
   */
  birthdayResolution?:  | "FULL" | "MONTH_AND_APPROXIMATED_YEAR" | "APPROXIMATED_YEAR";
  /**
   * Birthdays are more accurately represented as a calendar day that does not
   * depend on a timestamp representation at all. When given a timestamp, there
   * are lots of opportunities to make mistakes, so a CalendarDay proto is
   * replacing timestamps. Currently this is always returned by PeopleApi on
   * reads that include birthday fields. New clients should write using
   * calendar_day. Clients that were already writing via date_ms are allowlisted
   * such that writes use that field. Old callers should migrate to writing BOTH
   * date_ms and calendar_day values. If those are consistent, they may be
   * removed from the 'legacy_timestamp_event_write_behavior_enabled'
   * capability.
   */
  calendarDay?: GoogleTypeDate;
  /**
   * Birthdays are currently represented as timestamp values, although the
   * interpretation of these timestamp values is a calendar date. Clients are
   * recommended to read the calendar_day field, which is easier to work with
   * than date_ms. New clients writing to PeopleApi must set calendar_day
   * instead of date_ms. There are a few important details about how this value
   * should be mapped to a calendar date that should be consistent among all
   * clients. 1. Epoch - The epoch or calendar date equivalent to 0 ms is chosen
   * to be 1970-01-01 UTC. 2. Timezone - All of the conversions to calendars
   * should occur in the UTC timezone. We don't typically think of someones
   * birthday changing when they travel, so clients should not use local times.
   * 3. Calendar - The calendar used for the dates should be a Gregorian
   * proleptic calendar. Proleptic means that the rules of the Gregorian
   * calendar are retrofitted to before its adoption. It is easy to get this
   * wrong, particularly with the java GregorianCalendar class, which by default
   * is a mixed Gregorian/Julian calendar. Joda Time makes this easy, but if
   * it's not an option, look into GregorianCalendar.setGregorianChange(). 4.
   * Omitted years - Clients have chosen to represent birthdays or events
   * without years as timestamps within the year zero. When the computed date
   * has a year of 0, it means the client did not specify a year. Note that a
   * year 0 does not exist in a chronology like the familiar Anno Domini (A.D.
   * and B.C.); clients must agree on year numbering. 5. Year Numbering - The
   * chronology used to map dates to the calendar should use Astronomical Year
   * Numbering so that the year 0 is defined and dates before it have a negative
   * year. If libraries only provide Anno Domini, then the year of 1 BC
   * corresponds to year zero and an omitted user provided year. Other BC values
   * are presumed rare, but clients should still not ignore the era and
   * interpret the year as an A.D. value, especially if writing values back to
   * PeopleApi.
   */
  dateMs?: bigint;
  /**
   * date_ms_as_number contains the same data as date_ms, but has a different
   * type in generated javascript bindings. Non javascript clients can ignore
   * it.
   */
  dateMsAsNumber?: bigint;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * People Prompts settings for contact birthday data. Only supported for
   * CONTACT container.
   */
  prompt?: SocialGraphApiProtoPrompt;
  /**
   * Actual value entered. Allows unstructured values.
   */
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiBirthday(data: any): AppsPeopleOzExternalMergedpeopleapiBirthday {
  return {
    ...data,
    ageDisableGracePeriod: data["ageDisableGracePeriod"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriod(data["ageDisableGracePeriod"]) : undefined,
    dateMs: data["dateMs"] !== undefined ? String(data["dateMs"]) : undefined,
    dateMsAsNumber: data["dateMsAsNumber"] !== undefined ? String(data["dateMsAsNumber"]) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    prompt: data["prompt"] !== undefined ? serializeSocialGraphApiProtoPrompt(data["prompt"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiBirthday(data: any): AppsPeopleOzExternalMergedpeopleapiBirthday {
  return {
    ...data,
    ageDisableGracePeriod: data["ageDisableGracePeriod"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriod(data["ageDisableGracePeriod"]) : undefined,
    dateMs: data["dateMs"] !== undefined ? BigInt(data["dateMs"]) : undefined,
    dateMsAsNumber: data["dateMsAsNumber"] !== undefined ? BigInt(data["dateMsAsNumber"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    prompt: data["prompt"] !== undefined ? deserializeSocialGraphApiProtoPrompt(data["prompt"]) : undefined,
  };
}

/**
 * Whether this field is set or not determines whether an account is in the
 * grace period. While in the grace period, the user is unable to change their
 * birthday on their own, and will be age-disabled if they don't act in a
 * limited amount of time. Applies only to ServiceData Birthday. Users enter the
 * grace period if they choose a birthday below the Age of Consent (go/aoc).
 * After the grace period ends, the account will be age disabled. See
 * go/age-disable-grace-period-dd.
 */
export interface AppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriod {
  /**
   * Provisional birthday <AoC the user provided, which made them enter the
   * grace period. The main birthday fields were not altered yet while in the
   * grace period.
   */
  calendarDay?: GoogleTypeDate;
  /**
   * Timestamp which signifies the end of the grace period for this account.
   */
  gracePeriodEnd?: Date;
  /**
   * Timestamp which signifies the start of the grace period for this account.
   */
  gracePeriodStart?: Date;
  gracePeriodType?:  | "UNKNOWN" | "USER_SPECIFIED_BIRTHDAY" | "UNDERAGE_SUSPECTED";
  manualGracePeriodInfo?: AppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriodManualGracePeriodInfo;
}

function serializeAppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriod(data: any): AppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriod {
  return {
    ...data,
    gracePeriodEnd: data["gracePeriodEnd"] !== undefined ? data["gracePeriodEnd"].toISOString() : undefined,
    gracePeriodStart: data["gracePeriodStart"] !== undefined ? data["gracePeriodStart"].toISOString() : undefined,
    manualGracePeriodInfo: data["manualGracePeriodInfo"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriodManualGracePeriodInfo(data["manualGracePeriodInfo"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriod(data: any): AppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriod {
  return {
    ...data,
    gracePeriodEnd: data["gracePeriodEnd"] !== undefined ? new Date(data["gracePeriodEnd"]) : undefined,
    gracePeriodStart: data["gracePeriodStart"] !== undefined ? new Date(data["gracePeriodStart"]) : undefined,
    manualGracePeriodInfo: data["manualGracePeriodInfo"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriodManualGracePeriodInfo(data["manualGracePeriodInfo"]) : undefined,
  };
}

/**
 * Information provided within MutateDataRequest when setting a user into
 * AgeDisableGracePeriod manually. When the grace period expires, this info will
 * be forwarded to Gaia when disabling the user.
 * cs//symbol:InitiateAgeDisableGracePeriodArguments
 */
export interface AppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriodManualGracePeriodInfo {
  /**
   * The Gaia ID of an email that ops can send inquiries to for appeals.
   */
  escalateTo?: bigint;
  /**
   * The Gaia ID of a Googler who initiated this disable.
   */
  executedBy?: bigint;
  /**
   * When setting a user into age grace period manually, the requester can
   * additionally supply a short human-readable reason of why the account is put
   * into manual grace period. The description will be forwarded to Gaia when we
   * disable the account when the grace period expires.
   */
  reason?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriodManualGracePeriodInfo(data: any): AppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriodManualGracePeriodInfo {
  return {
    ...data,
    escalateTo: data["escalateTo"] !== undefined ? String(data["escalateTo"]) : undefined,
    executedBy: data["executedBy"] !== undefined ? String(data["executedBy"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriodManualGracePeriodInfo(data: any): AppsPeopleOzExternalMergedpeopleapiBirthdayAgeDisableGracePeriodManualGracePeriodInfo {
  return {
    ...data,
    escalateTo: data["escalateTo"] !== undefined ? BigInt(data["escalateTo"]) : undefined,
    executedBy: data["executedBy"] !== undefined ? BigInt(data["executedBy"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiBraggingRights {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiBraggingRights(data: any): AppsPeopleOzExternalMergedpeopleapiBraggingRights {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiBraggingRights(data: any): AppsPeopleOzExternalMergedpeopleapiBraggingRights {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * A url to the person's calendar. As of 03/2018 is not supported for user
 * Profile.
 */
export interface AppsPeopleOzExternalMergedpeopleapiCalendar {
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * The type of the calendar URL. The type can be free form or one of these
   * predefined values: * `home` * `freeBusy` * `work`
   */
  type?: string;
  url?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiCalendar(data: any): AppsPeopleOzExternalMergedpeopleapiCalendar {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiCalendar(data: any): AppsPeopleOzExternalMergedpeopleapiCalendar {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiCallerIdExtendedData {
  /**
   * Indicates which data source was used to populate the caller ID result
   */
  callerIdSource?: AppsPeopleOzExternalMergedpeopleapiCallerIdExtendedDataCallerIdSource;
}

export interface AppsPeopleOzExternalMergedpeopleapiCallerIdExtendedDataCallerIdSource {
  sourceType?:  | "UNKNOWN_SOURCE_TYPE" | "PLACE" | "SCOOBY_MANUAL" | "SCOOBY_GOOGLE_VOICE" | "SCOOBY_CSA" | "SCOOBY_KNOWLEDGE_GRAPH";
}

/**
 * Information related to domain administrator (or authority) certification of
 * a users age.
 */
export interface AppsPeopleOzExternalMergedpeopleapiCertifiedBornBefore {
  /**
   * Indicates that the user was born at or before this time.
   */
  bornBefore?: Date;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiCertifiedBornBefore(data: any): AppsPeopleOzExternalMergedpeopleapiCertifiedBornBefore {
  return {
    ...data,
    bornBefore: data["bornBefore"] !== undefined ? data["bornBefore"].toISOString() : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiCertifiedBornBefore(data: any): AppsPeopleOzExternalMergedpeopleapiCertifiedBornBefore {
  return {
    ...data,
    bornBefore: data["bornBefore"] !== undefined ? new Date(data["bornBefore"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiChannelData {
  /**
   * Unique ID that corresponds to a Youtube channel.
   */
  channelId?: string;
  /**
   * Number of comments for a given Youtube channel.
   */
  commentCount?: bigint;
  /**
   * Description of the channel.
   */
  description?: string;
  playlistCount?: bigint;
  /**
   * A FIFE URL pointing to the channel's profile image (go/avatar-fife-urls)
   * with default fife url options. Also refer to go/people-api-concepts:photos
   * for People API's FIFE best practices. The image could be up to a couple of
   * days stale, though it is much fresher in practice. If a fresh image is
   * required, contact the YouTubeAccountProfileService. The URL itself expires
   * ~30 days after generation.
   */
  profilePictureUrl?: string;
  /**
   * URL of user's Youtube channel profile.
   */
  profileUrl?: string;
  /**
   * Number of subscribers for a given Youtube channel.
   */
  subscriberCount?: bigint;
  /**
   * Title of the YouTube channel
   */
  title?: string;
  /**
   * Whether or not the channel's profile has a title/avatar that is canonical
   * in YouTube. Used to determine if the product profile card should be part of
   * the core persona or have their own persona.
   */
  usesYoutubeNames?: boolean;
  /**
   * Number of videos uploaded in a given Youtube channel.
   */
  videoCount?: bigint;
}

function serializeAppsPeopleOzExternalMergedpeopleapiChannelData(data: any): AppsPeopleOzExternalMergedpeopleapiChannelData {
  return {
    ...data,
    commentCount: data["commentCount"] !== undefined ? String(data["commentCount"]) : undefined,
    playlistCount: data["playlistCount"] !== undefined ? String(data["playlistCount"]) : undefined,
    subscriberCount: data["subscriberCount"] !== undefined ? String(data["subscriberCount"]) : undefined,
    videoCount: data["videoCount"] !== undefined ? String(data["videoCount"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiChannelData(data: any): AppsPeopleOzExternalMergedpeopleapiChannelData {
  return {
    ...data,
    commentCount: data["commentCount"] !== undefined ? BigInt(data["commentCount"]) : undefined,
    playlistCount: data["playlistCount"] !== undefined ? BigInt(data["playlistCount"]) : undefined,
    subscriberCount: data["subscriberCount"] !== undefined ? BigInt(data["subscriberCount"]) : undefined,
    videoCount: data["videoCount"] !== undefined ? BigInt(data["videoCount"]) : undefined,
  };
}

/**
 * A circle membership that the person has. A circle membership is created by
 * adding a person to a circle by person-id or by email.
 */
export interface AppsPeopleOzExternalMergedpeopleapiCircleMembership {
  /**
   * The circle that the person belongs to.
   */
  circleId?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiCircleMembership(data: any): AppsPeopleOzExternalMergedpeopleapiCircleMembership {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiCircleMembership(data: any): AppsPeopleOzExternalMergedpeopleapiCircleMembership {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Arbitrary client data that is populated based on the client
 */
export interface AppsPeopleOzExternalMergedpeopleapiClientData {
  key?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  namespace?: string;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiClientData(data: any): AppsPeopleOzExternalMergedpeopleapiClientData {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiClientData(data: any): AppsPeopleOzExternalMergedpeopleapiClientData {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Email for Google product communication with the user. This is only allowed
 * in ServiceData. It is purely synthesized and read-only, and contains at most
 * one field. It proxies from RawCommunicationEmail and only includes the
 * primary field if exists. Otherwise if RawCommunicationEmail does not have
 * primary, this includes a field synthesized from valid Gaia primary account
 * email. Otherwise if Gaia primary account email is invalid, this field is
 * empty. See go/comm-email-use for more details.
 */
export interface AppsPeopleOzExternalMergedpeopleapiCommunicationEmail {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiCommunicationEmail(data: any): AppsPeopleOzExternalMergedpeopleapiCommunicationEmail {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiCommunicationEmail(data: any): AppsPeopleOzExternalMergedpeopleapiCommunicationEmail {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Contact-level people-prompts settings and contact-level connection
 * reminders. Part of go/people-prompts.
 */
export interface AppsPeopleOzExternalMergedpeopleapiConnectionReminder {
  /**
   * Contains the Contact level settings that will affect all reminders.
   */
  contactPromptSettings?: SocialGraphApiProtoContactPromptSettings;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * Contact-level "reminder to connect" prompts for this contact.
   */
  prompt?: SocialGraphApiProtoPrompt[];
}

function serializeAppsPeopleOzExternalMergedpeopleapiConnectionReminder(data: any): AppsPeopleOzExternalMergedpeopleapiConnectionReminder {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    prompt: data["prompt"] !== undefined ? data["prompt"].map((item: any) => (serializeSocialGraphApiProtoPrompt(item))) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiConnectionReminder(data: any): AppsPeopleOzExternalMergedpeopleapiConnectionReminder {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    prompt: data["prompt"] !== undefined ? data["prompt"].map((item: any) => (deserializeSocialGraphApiProtoPrompt(item))) : undefined,
  };
}

/**
 * Contact creation timestamps and related metadata. See
 * go/contact-edit-history. This message is a pure wrapper of the shared
 * ContactCreactionContext message so that it can be a top-level person field.
 * No other fields should be added to the message.
 */
export interface AppsPeopleOzExternalMergedpeopleapiContactCreateContextInfo {
  contactCreateContext?: SocialGraphApiProtoContactCreateContext;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiContactCreateContextInfo(data: any): AppsPeopleOzExternalMergedpeopleapiContactCreateContextInfo {
  return {
    ...data,
    contactCreateContext: data["contactCreateContext"] !== undefined ? serializeSocialGraphApiProtoContactCreateContext(data["contactCreateContext"]) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiContactCreateContextInfo(data: any): AppsPeopleOzExternalMergedpeopleapiContactCreateContextInfo {
  return {
    ...data,
    contactCreateContext: data["contactCreateContext"] !== undefined ? deserializeSocialGraphApiProtoContactCreateContext(data["contactCreateContext"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Contact edit timestamps and related metadata. See go/contact-edit-history.
 * This message is a pure wrapper of the shared ContactCreactionContext message
 * so that it can be a top-level person field. No other fields should be added
 * to the message.
 */
export interface AppsPeopleOzExternalMergedpeopleapiContactEditContextInfo {
  contactEditContext?: SocialGraphApiProtoContactEditContext;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiContactEditContextInfo(data: any): AppsPeopleOzExternalMergedpeopleapiContactEditContextInfo {
  return {
    ...data,
    contactEditContext: data["contactEditContext"] !== undefined ? serializeSocialGraphApiProtoContactEditContext(data["contactEditContext"]) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiContactEditContextInfo(data: any): AppsPeopleOzExternalMergedpeopleapiContactEditContextInfo {
  return {
    ...data,
    contactEditContext: data["contactEditContext"] !== undefined ? deserializeSocialGraphApiProtoContactEditContext(data["contactEditContext"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * A membership that the person has. The person can be a member of multiple
 * circles and multiple contact-groups. A circle membership is created by adding
 * a person to a circle by person-id or by email. A contact-group membership is
 * created by adding a contact to a contact-group.
 */
export interface AppsPeopleOzExternalMergedpeopleapiContactGroupMembership {
  /**
   * The contact-group that the person belong to. The id can be either a
   * hex-formatted id or a camel-cased SystemContactGroup predefined group name.
   * The id will be predefined group name iff the system_contact_group_id has a
   * value.
   */
  contactGroupId?: string;
  /**
   * Information related to delegated group that this contact belongs to.
   */
  delegatedGroupInfo?: AppsPeopleOzExternalMergedpeopleapiDelegatedGroupInfo;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * This field will be populated when the membership is in a system-reserved
   * contact-group.
   */
  systemContactGroupId?:  | "UNKNOWN" | "MY_CONTACTS" | "STARRED" | "FRIENDS" | "FAMILY" | "COWORKERS";
}

function serializeAppsPeopleOzExternalMergedpeopleapiContactGroupMembership(data: any): AppsPeopleOzExternalMergedpeopleapiContactGroupMembership {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiContactGroupMembership(data: any): AppsPeopleOzExternalMergedpeopleapiContactGroupMembership {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Contact state and related metadata. See go/fbs-contacts-trash. This message
 * is a pure wrapper of the shared ContactState message so that it can be a
 * top-level person field. No other fields should be added to the message.
 */
export interface AppsPeopleOzExternalMergedpeopleapiContactStateInfo {
  contactState?: SocialGraphApiProtoContactState;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiContactStateInfo(data: any): AppsPeopleOzExternalMergedpeopleapiContactStateInfo {
  return {
    ...data,
    contactState: data["contactState"] !== undefined ? serializeSocialGraphApiProtoContactState(data["contactState"]) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiContactStateInfo(data: any): AppsPeopleOzExternalMergedpeopleapiContactStateInfo {
  return {
    ...data,
    contactState: data["contactState"] !== undefined ? deserializeSocialGraphApiProtoContactState(data["contactState"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * CoverPhoto is the long banner photo (also called full bleed photo) at the
 * top of G+ profile page.
 */
export interface AppsPeopleOzExternalMergedpeopleapiCoverPhoto {
  imageHeight?: number;
  imageId?: string;
  imageUrl?: string;
  imageWidth?: number;
  isAnimated?: boolean;
  isDefault?: boolean;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiCoverPhoto(data: any): AppsPeopleOzExternalMergedpeopleapiCoverPhoto {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiCoverPhoto(data: any): AppsPeopleOzExternalMergedpeopleapiCoverPhoto {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Contains customer data for profile owner proxied from D3.
 */
export interface AppsPeopleOzExternalMergedpeopleapiCustomerInfo {
  /**
   * DEPRECATED. Use obfuscated_customer_id instead. If result has a GSuite
   * Customer ID, this field will continue to be populated with -1 to indicate
   * the presence of a value for backwards compatibility with clients in the
   * wild. See b/144596193.
   */
  customerId?: bigint;
  /**
   * Customer organization name for dasher user.
   */
  customerName?: string;
  /**
   * Obfuscated FlexOrgs customer ID for Dasher user. See
   * cs/symbol:CustomerIdObfuscator.
   */
  obfuscatedCustomerId?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiCustomerInfo(data: any): AppsPeopleOzExternalMergedpeopleapiCustomerInfo {
  return {
    ...data,
    customerId: data["customerId"] !== undefined ? String(data["customerId"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiCustomerInfo(data: any): AppsPeopleOzExternalMergedpeopleapiCustomerInfo {
  return {
    ...data,
    customerId: data["customerId"] !== undefined ? BigInt(data["customerId"]) : undefined,
  };
}

/**
 * Custom fields associated with a person, from the custom schema defined on
 * the domain. See go/custompeopleapi and go/customfocus. NOTE: these are only
 * updatable via Cloud Directory (go/cd).
 */
export interface AppsPeopleOzExternalMergedpeopleapiCustomSchemaField {
  fieldDisplayName?: string;
  fieldId?: string;
  fieldType?:  | "CUSTOM_FIELD_TYPE_UNKNOWN" | "STRING" | "INT64" | "BOOL" | "DOUBLE" | "EMAIL" | "PHONE" | "DATE";
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  multiValued?: boolean;
  schemaDisplayName?: string;
  schemaId?: string;
  /**
   * The type of the custom schema field. The type can be free form or one of
   * these predefined values: * `home` * `other` * `work`
   */
  type?: string;
  /**
   * String representation of the value, based on FieldType
   */
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiCustomSchemaField(data: any): AppsPeopleOzExternalMergedpeopleapiCustomSchemaField {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiCustomSchemaField(data: any): AppsPeopleOzExternalMergedpeopleapiCustomSchemaField {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Container information for deduping. When two fields have the same value and
 * only differ by field.metadata a service implementation can choose to avoid
 * duplicating the fields and instead set
 * field.metadata.other_deduped_containers This type can include information on
 * the dedupe type (for example, strict value match vs. lenient value match)
 */
export interface AppsPeopleOzExternalMergedpeopleapiDedupedContainerInfo {
  /**
   * See SourceIdentity.container_type
   */
  containerType?:  | "UNKNOWN_CONTAINER" | "PROFILE" | "CONTACT" | "CIRCLE" | "PLACE" | "ACCOUNT" | "EXTERNAL_ACCOUNT" | "DOMAIN_PROFILE" | "DOMAIN_CONTACT" | "DEVICE_CONTACT" | "GOOGLE_GROUP" | "NAMED_CHAT_ROOM" | "UNNAMED_CHAT_ROOM" | "AFFINITY" | "RAW_DEVICE_CONTACT" | "CONTACT_ANNOTATION" | "DELEGATED_CONTACT";
  /**
   * See SourceIdentity.id
   */
  id?: string;
}

/**
 * Information related to delegated group that this contact belongs to.
 */
export interface AppsPeopleOzExternalMergedpeopleapiDelegatedGroupInfo {
  /**
   * Required. The additional id specifically for a delegated group.
   */
  delegatedGroupId?: SocialGraphApiProtoDelegatedGroupId;
}

/**
 * Extra metadata for an aggregated or raw device contact.
 */
export interface AppsPeopleOzExternalMergedpeopleapiDeviceContactExtraMetadata {
  /**
   * Attributes for this device contact.
   */
  attributes?:  | "ATTRIBUTE_UNKNOWN" | "STARRED"[];
  /**
   * Usage info for this device contact.
   */
  usageInfo?: SocialGraphApiProtoUsageInfo[];
}

function serializeAppsPeopleOzExternalMergedpeopleapiDeviceContactExtraMetadata(data: any): AppsPeopleOzExternalMergedpeopleapiDeviceContactExtraMetadata {
  return {
    ...data,
    usageInfo: data["usageInfo"] !== undefined ? data["usageInfo"].map((item: any) => (serializeSocialGraphApiProtoUsageInfo(item))) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiDeviceContactExtraMetadata(data: any): AppsPeopleOzExternalMergedpeopleapiDeviceContactExtraMetadata {
  return {
    ...data,
    usageInfo: data["usageInfo"] !== undefined ? data["usageInfo"].map((item: any) => (deserializeSocialGraphApiProtoUsageInfo(item))) : undefined,
  };
}

/**
 * Unique id for an aggregated device contact.
 */
export interface AppsPeopleOzExternalMergedpeopleapiDeviceContactId {
  /**
   * Aggregated device contact id on the source device.
   */
  contactId?: bigint;
  /**
   * Source device id (go/client-instance-id) of this device contact.
   */
  deviceId?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiDeviceContactId(data: any): AppsPeopleOzExternalMergedpeopleapiDeviceContactId {
  return {
    ...data,
    contactId: data["contactId"] !== undefined ? String(data["contactId"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiDeviceContactId(data: any): AppsPeopleOzExternalMergedpeopleapiDeviceContactId {
  return {
    ...data,
    contactId: data["contactId"] !== undefined ? BigInt(data["contactId"]) : undefined,
  };
}

/**
 * Device contact information.
 */
export interface AppsPeopleOzExternalMergedpeopleapiDeviceContactInfo {
  /**
   * Metadata for this device contact.
   */
  deviceContactMetadata?: AppsPeopleOzExternalMergedpeopleapiDeviceContactExtraMetadata;
  /**
   * Output only. True if any of the contact's phone, email or address fields
   * can be used on devices other than the one it originated from. Note that
   * there can be other fields, typically name, and metadata such as some of the
   * raw_contact_infos that can be used on other devices. Assigned by the
   * server.
   */
  hasCrossDeviceData?: boolean;
  /**
   * Id of the device contact.
   */
  id?: AppsPeopleOzExternalMergedpeopleapiDeviceContactId;
  /**
   * Last time a device contact was updated on device.
   */
  lastClientUpdateTime?: Date;
  /**
   * An opaque value used by the device to look up this contact if its row id
   * changed as a result of a sync or aggregation. See:
   * https://developer.android.com/reference/android/provider/ContactsContract.ContactsColumns.html#LOOKUP_KEY
   */
  lookupKey?: string;
  /**
   * Info about the raw device contacts that make up this device contact.
   */
  rawContactInfo?: AppsPeopleOzExternalMergedpeopleapiRawDeviceContactInfo[];
}

function serializeAppsPeopleOzExternalMergedpeopleapiDeviceContactInfo(data: any): AppsPeopleOzExternalMergedpeopleapiDeviceContactInfo {
  return {
    ...data,
    deviceContactMetadata: data["deviceContactMetadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiDeviceContactExtraMetadata(data["deviceContactMetadata"]) : undefined,
    id: data["id"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiDeviceContactId(data["id"]) : undefined,
    lastClientUpdateTime: data["lastClientUpdateTime"] !== undefined ? data["lastClientUpdateTime"].toISOString() : undefined,
    rawContactInfo: data["rawContactInfo"] !== undefined ? data["rawContactInfo"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiRawDeviceContactInfo(item))) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiDeviceContactInfo(data: any): AppsPeopleOzExternalMergedpeopleapiDeviceContactInfo {
  return {
    ...data,
    deviceContactMetadata: data["deviceContactMetadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiDeviceContactExtraMetadata(data["deviceContactMetadata"]) : undefined,
    id: data["id"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiDeviceContactId(data["id"]) : undefined,
    lastClientUpdateTime: data["lastClientUpdateTime"] !== undefined ? new Date(data["lastClientUpdateTime"]) : undefined,
    rawContactInfo: data["rawContactInfo"] !== undefined ? data["rawContactInfo"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiRawDeviceContactInfo(item))) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiEdgeKeyInfo {
  /**
   * The container ID of the entity this field creates a join to. See
   * `SourceIdentity.id`.
   */
  containerId?: string;
  /**
   * The type of container that this edge points to. See
   * `SourceIdentity.container_type`.
   */
  containerType?:  | "UNKNOWN_CONTAINER" | "PROFILE" | "CONTACT" | "CIRCLE" | "PLACE" | "ACCOUNT" | "EXTERNAL_ACCOUNT" | "DOMAIN_PROFILE" | "DOMAIN_CONTACT" | "DEVICE_CONTACT" | "GOOGLE_GROUP" | "NAMED_CHAT_ROOM" | "UNNAMED_CHAT_ROOM" | "AFFINITY" | "RAW_DEVICE_CONTACT" | "CONTACT_ANNOTATION" | "DELEGATED_CONTACT";
  /**
   * Data that is added to the proto by peopleapi read extensions.
   */
  extendedData?: AppsPeopleOzExternalMergedpeopleapiEdgeKeyInfoExtensionData;
  /**
   * True indicates this edge links this source to a container represented by
   * this person object. Note: Except for certain legacy clients, EdgeKeyInfo is
   * only created for for edges to an entity in this person and this will always
   * be true.
   */
  materialized?: boolean;
}

export interface AppsPeopleOzExternalMergedpeopleapiEdgeKeyInfoExtensionData {
  /**
   * The GDataCompatibilityExtension will (temporarily) return mobile_owner_id
   * for profile containers.
   */
  gdataCompatibilityExtensionId?: string;
}

export interface AppsPeopleOzExternalMergedpeopleapiEmail {
  certificate?: AppsPeopleOzExternalMergedpeopleapiEmailCertificate[];
  classification?:  | "EMAIL_CLASSIFICATION_UNKNOWN" | "SIGNUP_EMAIL";
  /**
   * To read or update, use the CONTACT_GROUP_PREFERENCE mask field.
   */
  contactGroupPreference?: AppsPeopleOzExternalMergedpeopleapiEmailContactGroupPreference[];
  displayName?: string;
  extendedData?: AppsPeopleOzExternalMergedpeopleapiEmailExtendedData;
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  signupEmailMetadata?: AppsPeopleOzExternalMergedpeopleapiEmailSignupEmailMetadata;
  /**
   * The type of the email address. The type can be free form or one of these
   * predefined values: * `home` * `work` * `other`
   */
  type?: string;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiEmail(data: any): AppsPeopleOzExternalMergedpeopleapiEmail {
  return {
    ...data,
    certificate: data["certificate"] !== undefined ? data["certificate"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiEmailCertificate(item))) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiEmail(data: any): AppsPeopleOzExternalMergedpeopleapiEmail {
  return {
    ...data,
    certificate: data["certificate"] !== undefined ? data["certificate"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiEmailCertificate(item))) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Represents a S/MIME certificate config for use with Gmail. See
 * //caribou/smime/proto/certificate_status.proto. There can be zero or more
 * certificates associated with an email address, be it profile email or contact
 * email.
 */
export interface AppsPeopleOzExternalMergedpeopleapiEmailCertificate {
  /**
   * The name of this certificate configuration. Examples could be "High
   * security level" or "For domain emails only".
   */
  configurationName?: string;
  /**
   * It is conceivable that certificates could be ACLed. We also need to
   * indicate which certificate is the default. The PersonFieldMetadata can
   * accomplish both of these.
   */
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  status?: AppsPeopleOzExternalMergedpeopleapiEmailCertificateCertificateStatus;
}

function serializeAppsPeopleOzExternalMergedpeopleapiEmailCertificate(data: any): AppsPeopleOzExternalMergedpeopleapiEmailCertificate {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    status: data["status"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiEmailCertificateCertificateStatus(data["status"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiEmailCertificate(data: any): AppsPeopleOzExternalMergedpeopleapiEmailCertificate {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    status: data["status"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiEmailCertificateCertificateStatus(data["status"]) : undefined,
  };
}

/**
 * Minimal S/MIME certificate status i.e. two fields per email address.
 */
export interface AppsPeopleOzExternalMergedpeopleapiEmailCertificateCertificateStatus {
  /**
   * The certificate expiration timestamp in seconds.
   */
  notAfterSec?: bigint;
  /**
   * Current status of the email's certificate chain.
   */
  statusCode?:  | "UNKNOWN" | "CERTIFICATE_VALID" | "CERTIFICATE_MISSING" | "CERTIFICATE_EXPIRED" | "CERTIFICATE_REVOKED";
}

function serializeAppsPeopleOzExternalMergedpeopleapiEmailCertificateCertificateStatus(data: any): AppsPeopleOzExternalMergedpeopleapiEmailCertificateCertificateStatus {
  return {
    ...data,
    notAfterSec: data["notAfterSec"] !== undefined ? String(data["notAfterSec"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiEmailCertificateCertificateStatus(data: any): AppsPeopleOzExternalMergedpeopleapiEmailCertificateCertificateStatus {
  return {
    ...data,
    notAfterSec: data["notAfterSec"] !== undefined ? BigInt(data["notAfterSec"]) : undefined,
  };
}

/**
 * Preferred email addresses for contact groups.
 */
export interface AppsPeopleOzExternalMergedpeopleapiEmailContactGroupPreference {
  contactGroupId?: string;
  /**
   * If the Preference was implicitly set by PeopleApi/Contacts Service. A
   * preference with this bit will not be saved to storage. See
   * go/contact-group-email-preference-papi-problem for more info.
   */
  isSynthetic?: boolean;
  type?:  | "UNKNOWN" | "GMAIL";
}

/**
 * Extension data for a person email.
 */
export interface AppsPeopleOzExternalMergedpeopleapiEmailExtendedData {
  /**
   * For use with the CUSTOMER_INFO_ADDITIONAL_DATA extension. This includes
   * information on whether the given email is internal to or external to the
   * requesting user's domain.
   */
  internalExternal?: PeoplestackFlexorgsProtoInternalExternal;
  /**
   * For ListPeoplebyKnownId to indicate an email is sythesized from a lookup
   * email.
   */
  isPlaceholder?: boolean;
  /**
   * For use with the TLS extension. Whether the SMTP server that handles
   * delivery for this email address supports TLS encryption.
   */
  smtpServerSupportsTls?: boolean;
  /**
   * For use with the Gmail Homograph Warning extension. Whether the email
   * contains mixed character sets that could be used to decieve users. This
   * field is populated by the GMAIL_SECURITY_DATA extension.
   */
  usesConfusingCharacters?: boolean;
}

/**
 * Additional metadata for a signup email. This will only be set if the email's
 * classification is SIGNUP_EMAIL.
 */
export interface AppsPeopleOzExternalMergedpeopleapiEmailSignupEmailMetadata {
  /**
   * This is considered to be the primary signup email. At most 1 signup email
   * will have this set.
   */
  primary?: boolean;
}

/**
 * Emergency info for Person. See go/emergency-trusted-contacts-papi.
 */
export interface AppsPeopleOzExternalMergedpeopleapiEmergencyInfo {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * Opaque id from Pomeroy (go/pomeroy). Non-empty pomeroy_id means that this
   * contact has the potential to become trusted contact or it's already trusted
   * contact. Trust is eventually gaia<->gaia link, but when the trust link is
   * initiated gaia might not be known. Until gaia is discovered, pomeroy_id is
   * used to identify the contact uniquely. If trust_level is missing or set to
   * TRUST_LEVEL_UNSPECIFIED pomeroy_id must be empty.
   */
  pomeroyId?: string;
  trustLevel?:  | "TRUST_LEVEL_UNSPECIFIED" | "TRUST_LEVEL_EMERGENCY_CONTACT";
}

function serializeAppsPeopleOzExternalMergedpeopleapiEmergencyInfo(data: any): AppsPeopleOzExternalMergedpeopleapiEmergencyInfo {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiEmergencyInfo(data: any): AppsPeopleOzExternalMergedpeopleapiEmergencyInfo {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiEvent {
  /**
   * Event are more accurately represented as a calendar day that does not
   * depend on a timestamp representation at all. When given a timestamp, there
   * are lots of opportunities to make mistakes, so a CalendarDay proto is
   * replacing timestamps. PeopleApi will return these values on reads, and
   * unless the client is a legacy caller in the
   * legacy_timestamp_event_write_behavior_enabled capability allowlist, this
   * value is what is used for Person writes.
   */
  calendarDay?: GoogleTypeDate;
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * People Prompts settings for contact event data.
   */
  prompt?: SocialGraphApiProtoPrompt;
  /**
   * Clients are recommended to read the calendar_day field instead of
   * timestamp_millis. When writing events, new clients must set calendar_day
   * instead of timestamp_millis. Events are currently represented as timestamp
   * values, although the interpretation of these timestamp values is a calendar
   * date. There are a few important details about how this value should be
   * mapped to a calendar date that should be consistent among all clients. For
   * detailed information, see Birthday.date_ms.
   */
  timestampMillis?: bigint;
  /**
   * The type of the event. The type can be free form or one of these
   * predefined values: * `anniversary` * `other`
   */
  type?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiEvent(data: any): AppsPeopleOzExternalMergedpeopleapiEvent {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    prompt: data["prompt"] !== undefined ? serializeSocialGraphApiProtoPrompt(data["prompt"]) : undefined,
    timestampMillis: data["timestampMillis"] !== undefined ? String(data["timestampMillis"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiEvent(data: any): AppsPeopleOzExternalMergedpeopleapiEvent {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    prompt: data["prompt"] !== undefined ? deserializeSocialGraphApiProtoPrompt(data["prompt"]) : undefined,
    timestampMillis: data["timestampMillis"] !== undefined ? BigInt(data["timestampMillis"]) : undefined,
  };
}

/**
 * External identifier associated with the person.
 */
export interface AppsPeopleOzExternalMergedpeopleapiExternalId {
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * The type of the external ID. The type can be free form or one of these
   * predefined values: * `account` * `customer` * `loginId` * `network` *
   * `organization`
   */
  type?: string;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiExternalId(data: any): AppsPeopleOzExternalMergedpeopleapiExternalId {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiExternalId(data: any): AppsPeopleOzExternalMergedpeopleapiExternalId {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * The field ACL. Currently only populated on profile fields for the profile
 * owner. A Person field ACL; see http://go/peopleapi-acl
 */
export interface AppsPeopleOzExternalMergedpeopleapiFieldAcl {
  /**
   * A custom type of field ACL entry. The set of all ACL entries includes
   * those listed in acl_entry as well as predefined_acl_entry.
   */
  aclEntry?: AppsPeopleOzExternalMergedpeopleapiFieldAclAclEntry[];
  /**
   * Set of users that will be authorized to view the field by this field ACL.
   * If the ACL is public, this will only contain ALL_USERS. This field is
   * synthesized, read-only, and currently only used for profile photos. It's
   * populated under "person.photo.metadata.field_acl" for the current photo ACL
   * and "person.photo.metadata.acl_choices" for available photo ACL choices.
   * Note: The set of authorized viewers for a given FieldAcl may depend on the
   * user's account type and domain configuration. For example, a PRIVATE_READ
   * FieldAcl could have any of the following authorized viewers: Consumer user:
   * [IDENTITY_ACL_ESTABLISHED] Dasher user without domain contact sharing:
   * [IDENTITY_ACL_ESTABLISHED] Unicorn user: [SAME_UNICORN_FAMILY] Hafez user:
   * []
   */
  authorizedViewers?:  | "AUTHORIZED_VIEWER_UNSPECIFIED" | "IDENTITY_ACL_ESTABLISHED" | "SAME_ORGANIZATION" | "SAME_UNICORN_FAMILY" | "ALL_USERS"[];
  /**
   * A common type of field ACL entry. A predefined ACL entry is a shortcut for
   * a commonly occurring case of role and scope. For example, PUBLIC_READ is
   * the same as an AclEntry with role = READER and scope.all_users = true. The
   * set of all ACL entries includes those listed in acl_entry as well as
   * predefined_acl_entry.
   */
  predefinedAclEntry?:  | "UNKNOWN" | "OWNER" | "PUBLIC_READ" | "DOMAIN_READ" | "YOUR_CIRCLES_READ" | "EXTENDED_CIRCLES_READ" | "PRIVATE_READ"[];
}

export interface AppsPeopleOzExternalMergedpeopleapiFieldAclAclEntry {
  role?:  | "UNKNOWN" | "READER" | "WRITER" | "OWNER";
  scope?: AppsPeopleOzExternalMergedpeopleapiFieldAclAclEntryScope;
}

export interface AppsPeopleOzExternalMergedpeopleapiFieldAclAclEntryScope {
  /**
   * Indicates that the field is accessible to all users including
   * unauthenticated users. For some fields this means "to everyone except
   * blocked users".
   */
  allUsers?: boolean;
  /**
   * This is a "synthetic" field. In reality domains are treated as gaia-
   * groups. This field will be 'true' when the field is ACLed to the gaia-group
   * of the requester's domain.
   */
  domainUsers?: boolean;
  membership?: AppsPeopleOzExternalMergedpeopleapiFieldAclAclEntryScopeMembershipAcl;
  /**
   * Indicates that the field is accessible to a person.
   */
  person?: AppsPeopleOzExternalMergedpeopleapiFieldAclAclEntryScopePersonAcl;
}

/**
 * Used when the field is accessible to a membership that the person has.
 */
export interface AppsPeopleOzExternalMergedpeopleapiFieldAclAclEntryScopeMembershipAcl {
  circle?: AppsPeopleOzExternalMergedpeopleapiFieldAclAclEntryScopeMembershipAclCircleAcl;
  contactGroup?: AppsPeopleOzExternalMergedpeopleapiFieldAclAclEntryScopeMembershipAclContactGroupAcl;
}

/**
 * Used when a field is accessible to a circle.
 */
export interface AppsPeopleOzExternalMergedpeopleapiFieldAclAclEntryScopeMembershipAclCircleAcl {
  circleId?: string;
  circleSet?:  | "UNKNOWN" | "YOUR_CIRCLES" | "EXTENDED_CIRCLES";
  /**
   * Equivalent to Circle.display_name for the circle_id. Included when
   * FieldAclOption.FULL_ACL_WITH_DETAILS is requested. This field is read-only
   * and ignored on update.
   */
  displayName?: string;
}

/**
 * Used when a field is accessible to a legacy contact group. Contact groups
 * are discouraged and may be deprecated soon. ContactGroupAcls are read-only.
 * If they are included as part of an ACL on an Update, an exception is thrown.
 */
export interface AppsPeopleOzExternalMergedpeopleapiFieldAclAclEntryScopeMembershipAclContactGroupAcl {
  /**
   * A contact group ID. This is either a user-defined contact group hex ID, or
   * it is the string name of the enum constant in Group.PredefinedId in FBS
   * backend.proto for predefined groups. Common values for the predefined name
   * include, but are not limited to: all, myContacts, starred, chatBuddies,
   * friends, family, coworkers, and blocked.
   */
  contactGroupId?: string;
  /**
   * The localized display name for the predefined group, if known; or, the
   * display name for the user-defined contact group. Included when
   * FieldAclOption.FULL_ACL_WITH_DETAILS is requested.
   */
  displayName?: string;
}

/**
 * Used when a field is accessible to a person. NOTE: ACLs to a circle or to a
 * non-self person are no longer supported, so this can only be applied to the
 * requester self.
 */
export interface AppsPeopleOzExternalMergedpeopleapiFieldAclAclEntryScopePersonAcl {
  /**
   * DEPRECATED. This is not different than reading from person.name for a
   * self-read; ACLs to a circle or to a non-self person are no longer
   * supported. Equivalent to Name.display_name for the person_id profile.
   * Included when the profile Name is ACLed to the requester and
   * FieldAclOption.FULL_ACL_WITH_DETAILS is requested. This field is read-only
   * and ignored on update.
   */
  displayName?: string;
  personId?: string;
  /**
   * DEPRECATED. This is not different than reading from person.photo for a
   * self-read; ACLs to a circle or to a non-self person are no longer
   * supported. Equivalent to Photo.url for the person_id profile. Included when
   * the profile Photo is ACLed to the requester and
   * FieldAclOption.FULL_ACL_WITH_DETAILS is requested. This field is read-only
   * and ignored on update.
   */
  photoUrl?: string;
}

/**
 * Emergency information for Person field, such as Phone or Email. See
 * go/emergency-trusted-contacts-papi.
 */
export interface AppsPeopleOzExternalMergedpeopleapiFieldEmergencyInfo {
  emergencyLevel?:  | "EMERGENCY_LEVEL_UNSPECIFIED" | "EMERGENCY_LEVEL_PRIMARY";
}

/**
 * The FileAs field in Contacts is used to override the DisplayName of a
 * Contact for that User.
 */
export interface AppsPeopleOzExternalMergedpeopleapiFileAs {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiFileAs(data: any): AppsPeopleOzExternalMergedpeopleapiFileAs {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiFileAs(data: any): AppsPeopleOzExternalMergedpeopleapiFileAs {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Gender in PeopleApi has some odd semantics about writing and reading that
 * are not obvious from the proto definition. First, the `type` string, when
 * read, always maps to the constrained domain of "male", "female", and "other",
 * aside from a pathological case that PeopleApi would like to fix. There are
 * two typical patterns: 1. `type` is either "male" or "female" and
 * `custom_type` and `address_me_as` are exactly as specified by an update to
 * PeopleApi, although they are most often absent for "male" and "female"
 * writes. 2. `type` is "other" and `custom_type` is set to a freeform string
 * from the request. `address_me_as` is equal to whatever was provided at write
 * time. When writing, the free-form string for `custom_type` can come from
 * either `custom_type` if the field is present on the request, or if
 * `custom_type` is absent, the string value of `type` will be copied into it.
 * Any value in `type` will be coerced to "other" and the free-form value will
 * be copied into `custom_type`, even if `type` is exactly "other". Prefer to
 * explicitly set `custom_type` and set type to "other" instead of setting type
 * to a free-form value. There are weird edge cases when the value is "unknown".
 * Consider the behavior for `type` == "unknown" unspecified. Clients reading
 * the gender should use the value from `formatted_type` if `type` is "male" or
 * "female". If `type` is "other", `formatted_type` will be "Other" (or some
 * translation) and clients should read `custom_type` for more specificity.
 */
export interface AppsPeopleOzExternalMergedpeopleapiGender {
  /**
   * Preferred pronoun choice. It's unclear whether this value is constrained
   * to a finite domain by UIs. `address_me_as` may be populated regardless of
   * whether `type` is "male", "female", or "other", although most writers only
   * set it if `type` is "other".
   */
  addressMeAs?: string;
  /**
   * A free-form string indicating what the user entered as their gender.
   * `custom_type` may exist even if the type is "male" or "female", although
   * most writers do not set it unless `type` is "other".
   */
  customType?: string;
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * The gender. "male", "female", or "other". If "other", typically,
   * additional fields will have additional information.
   */
  type?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiGender(data: any): AppsPeopleOzExternalMergedpeopleapiGender {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiGender(data: any): AppsPeopleOzExternalMergedpeopleapiGender {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Extension data for use in GPay Product Profile.
 * go/gpay-product-profile-1-pager Contact: profiles-eng-fe@google.com
 */
export interface AppsPeopleOzExternalMergedpeopleapiGPayExtendedData {
  /**
   * Failure type if there is an error when fetching product profile data.
   */
  failure?: AppsPeopleOzExternalMergedpeopleapiProductProfileFailure;
  /**
   * A number in international format including the country code that is made
   * user readable by including formatting such as spaces. Example: "+41 44 668
   * 1800" DEPRECATED: A user's phone number should be masked and not in an
   * international format
   */
  internationalNumber?: string;
  /**
   * The masked string of a user's phone number The number will be obfucsated
   * with * except the last 4 digits. Refer to:
   * //java/com/google/nbu/paisa/common/PhoneNumberMasker.java
   */
  maskedNumber?: string;
}

export interface AppsPeopleOzExternalMergedpeopleapiGplusExtendedData {
  contentRestriction?:  | "UNKNOWN" | "PUBLIC" | "DISCOVERY" | "WALLED_GARDEN";
  /**
   * Equivalent to having the DASHER_POLICY bit in the REGISTERED state.
   */
  isEnterpriseUser?: boolean;
}

/**
 * Extension data for use in Hangouts.
 */
export interface AppsPeopleOzExternalMergedpeopleapiHangoutsExtendedData {
  hadPastHangoutState?:  | "UNKNOWN_PAST_HANGOUT_STATE" | "HAD_PAST_HANGOUT" | "NO_PAST_HANGOUT";
  /**
   * Populated for all contacts. Only set if had_past_hangout_state ==
   * HAD_PAST_HANGOUT. INVITATION_NEEDED is not a valid value because there
   * already is a past hangout, which means either the invitation is still
   * pending or it’s been accepted.
   */
  invitationStatus?:  | "UNKNOWN_INVITATION_STATUS" | "PENDING_INVITATION" | "ACCEPTED_INVITATION" | "INVITATION_NEEDED";
  /**
   * True if this is a Hangouts bot.
   */
  isBot?: boolean;
  isDismissed?: boolean;
  isFavorite?: boolean;
  isPinned?: boolean;
  userType?:  | "UNKNOWN_USER_TYPE" | "INVALID" | "GAIA" | "OFF_NETWORK_PHONE" | "MALFORMED_PHONE_NUMBER" | "UNKNOWN_PHONE_NUMBER" | "ANONYMOUS_PHONE_NUMBER";
}

export interface AppsPeopleOzExternalMergedpeopleapiIdentityInfo {
  /**
   * Original lookup token from the request that resulted in this person or one
   * of its containers.
   */
  originalLookupToken?: string[];
  /**
   * Any former IDs this person may have had, in the case that their ID may
   * have changed. Populated only for sync requests. Examples of such changes
   * include adding an edge to a contact that links to a profile. The ID will
   * change from being contact-oriented to being profile-oriented. To be used to
   * clear out old versions of a person.
   */
  previousPersonId?: string[];
  /**
   * A list of sources contributing to the merged person, including profiles
   * (with gaia-id), contacts and synthetic-contacts.
   */
  sourceIds?: AppsPeopleOzExternalMergedpeopleapiSourceIdentity[];
}

function serializeAppsPeopleOzExternalMergedpeopleapiIdentityInfo(data: any): AppsPeopleOzExternalMergedpeopleapiIdentityInfo {
  return {
    ...data,
    sourceIds: data["sourceIds"] !== undefined ? data["sourceIds"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiSourceIdentity(item))) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiIdentityInfo(data: any): AppsPeopleOzExternalMergedpeopleapiIdentityInfo {
  return {
    ...data,
    sourceIds: data["sourceIds"] !== undefined ? data["sourceIds"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiSourceIdentity(item))) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiIm {
  /**
   * The `protocol` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedProtocol?: string;
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * The protocol of the IM. The protocol can be free form or one of these
   * predefined values: * `aim` * `msn` * `yahoo` * `skype` * `qq` *
   * `googleTalk` * `icq` * `jabber` * `netMeeting`
   */
  protocol?: string;
  /**
   * The type of the IM. The type can be free form or one of these predefined
   * values: * `home` * `work` * `other`
   */
  type?: string;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiIm(data: any): AppsPeopleOzExternalMergedpeopleapiIm {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiIm(data: any): AppsPeopleOzExternalMergedpeopleapiIm {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * How and where to send notifications to this person in other apps, and why
 * the requester can do so. See go/reachability for more info. "How" and "where"
 * identify the recipient in a P2P Bridge (glossary/p2p bridge), and "why" may
 * be helpful in a UI to disambiguate which of several ways may be used to
 * contact the recipient. How: Via a Google profile or a reachable-only phone
 * number that the requester has access to. Specified in the target "type" and
 * "value". Where: Apps in which the profile/phone number owner may receive
 * notifications. Specified in the repeated "app". Why: Which fields in, e.g., a
 * contact associated with this person make the notification target info visible
 * to the requester. Specified in the repeated originating_field param. Example:
 * Alice has a contact Bob, with: Email 0 = bob@gmail.com Phone 0 = +12223334444
 * Phone 1 = +15556667777 Email 0 and Phone 0 let Alice see Bob's public profile
 * (obfuscated gaia ID = 123). Public profiles are visible by email by default,
 * and Bob has explicitly made it visible via Phone 0. Bob says people can send
 * notifications to his public profile in YouTube. Phone 2 is associated with
 * another Google profile that Bob owns, but he doesn't want others to see it.
 * He is okay with people sending notifications to him in Who's Down if they
 * have this phone number, however. There will be separate
 * InAppNotificationTargets: one for Bob's public Google profile, and one for
 * the second phone number, which is in his private profile. IANT #1 - targeting
 * Bob's public profile (visible via Email 0 and Phone 0): app = [YOUTUBE] type
 * = OBFUSCATED_GAIA_ID value = 123 originating_field: [ { field_type = EMAIL,
 * field_index = 0 } // For Email 0 { field_type = PHONE, field_index = 0 } //
 * For Phone 0 ] IANT #2 - targeting Bob's private profile phone number Phone 1:
 * app = [WHOS_DOWN] type = PHONE value = +15556667777 originating_field: [ {
 * field_type = PHONE, field_index = 1 } // For Phone 1 ]
 */
export interface AppsPeopleOzExternalMergedpeopleapiInAppNotificationTarget {
  app?:  | "UNKNOWN" | "BABEL" | "YOUTUBE" | "WHOS_DOWN" | "YOUTUBE_MANGO" | "PHOTOS" | "GOOGLE_ASSISTANT" | "KABOO" | "COMMERCE_PLATFORM" | "SPACES" | "MAPS" | "LOUPE_UNUSED" | "POMEROY" | "LOUPE" | "PEOPLE_PLAYGROUND" | "NEWS_360" | "DUO"[];
  clientData?: AppsPeopleOzExternalMergedpeopleapiInAppNotificationTargetClientData[];
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * There may be more than one field from which this IANT originates, as in
   * the case of Bob's public profile.
   */
  originatingField?: AppsPeopleOzExternalMergedpeopleapiInAppNotificationTargetOriginatingField[];
  type?:  | "UNKNOWN_KEY_TYPE" | "PHONE" | "OBFUSCATED_GAIA_ID" | "EMAIL";
  /**
   * The value of the target, used for delivery. E.g., the obfuscated gaia ID
   * for a visible profile.
   */
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiInAppNotificationTarget(data: any): AppsPeopleOzExternalMergedpeopleapiInAppNotificationTarget {
  return {
    ...data,
    clientData: data["clientData"] !== undefined ? data["clientData"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiInAppNotificationTargetClientData(item))) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiInAppNotificationTarget(data: any): AppsPeopleOzExternalMergedpeopleapiInAppNotificationTarget {
  return {
    ...data,
    clientData: data["clientData"] !== undefined ? data["clientData"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiInAppNotificationTargetClientData(item))) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Client-specific data pertaining to app reachability. No PII data or user
 * content should be stored in this blob.
 */
export interface AppsPeopleOzExternalMergedpeopleapiInAppNotificationTargetClientData {
  /**
   * The app to which this client data applies.
   */
  app?:  | "UNKNOWN" | "BABEL" | "YOUTUBE" | "WHOS_DOWN" | "YOUTUBE_MANGO" | "PHOTOS" | "GOOGLE_ASSISTANT" | "KABOO" | "COMMERCE_PLATFORM" | "SPACES" | "MAPS" | "LOUPE_UNUSED" | "POMEROY" | "LOUPE" | "PEOPLE_PLAYGROUND" | "NEWS_360" | "DUO";
  byteValue?: Uint8Array;
}

function serializeAppsPeopleOzExternalMergedpeopleapiInAppNotificationTargetClientData(data: any): AppsPeopleOzExternalMergedpeopleapiInAppNotificationTargetClientData {
  return {
    ...data,
    byteValue: data["byteValue"] !== undefined ? encodeBase64(data["byteValue"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiInAppNotificationTargetClientData(data: any): AppsPeopleOzExternalMergedpeopleapiInAppNotificationTargetClientData {
  return {
    ...data,
    byteValue: data["byteValue"] !== undefined ? decodeBase64(data["byteValue"] as string) : undefined,
  };
}

/**
 * Info for identifying the specific field in this person that lets the
 * requester send them notifications. These are typically fields added to a
 * contact (e.g., email). There will not always be in originating field,
 * typically in the case that whatever permits the requester to see this target
 * info is not something that can be used on its own for contacting this person.
 */
export interface AppsPeopleOzExternalMergedpeopleapiInAppNotificationTargetOriginatingField {
  /**
   * The index of the relevant field in the merged person
   */
  fieldIndex?: number;
  fieldType?:  | "UNKNOWN_FIELD_TYPE" | "PHONE" | "EMAIL";
  /**
   * The value of the origin field
   */
  value?: string;
}

/**
 * This is deprecated in PEOPLE_API/SHARPEN, and should only be used for
 * PROFILES. Which apps the person has indicated they are reachable at for the
 * requester. See go/d13y and com.google.focus.proto.InAppReachability.
 */
export interface AppsPeopleOzExternalMergedpeopleapiInAppReachability {
  appType?:  | "UNKNOWN" | "BABEL" | "YOUTUBE" | "WHOS_DOWN" | "YOUTUBE_MANGO" | "PHOTOS" | "KABOO" | "COMMERCE_PLATFORM" | "SPACES" | "GOOGLE_ASSISTANT" | "PEOPLE_PLAYGROUND" | "MAPS" | "LOUPE_UNUSED" | "POMEROY" | "LOUPE" | "NEWS_360" | "DUO";
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  reachabilityKey?: AppsPeopleOzExternalMergedpeopleapiInAppReachabilityReachabilityKey;
  status?:  | "UNKNOWN_REACHABLE_STATUS" | "REACHABLE" | "NOT_REACHABLE";
}

function serializeAppsPeopleOzExternalMergedpeopleapiInAppReachability(data: any): AppsPeopleOzExternalMergedpeopleapiInAppReachability {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiInAppReachability(data: any): AppsPeopleOzExternalMergedpeopleapiInAppReachability {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Information pertaining to how this reachable state was established.
 */
export interface AppsPeopleOzExternalMergedpeopleapiInAppReachabilityReachabilityKey {
  keyType?:  | "UNKNOWN_KEY_TYPE" | "PHONE" | "OBFUSCATED_GAIA_ID";
  /**
   * The value of the key by which the user said they may be reachable. E.g.,
   * the phone number.
   */
  keyValue?: string;
}

/**
 * Defines interactions that are allowed or disallowed with this person.
 */
export interface AppsPeopleOzExternalMergedpeopleapiInteractionSettings {
  allowed?: boolean;
  interaction?:  | "UNKNOWN" | "INCOMING_CIRCLE_MEMBERSHIP" | "INCOMING_SOCIAL_EDGE" | "INVITE_TO_EMAIL";
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiInteractionSettings(data: any): AppsPeopleOzExternalMergedpeopleapiInteractionSettings {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiInteractionSettings(data: any): AppsPeopleOzExternalMergedpeopleapiInteractionSettings {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiInterest {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiInterest(data: any): AppsPeopleOzExternalMergedpeopleapiInterest {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiInterest(data: any): AppsPeopleOzExternalMergedpeopleapiInterest {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * The value can either by a language code conforming to the IETF BCP 47
 * specification or a custom freeform value. By default the returned value is
 * proxied from FBS Profile.Language. If `include_account_locale` is set on the
 * `MergePersonSourceOptions` the language from go/uls is preferred and returned
 * as primary along with a secondary language from FBS.
 */
export interface AppsPeopleOzExternalMergedpeopleapiLanguage {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiLanguage(data: any): AppsPeopleOzExternalMergedpeopleapiLanguage {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiLanguage(data: any): AppsPeopleOzExternalMergedpeopleapiLanguage {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiLatLng {
  lat?: number;
  lng?: number;
}

/**
 * Fields used in legacy applications. Useful for joining legacy and new data
 * streams. Most applications should not care about these fields.
 */
export interface AppsPeopleOzExternalMergedpeopleapiLegacyFields {
  /**
   * Mobile obfuscated gaia id. This is the same gaia id in metadata.owner_id,
   * but obfuscated with the legacy mobile obfuscator.
   */
  mobileOwnerId?: string;
}

export interface AppsPeopleOzExternalMergedpeopleapiLimitedProfileSettingsField {
  limitedProfileSettings?: SocialGraphApiProtoLimitedProfileSettings;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiLimitedProfileSettingsField(data: any): AppsPeopleOzExternalMergedpeopleapiLimitedProfileSettingsField {
  return {
    ...data,
    limitedProfileSettings: data["limitedProfileSettings"] !== undefined ? serializeSocialGraphApiProtoLimitedProfileSettings(data["limitedProfileSettings"]) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiLimitedProfileSettingsField(data: any): AppsPeopleOzExternalMergedpeopleapiLimitedProfileSettingsField {
  return {
    ...data,
    limitedProfileSettings: data["limitedProfileSettings"] !== undefined ? deserializeSocialGraphApiProtoLimitedProfileSettings(data["limitedProfileSettings"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiLocation {
  buildingId?: string;
  /**
   * The building_name field is only filled if the
   * DESK_LOCATION_ADDITIONAL_DATA extension is active.
   */
  buildingName?: string;
  current?: boolean;
  /**
   * Most specific textual description of individual desk location.
   */
  deskCode?: string;
  floorName?: string;
  floorSection?: string;
  /**
   * Indicates the time this location was added or last edited.
   */
  lastUpdateTime?: Date;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * Value indicates the origin of this location information.
   */
  source?:  | "UNKNOWN" | "EXPLICIT" | "INFERRED";
  /**
   * Describes the type of location. For e.g. Grew_up, Desk. Corresponds to FBS
   * backend.proto Location.StandardTag
   */
  type?: string;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiLocation(data: any): AppsPeopleOzExternalMergedpeopleapiLocation {
  return {
    ...data,
    lastUpdateTime: data["lastUpdateTime"] !== undefined ? data["lastUpdateTime"].toISOString() : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiLocation(data: any): AppsPeopleOzExternalMergedpeopleapiLocation {
  return {
    ...data,
    lastUpdateTime: data["lastUpdateTime"] !== undefined ? new Date(data["lastUpdateTime"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiManagementUpchain {
  /**
   * List of managers in the chain. If user has manager email "abc@google.com"
   * and manager's manager has email "xyz@google.com" then the list will be:
   * [0]: { email: "abc@google.com" } [1]: { email: "xyz@google.com" }
   */
  indirectManager?: AppsPeopleOzExternalMergedpeopleapiManagementUpchainIndirectManager[];
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  status?:  | "UNKNOWN" | "OK" | "PARTIAL" | "LOOP";
}

function serializeAppsPeopleOzExternalMergedpeopleapiManagementUpchain(data: any): AppsPeopleOzExternalMergedpeopleapiManagementUpchain {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiManagementUpchain(data: any): AppsPeopleOzExternalMergedpeopleapiManagementUpchain {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiManagementUpchainIndirectManager {
  email?: string;
  personId?: string;
}

/**
 * Extension data for use in Maps Product Profile.
 */
export interface AppsPeopleOzExternalMergedpeopleapiMapsExtendedData {
  /**
   * Failure type if there is an error when fetching product profile data.
   */
  failure?: AppsPeopleOzExternalMergedpeopleapiProductProfileFailure;
  /**
   * Number of people the user is following.
   */
  followeeCount?: bigint;
  /**
   * Number of people who are following the user.
   */
  followerCount?: number;
  /**
   * Sum of creators contributions i.e. reviews, rating, questions, etc.
   */
  numContributions?: bigint;
  /**
   * The user's profile photo that might have a badge rendered at the corner if
   * the user is eligible for a badge.
   */
  profilePhotoUrl?: string;
  /**
   * A user's bio, or tagline.
   */
  tagline?: string;
  /**
   * A topic that creator has expertise in. This will be in the format: emoji
   * associated with the topic, display name of the topic, topic score
   */
  topicExpertise?: string[];
  /**
   * A user's caption displayed under the user name on their profile page i.e.
   * 'Local Guide Level 8'
   */
  userCaption?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiMapsExtendedData(data: any): AppsPeopleOzExternalMergedpeopleapiMapsExtendedData {
  return {
    ...data,
    followeeCount: data["followeeCount"] !== undefined ? String(data["followeeCount"]) : undefined,
    numContributions: data["numContributions"] !== undefined ? String(data["numContributions"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiMapsExtendedData(data: any): AppsPeopleOzExternalMergedpeopleapiMapsExtendedData {
  return {
    ...data,
    followeeCount: data["followeeCount"] !== undefined ? BigInt(data["followeeCount"]) : undefined,
    numContributions: data["numContributions"] !== undefined ? BigInt(data["numContributions"]) : undefined,
  };
}

/**
 * Maps Profile Data. See go/product-profiles-backend-api.
 */
export interface AppsPeopleOzExternalMergedpeopleapiMapsProfile {
  fieldRestriction?: AppsPeopleOzExternalMergedpeopleapiMapsProfileFieldRestriction[];
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  tagline?: string;
  /**
   * A link to the profile owner's website to be displayed in profile.
   */
  websiteLink?: AppsPeopleOzExternalMergedpeopleapiMapsProfileUrlLink;
}

function serializeAppsPeopleOzExternalMergedpeopleapiMapsProfile(data: any): AppsPeopleOzExternalMergedpeopleapiMapsProfile {
  return {
    ...data,
    fieldRestriction: data["fieldRestriction"] !== undefined ? data["fieldRestriction"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiMapsProfileFieldRestriction(item))) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiMapsProfile(data: any): AppsPeopleOzExternalMergedpeopleapiMapsProfile {
  return {
    ...data,
    fieldRestriction: data["fieldRestriction"] !== undefined ? data["fieldRestriction"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiMapsProfileFieldRestriction(item))) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiMapsProfileFieldRestriction {
  /**
   * Opaque data associated with this restriction e.g. abuse status.
   */
  clientData?: Uint8Array;
  type?:  | "TYPE_UNSPECIFIED" | "HIDE_TAGLINE";
}

function serializeAppsPeopleOzExternalMergedpeopleapiMapsProfileFieldRestriction(data: any): AppsPeopleOzExternalMergedpeopleapiMapsProfileFieldRestriction {
  return {
    ...data,
    clientData: data["clientData"] !== undefined ? encodeBase64(data["clientData"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiMapsProfileFieldRestriction(data: any): AppsPeopleOzExternalMergedpeopleapiMapsProfileFieldRestriction {
  return {
    ...data,
    clientData: data["clientData"] !== undefined ? decodeBase64(data["clientData"] as string) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiMapsProfileUrlLink {
  /**
   * Anchor text to be displayed as clickable link. If not present, the URL
   * should be displayed directly.
   */
  anchorText?: string;
  /**
   * The URL to be linked to.
   */
  url?: string;
}

/**
 * Represents the matching information for a field when there is a query.
 */
export interface AppsPeopleOzExternalMergedpeopleapiMatchInfo {
  /**
   * The list of matches ordered by most relevant matching for autocomplete
   * coming first.
   */
  match?: AppsPeopleOzExternalMergedpeopleapiMatchInfoLookupTokenMatch[];
  /**
   * The query token we are matching against.
   */
  query?: string;
}

/**
 * All the substring that were matched for the given query against the current
 * field. Represents a substring of another string.
 */
export interface AppsPeopleOzExternalMergedpeopleapiMatchInfoLookupTokenMatch {
  /**
   * Index right after the last character that matches the query. length =
   * end-start, we have substring = [start, end).
   */
  endIndex?: number;
  /**
   * Index of the first unicode character that matches the query.
   */
  startIndex?: number;
}

/**
 * A membership that the person has. The person can be a member of multiple
 * circles and multiple contact-groups. A circle membership is created by adding
 * a person to a circle by person-id or by email. A contact-group membership is
 * created by adding a contact to a contact-group.
 */
export interface AppsPeopleOzExternalMergedpeopleapiMembership {
  /**
   * A circle that the person belongs to.
   */
  circleId?: string;
  /**
   * A contact-group that the person belong to. The id can be either a
   * hex-formatted id or a camel-cased SystemContactGroup predefined group name.
   * The id will be predefined group name iff the system_contact_group_id has a
   * value.
   */
  contactGroupId?: string;
  /**
   * The metadata field can be used to determine which container generated the
   * membership. For example, when the membership has a contact_group_id, the
   * metadata.container will be CONTACT and the container_id will be the contact
   * Id.
   */
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * The membership has a contact_group_id, this field will be populated when
   * the membership is in a system-reserved contact-group.
   */
  systemContactGroupId?:  | "UNKNOWN" | "MY_CONTACTS" | "STARRED" | "FRIENDS" | "FAMILY" | "COWORKERS";
}

function serializeAppsPeopleOzExternalMergedpeopleapiMembership(data: any): AppsPeopleOzExternalMergedpeopleapiMembership {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiMembership(data: any): AppsPeopleOzExternalMergedpeopleapiMembership {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiMission {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiMission(data: any): AppsPeopleOzExternalMergedpeopleapiMission {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiMission(data: any): AppsPeopleOzExternalMergedpeopleapiMission {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * See go/people-api-howto:names for an overview of name usage in PeopleAPI.
 * The `unstructured_name` field contains a free form name value. The
 * `given_name`, `middle_name`, `family_name`, etc, fields contain the
 * structured name. For CONTACT mutates, (i.e. when Name.metadata.container is
 * CONTACT), it is recommended for clients to set either the `unstructured_name`
 * or the set of structured name fields, not both. * When only the
 * `unstructured_name` is set, it is parsed to produce a best-guess set of
 * structured name values for the `given_name`, `family_name`, etc. * When only
 * the structured name fields are set, the various values are combined to
 * produce an `unstructured_name`. * When both are set, the `unstructured_name`
 * is saved as-is and the structured name fields are saved as-is. This may be
 * confusing as they might not "match". For PROFILE mutates, (i.e. when
 * Name.metadata.container is PROFILE), it is _required_ for clients to use the
 * structured name fields as the unstructured field value is ignored on write.
 * The unstructured name fields are generated for convenience on read. For
 * DEVICE_CONTACTS, see b/156020778.
 */
export interface AppsPeopleOzExternalMergedpeopleapiName {
  /**
   * Read-only. A name synthesized based on `unstructured_name` and the
   * structured name fields. Example: "John Smith" If a language code is passed
   * in the side channel using
   * http://cs/symbol:framework.rpc.DeprecatedPropagatedLanguageCode.value or
   * http://cs/symbol:google.rpc.context.OriginContext.accept_language and the
   * name does not have `honorific_prefix`, `middle_name`, or `honorific_suffix`
   * set, the language code will be used to format `display_name`. If
   * `include_account_locale` is set on the `MergePersonSourceOptions` and a
   * language code is not passed in the side channel. The language code from
   * go/uls will be used as the language code for formatting `display_name`.
   */
  displayName?: string;
  /**
   * Read-only. A name synthesized based on `unstructured_name` and the
   * structured name fields with the last name first. Example: "Smith, John"
   */
  displayNameLastFirst?: string;
  /**
   * Read-only. The source of the display name.
   */
  displayNameSource?: SocialGraphApiProtoDisplayNameSource;
  familyName?: string;
  /**
   * DEPRECATED(b/70571931). Use `unstructured_name` instead.
   */
  formattedName?: string;
  givenName?: string;
  honorificPrefix?: string;
  honorificSuffix?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  middleName?: string;
  /**
   * This field is stored in contact annotations and merged at read-time. It is
   * available with CONTACT_ANNOTATION container type at read time.
   */
  pronunciations?: SocialGraphApiProtoPronunciations;
  /**
   * Read-only. A possibly shorter version of the user's name. - The purpose of
   * this field is to address the needs of UIs where a full display name might
   * be too large to fit. Instead of relying on `first_name`, which might not be
   * present, `short_display_name` is preferred. - This is only available for
   * PROFILE and DOMAIN_PROFILE container types. - About the actual content in
   * this field: will be the first name when it's visible to the requester, or
   * the same as `display_name`, otherwise. A sample scenario where the first
   * name may not be visible is when the limited profile is returned. For more
   * info, see: http://shortn/_9iV7TJ33la
   */
  shortDisplayName?: string;
  /**
   * The free form name value. For contact mutates it is recommended for
   * clients to set either the `unstructured_name` or the set of structured name
   * fields, not both.
   */
  unstructuredName?: string;
  yomiFamilyName?: string;
  yomiFullName?: string;
  yomiGivenName?: string;
  yomiHonorificPrefix?: string;
  yomiHonorificSuffix?: string;
  yomiMiddleName?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiName(data: any): AppsPeopleOzExternalMergedpeopleapiName {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiName(data: any): AppsPeopleOzExternalMergedpeopleapiName {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Pronunciation audio metadata info. See go/name-pronunciation-backend. The
 * metadata itself tracks the state of a user's name pronunciation audio.
 */
export interface AppsPeopleOzExternalMergedpeopleapiNamePronunciationAudioMetadataInfo {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * Actual metadata proto, shared with FBS backends.
   */
  namePronunciationAudioMetadata?: SocialGraphApiProtoNamePronunciationAudioMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiNamePronunciationAudioMetadataInfo(data: any): AppsPeopleOzExternalMergedpeopleapiNamePronunciationAudioMetadataInfo {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiNamePronunciationAudioMetadataInfo(data: any): AppsPeopleOzExternalMergedpeopleapiNamePronunciationAudioMetadataInfo {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiNickname {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  type?:  | "NICKNAME_UNKNOWN" | "DEFAULT" | "OTHER_NAME" | "MAIDEN_NAME" | "SHORT_NAME" | "INITIALS" | "ALTERNATE_NAME";
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiNickname(data: any): AppsPeopleOzExternalMergedpeopleapiNickname {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiNickname(data: any): AppsPeopleOzExternalMergedpeopleapiNickname {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiOccupation {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiOccupation(data: any): AppsPeopleOzExternalMergedpeopleapiOccupation {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiOccupation(data: any): AppsPeopleOzExternalMergedpeopleapiOccupation {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * The periods that this place is open during the week. The periods are in
 * chronological order, starting with today in the place-local timezone. An
 * empty (but not absent) value indicates a place that is never open, e.g.
 * because it is closed temporarily for renovations.
 */
export interface AppsPeopleOzExternalMergedpeopleapiOpeningHours {
  /**
   * Is this place open right now? Always present unless we lack time-of-day or
   * timezone data for these opening hours.
   */
  openNow?: boolean;
  periods?: AppsPeopleOzExternalMergedpeopleapiOpeningHoursPeriod[];
  /**
   * Localized strings describing the opening hours of this place, one string
   * for each day of the week. Will be empty if the hours are unknown or could
   * not be converted to localized text. Example: "Sun: 18:00-06:00"
   */
  weekdayTexts?: string[];
}

export interface AppsPeopleOzExternalMergedpeopleapiOpeningHoursEndpoint {
  /**
   * A day of the week, as an integer in the range 0-6. 0 is Sunday, 1 is
   * Monday, etc.
   */
  day?: number;
  /**
   * A time in 24-hour "hhmm" format (i.e. range is 0000 to 2359).
   */
  time?: string;
}

export interface AppsPeopleOzExternalMergedpeopleapiOpeningHoursPeriod {
  close?: AppsPeopleOzExternalMergedpeopleapiOpeningHoursEndpoint;
  open?: AppsPeopleOzExternalMergedpeopleapiOpeningHoursEndpoint;
}

export interface AppsPeopleOzExternalMergedpeopleapiOrganization {
  assignment?: AppsPeopleOzExternalMergedpeopleapiOrganizationAssignment[];
  certification?: string;
  costCenter?: string;
  current?: boolean;
  department?: string;
  description?: string;
  domain?: string;
  /**
   * Start and End Dates are better represented as calendar entities. The
   * intention is to replace timestamps. Not set if no value exists. Clients can
   * choose whether to use has* semantics or default value semantics. For
   * writes, the default proto and an absent message are equivalent. Legacy
   * callers in the legacy_timestamp_event_write_behavior_enabled capability
   * allowlist should write to PeopleApi via end_ms and migrate to setting both
   * so they can be removed from the whitelist.
   */
  endCalendarDay?: GoogleTypeDate;
  /**
   * Clients are encouraged to read the end_calendar_day instead. PeopleApi
   * writes will still use end_ms for legacy callers that are in the
   * legacy_timestamp_event_write_behavior_enabled capability allowlist. New
   * writers must use the calendar_day fields.
   */
  endMs?: bigint;
  endMsAsNumber?: bigint;
  /**
   * The `string_type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedStringType?: string;
  fteMilliPercent?: number;
  importance?: number;
  location?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  name?: string;
  project?: AppsPeopleOzExternalMergedpeopleapiOrganizationProject[];
  /**
   * Start and End Dates are better represented as calendar entities. The
   * intention is to replace timestamps. Not set if no value exists. Clients can
   * choose whether to use has* semantics or default value semantics. For
   * writes, the default proto and an absent message are equivalent. Legacy
   * callers in the legacy_timestamp_event_write_behavior_enabled capability
   * allowlist should write to PeopleApi via start_ms and migrate to setting
   * both so they can be removed from the allowlist.
   */
  startCalendarDay?: GoogleTypeDate;
  /**
   * Clients are encouraged to read the start_calendar_day instead. PeopleApi
   * writes will still use start_ms for legacy callers that are in the
   * legacy_timestamp_event_write_behavior_enabled capability allowlist. New
   * writers must use the calendar_day fields.
   */
  startMs?: bigint;
  startMsAsNumber?: bigint;
  /**
   * The type of the organization. The type can be free form or one of these
   * predefined values: * `work` * `school`
   */
  stringType?: string;
  symbol?: string;
  title?: string;
  type?:  | "UNKNOWN" | "WORK" | "SCHOOL" | "DOMAIN_ONLY";
  yomiName?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiOrganization(data: any): AppsPeopleOzExternalMergedpeopleapiOrganization {
  return {
    ...data,
    endMs: data["endMs"] !== undefined ? String(data["endMs"]) : undefined,
    endMsAsNumber: data["endMsAsNumber"] !== undefined ? String(data["endMsAsNumber"]) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    startMs: data["startMs"] !== undefined ? String(data["startMs"]) : undefined,
    startMsAsNumber: data["startMsAsNumber"] !== undefined ? String(data["startMsAsNumber"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiOrganization(data: any): AppsPeopleOzExternalMergedpeopleapiOrganization {
  return {
    ...data,
    endMs: data["endMs"] !== undefined ? BigInt(data["endMs"]) : undefined,
    endMsAsNumber: data["endMsAsNumber"] !== undefined ? BigInt(data["endMsAsNumber"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    startMs: data["startMs"] !== undefined ? BigInt(data["startMs"]) : undefined,
    startMsAsNumber: data["startMsAsNumber"] !== undefined ? BigInt(data["startMsAsNumber"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiOrganizationAssignment {
  name?: string;
  url?: string;
}

export interface AppsPeopleOzExternalMergedpeopleapiOrganizationProject {
  description?: string;
  name?: string;
  role?: string;
  /**
   * Mapped from StandardProjectTag / CustomProjectTag
   */
  type?: string;
  url?: string;
}

export interface AppsPeopleOzExternalMergedpeopleapiOtherKeyword {
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  source?:  | "SOURCE_UNKNOWN" | "OUTLOOK" | "CUSTOM";
  /**
   * The type of the event. The type depends on the `OtherKeyword.source`.
   * `OUTLOOK` source fields must be one of: * `billing_information` *
   * `directory_server` * `keyword` * `mileage` * `sensitivity` * `user` *
   * `subject` All other fields are treated as a `CUSTOM` source field. The
   * value can be free form or one of these predefined values: * `home` *
   * `other` * `work`
   */
  type?: string;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiOtherKeyword(data: any): AppsPeopleOzExternalMergedpeopleapiOtherKeyword {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiOtherKeyword(data: any): AppsPeopleOzExternalMergedpeopleapiOtherKeyword {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Merged-person combines multiple sources of data like contacts and profiles.
 * See go/people-api and go/understanding-merged-person NOTE: Why are all the
 * fields repeated? See go/people-api-concepts#repeated
 */
export interface AppsPeopleOzExternalMergedpeopleapiPerson {
  about?: AppsPeopleOzExternalMergedpeopleapiAbout[];
  address?: AppsPeopleOzExternalMergedpeopleapiAddress[];
  /**
   * Deprecated. If age is needed use `person.age_range_repeated` instead.
   * Please see go/people-api-howto:age on how to correctly get age data.
   */
  ageRange?:  | "UNKNOWN" | "LESS_THAN_EIGHTEEN" | "TWENTY_ONE_OR_OLDER" | "EIGHTEEN_TO_TWENTY";
  /**
   * Data on the person's age range, adult status, and age of consent. NOTE:
   * Please read go/people-api-howto:age on how to correctly get age data.
   */
  ageRangeRepeated?: AppsPeopleOzExternalMergedpeopleapiAgeRangeType[];
  birthday?: AppsPeopleOzExternalMergedpeopleapiBirthday[];
  /**
   * Used only by contacts, no data will be returned for profiles.
   */
  braggingRights?: AppsPeopleOzExternalMergedpeopleapiBraggingRights[];
  /**
   * b/145671020: Deprecated for Profiles, but not for Contacts.
   */
  calendar?: AppsPeopleOzExternalMergedpeopleapiCalendar[];
  certifiedBornBefore?: AppsPeopleOzExternalMergedpeopleapiCertifiedBornBefore[];
  /**
   * Circles that this person is a member of.
   */
  circleMembership?: AppsPeopleOzExternalMergedpeopleapiCircleMembership[];
  clientData?: AppsPeopleOzExternalMergedpeopleapiClientData[];
  communicationEmail?: AppsPeopleOzExternalMergedpeopleapiCommunicationEmail[];
  /**
   * Reminder to connect with a Contact (part of go/people-prompts). Also
   * contains contact-level prompts settings. Each Contact can have a single
   * `connection_reminder` (but can have multiple Prompts inside of it). Field
   * is repeated per PeopleAPI data model go/people-api-concepts#repeated. Only
   * supported for CONTACT container.
   */
  connectionReminder?: AppsPeopleOzExternalMergedpeopleapiConnectionReminder[];
  contactCreateContextInfo?: AppsPeopleOzExternalMergedpeopleapiContactCreateContextInfo[];
  contactEditContextInfo?: AppsPeopleOzExternalMergedpeopleapiContactEditContextInfo[];
  /**
   * Contact groups that this person is a member of.
   */
  contactGroupMembership?: AppsPeopleOzExternalMergedpeopleapiContactGroupMembership[];
  /**
   * Contact state and related metadata. See go/fbs-contacts-trash. If this
   * field was requested but is not set on the Person then the contact is in the
   * DEFAULT contact state. This field is read-only, and should not be set on a
   * mutate (e.g. UpdatePerson) call. Clients must call the explicit APIs (e.g.
   * UntrashPerson) to change contact state.
   */
  contactStateInfo?: AppsPeopleOzExternalMergedpeopleapiContactStateInfo[];
  /**
   * DEPRECATED. Now always returns a default cover photo. See
   * go/sunset-cover-photo.
   */
  coverPhoto?: AppsPeopleOzExternalMergedpeopleapiCoverPhoto[];
  customSchemaField?: AppsPeopleOzExternalMergedpeopleapiCustomSchemaField[];
  email?: AppsPeopleOzExternalMergedpeopleapiEmail[];
  /**
   * Emergency information. See go/emergency-trusted-contacts-papi.
   */
  emergencyInfo?: AppsPeopleOzExternalMergedpeopleapiEmergencyInfo[];
  /**
   * Event is currently in use by contacts.
   */
  event?: AppsPeopleOzExternalMergedpeopleapiEvent[];
  /**
   * Data added by extensions that are not specific to a particular field.
   */
  extendedData?: AppsPeopleOzExternalMergedpeopleapiPersonExtendedData;
  externalId?: AppsPeopleOzExternalMergedpeopleapiExternalId[];
  fileAs?: AppsPeopleOzExternalMergedpeopleapiFileAs[];
  /**
   * A fingerprint that can be used to reliably determine if a resource has
   * changed. Externally it is used as part of the etag.
   */
  fingerprint?: string;
  gender?: AppsPeopleOzExternalMergedpeopleapiGender[];
  im?: AppsPeopleOzExternalMergedpeopleapiIm[];
  /**
   * Ways to send in-app notifications to this person. See go/reachability.
   * This field is read-only and ignored for mutates.
   */
  inAppNotificationTarget?: AppsPeopleOzExternalMergedpeopleapiInAppNotificationTarget[];
  /**
   * Used only by profile service, deprecated for PeopleAPI and Sharpen. If you
   * aren't sure, contact people-api-users@ and profile-service-eng@.
   */
  inAppReachability?: AppsPeopleOzExternalMergedpeopleapiInAppReachability[];
  /**
   * DEPRECATED. This field isn't populated in people.list.
   */
  interactionSettings?: AppsPeopleOzExternalMergedpeopleapiInteractionSettings[];
  interest?: AppsPeopleOzExternalMergedpeopleapiInterest[];
  language?: AppsPeopleOzExternalMergedpeopleapiLanguage[];
  /**
   * DEPRECATED. This field was only for backwards compatibility with legacy
   * GData callers, and should not be used by new clients. Legacy fields used
   * for mobile clients.
   */
  legacyFields?: AppsPeopleOzExternalMergedpeopleapiLegacyFields;
  /**
   * Settings for the limited profile. See go/limited-profiles-api.
   */
  limitedProfileSettings?: AppsPeopleOzExternalMergedpeopleapiLimitedProfileSettingsField[];
  /**
   * Other person resources linked indirectly by an edge. The full person or
   * just the IDs may be populated depending on request parameters. We consider
   * linked people distinct people, but they share information. Example: A
   * contact with two outgoing edges. The two edges are considered separate, but
   * linked people.
   */
  linkedPerson?: AppsPeopleOzExternalMergedpeopleapiPerson[];
  location?: AppsPeopleOzExternalMergedpeopleapiLocation[];
  managementUpchain?: AppsPeopleOzExternalMergedpeopleapiManagementUpchain[];
  /**
   * MapsProfile, see go/product-profiles-backend-api
   */
  mapsProfile?: AppsPeopleOzExternalMergedpeopleapiMapsProfile[];
  /**
   * DEPRECATED. Please use `circle_membership` or `contact_group_membership`
   * instead. Contact-groups and circles that this person is a member of.
   */
  membership?: AppsPeopleOzExternalMergedpeopleapiMembership[];
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonMetadata;
  mission?: AppsPeopleOzExternalMergedpeopleapiMission[];
  /**
   * See go/people-api-howto:names for details about names in PeopleAPI.
   */
  name?: AppsPeopleOzExternalMergedpeopleapiName[];
  /**
   * Metadata info for a user's name pronunciation audio. See
   * go/name-pronunication-backend.
   */
  namePronunciationAudioMetadataInfo?: AppsPeopleOzExternalMergedpeopleapiNamePronunciationAudioMetadataInfo[];
  nickname?: AppsPeopleOzExternalMergedpeopleapiNickname[];
  occupation?: AppsPeopleOzExternalMergedpeopleapiOccupation[];
  organization?: AppsPeopleOzExternalMergedpeopleapiOrganization[];
  /**
   * Legacy arbitrary key value fields
   */
  otherKeyword?: AppsPeopleOzExternalMergedpeopleapiOtherKeyword[];
  /**
   * DEPRECATED. This feature was stubbed, but never implemented. This field
   * will not be populated with any results.
   */
  peopleInCommon?: AppsPeopleOzExternalMergedpeopleapiPerson[];
  /**
   * In order to request this field, the client must set desired
   * PersonAttributeKey in the dedicated RequestMask field `person_attribute`.
   * Unlike other person fields, this field cannot be requested in the
   * `include_field` field mask.
   */
  personAttribute?: AppsPeopleOzExternalMergedpeopleapiPersonAttribute[];
  /**
   * The ID of the person. This is determined by the backend, is unstable, and
   * may not be the same as a user_id. Internally referred as 'personKey' to
   * distinguish from the common PersonId pojo. See
   * go/people-api-concepts#person-id
   */
  personId?: string;
  phone?: AppsPeopleOzExternalMergedpeopleapiPhone[];
  /**
   * See go/people-api-concepts/photos for usage details
   */
  photo?: AppsPeopleOzExternalMergedpeopleapiPhoto[];
  /**
   * Data specific to places. Data which also applies to contacts and profiles
   * such as name, phone, photo, etc. are returned in the corresponding Person
   * fields.
   */
  placeDetails?: AppsPeopleOzExternalMergedpeopleapiPlaceDetails[];
  /**
   * DEPRECATED. Info about plus pages in the person.
   */
  plusPageInfo?: AppsPeopleOzExternalMergedpeopleapiPlusPageInfo[];
  posixAccount?: AppsPeopleOzExternalMergedpeopleapiPosixAccount[];
  /**
   * DEPRECATED. (go/people-api-concepts#repeated): Use
   * person.profile_url_repeated instead. Access to this field is restricted to
   * a set of legacy clients. This is a Google+-only field. See
   * go/fbs-g+-deprecation. NOTE: `Person.profile_url` is only populated for
   * profile-centric person.
   */
  profileUrl?: string;
  /**
   * This is a Google+-only field. See go/fbs-g+-deprecation.
   */
  profileUrlRepeated?: AppsPeopleOzExternalMergedpeopleapiProfileUrl[];
  /**
   * Pronouns are not supported for consumer profiles. See
   * go/pronouns-in-people-system-prd for more details.
   */
  pronoun?: AppsPeopleOzExternalMergedpeopleapiPronoun[];
  /**
   * Information about the profiles that are a part of this Person. This is
   * only applicable to PROFILE and DOMAIN_PROFILE containers.
   */
  readOnlyProfileInfo?: AppsPeopleOzExternalMergedpeopleapiReadOnlyProfileInfo[];
  /**
   * See go/relation-vs-relationship for relation vs relationship explanation.
   */
  relation?: AppsPeopleOzExternalMergedpeopleapiRelation[];
  /**
   * DEPRECATED. No data is returned for this field anymore.
   */
  relationshipInterest?: AppsPeopleOzExternalMergedpeopleapiRelationshipInterest[];
  /**
   * DEPRECATED. No data is returned for this field anymore.
   */
  relationshipStatus?: AppsPeopleOzExternalMergedpeopleapiRelationshipStatus[];
  rightOfPublicityState?: AppsPeopleOzExternalMergedpeopleapiRightOfPublicityState[];
  /**
   * Data specific to rosters (such as Google Groups and Chat Rooms). Data
   * which also applies to contacts and profiles such as name, email, and photo,
   * etc are returned in the corresponding Person fields.
   */
  rosterDetails?: AppsPeopleOzExternalMergedpeopleapiRosterDetails[];
  /**
   * Profile for Janata and Search. go/janata-profile-in-sgbe
   */
  searchProfile?: AppsPeopleOzExternalMergedpeopleapiSearchProfile[];
  /**
   * SipAddress is currently in use by contacts.
   */
  sipAddress?: AppsPeopleOzExternalMergedpeopleapiSipAddress[];
  skills?: AppsPeopleOzExternalMergedpeopleapiSkills[];
  /**
   * NOTE: this is used by go/starlight, but not actually used or returned in
   * PeopleAPI. See b/27281119 for context. Please reach out to people-api-eng@
   * if you have questions.
   */
  socialConnection?: AppsPeopleOzExternalMergedpeopleapiSocialConnection[];
  sortKeys?: AppsPeopleOzExternalMergedpeopleapiSortKeys;
  sshPublicKey?: AppsPeopleOzExternalMergedpeopleapiSshPublicKey[];
  /**
   * Only supported for PLACE container results, no data will be returned for
   * profiles.
   */
  tagline?: AppsPeopleOzExternalMergedpeopleapiTagline[];
  /**
   * DEPRECATED. *UNSUPPORTED*. This field is never populated.
   */
  teamsExtendedData?: AppsPeopleOzExternalMergedpeopleapiTeamsExtendedData;
  /**
   * UserDefined is currently in use by contacts.
   */
  userDefined?: AppsPeopleOzExternalMergedpeopleapiUserDefined[];
  /**
   * Add annotation_id and metadata (product_source) for visible to guests
   * contacts go/visible-to-guests.
   */
  visibleToGuests?: AppsPeopleOzExternalMergedpeopleapiVisibleToGuests[];
  website?: AppsPeopleOzExternalMergedpeopleapiWebsite[];
}

function serializeAppsPeopleOzExternalMergedpeopleapiPerson(data: any): AppsPeopleOzExternalMergedpeopleapiPerson {
  return {
    ...data,
    about: data["about"] !== undefined ? data["about"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiAbout(item))) : undefined,
    address: data["address"] !== undefined ? data["address"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiAddress(item))) : undefined,
    ageRangeRepeated: data["ageRangeRepeated"] !== undefined ? data["ageRangeRepeated"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiAgeRangeType(item))) : undefined,
    birthday: data["birthday"] !== undefined ? data["birthday"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiBirthday(item))) : undefined,
    braggingRights: data["braggingRights"] !== undefined ? data["braggingRights"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiBraggingRights(item))) : undefined,
    calendar: data["calendar"] !== undefined ? data["calendar"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiCalendar(item))) : undefined,
    certifiedBornBefore: data["certifiedBornBefore"] !== undefined ? data["certifiedBornBefore"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiCertifiedBornBefore(item))) : undefined,
    circleMembership: data["circleMembership"] !== undefined ? data["circleMembership"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiCircleMembership(item))) : undefined,
    clientData: data["clientData"] !== undefined ? data["clientData"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiClientData(item))) : undefined,
    communicationEmail: data["communicationEmail"] !== undefined ? data["communicationEmail"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiCommunicationEmail(item))) : undefined,
    connectionReminder: data["connectionReminder"] !== undefined ? data["connectionReminder"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiConnectionReminder(item))) : undefined,
    contactCreateContextInfo: data["contactCreateContextInfo"] !== undefined ? data["contactCreateContextInfo"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiContactCreateContextInfo(item))) : undefined,
    contactEditContextInfo: data["contactEditContextInfo"] !== undefined ? data["contactEditContextInfo"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiContactEditContextInfo(item))) : undefined,
    contactGroupMembership: data["contactGroupMembership"] !== undefined ? data["contactGroupMembership"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiContactGroupMembership(item))) : undefined,
    contactStateInfo: data["contactStateInfo"] !== undefined ? data["contactStateInfo"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiContactStateInfo(item))) : undefined,
    coverPhoto: data["coverPhoto"] !== undefined ? data["coverPhoto"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiCoverPhoto(item))) : undefined,
    customSchemaField: data["customSchemaField"] !== undefined ? data["customSchemaField"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiCustomSchemaField(item))) : undefined,
    email: data["email"] !== undefined ? data["email"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiEmail(item))) : undefined,
    emergencyInfo: data["emergencyInfo"] !== undefined ? data["emergencyInfo"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiEmergencyInfo(item))) : undefined,
    event: data["event"] !== undefined ? data["event"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiEvent(item))) : undefined,
    extendedData: data["extendedData"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonExtendedData(data["extendedData"]) : undefined,
    externalId: data["externalId"] !== undefined ? data["externalId"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiExternalId(item))) : undefined,
    fileAs: data["fileAs"] !== undefined ? data["fileAs"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiFileAs(item))) : undefined,
    gender: data["gender"] !== undefined ? data["gender"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiGender(item))) : undefined,
    im: data["im"] !== undefined ? data["im"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiIm(item))) : undefined,
    inAppNotificationTarget: data["inAppNotificationTarget"] !== undefined ? data["inAppNotificationTarget"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiInAppNotificationTarget(item))) : undefined,
    inAppReachability: data["inAppReachability"] !== undefined ? data["inAppReachability"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiInAppReachability(item))) : undefined,
    interactionSettings: data["interactionSettings"] !== undefined ? data["interactionSettings"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiInteractionSettings(item))) : undefined,
    interest: data["interest"] !== undefined ? data["interest"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiInterest(item))) : undefined,
    language: data["language"] !== undefined ? data["language"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiLanguage(item))) : undefined,
    limitedProfileSettings: data["limitedProfileSettings"] !== undefined ? data["limitedProfileSettings"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiLimitedProfileSettingsField(item))) : undefined,
    linkedPerson: data["linkedPerson"] !== undefined ? data["linkedPerson"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
    location: data["location"] !== undefined ? data["location"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiLocation(item))) : undefined,
    managementUpchain: data["managementUpchain"] !== undefined ? data["managementUpchain"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiManagementUpchain(item))) : undefined,
    mapsProfile: data["mapsProfile"] !== undefined ? data["mapsProfile"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiMapsProfile(item))) : undefined,
    membership: data["membership"] !== undefined ? data["membership"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiMembership(item))) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonMetadata(data["metadata"]) : undefined,
    mission: data["mission"] !== undefined ? data["mission"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiMission(item))) : undefined,
    name: data["name"] !== undefined ? data["name"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiName(item))) : undefined,
    namePronunciationAudioMetadataInfo: data["namePronunciationAudioMetadataInfo"] !== undefined ? data["namePronunciationAudioMetadataInfo"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiNamePronunciationAudioMetadataInfo(item))) : undefined,
    nickname: data["nickname"] !== undefined ? data["nickname"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiNickname(item))) : undefined,
    occupation: data["occupation"] !== undefined ? data["occupation"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiOccupation(item))) : undefined,
    organization: data["organization"] !== undefined ? data["organization"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiOrganization(item))) : undefined,
    otherKeyword: data["otherKeyword"] !== undefined ? data["otherKeyword"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiOtherKeyword(item))) : undefined,
    peopleInCommon: data["peopleInCommon"] !== undefined ? data["peopleInCommon"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
    personAttribute: data["personAttribute"] !== undefined ? data["personAttribute"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPersonAttribute(item))) : undefined,
    phone: data["phone"] !== undefined ? data["phone"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPhone(item))) : undefined,
    photo: data["photo"] !== undefined ? data["photo"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPhoto(item))) : undefined,
    placeDetails: data["placeDetails"] !== undefined ? data["placeDetails"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPlaceDetails(item))) : undefined,
    plusPageInfo: data["plusPageInfo"] !== undefined ? data["plusPageInfo"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPlusPageInfo(item))) : undefined,
    posixAccount: data["posixAccount"] !== undefined ? data["posixAccount"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPosixAccount(item))) : undefined,
    profileUrlRepeated: data["profileUrlRepeated"] !== undefined ? data["profileUrlRepeated"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiProfileUrl(item))) : undefined,
    pronoun: data["pronoun"] !== undefined ? data["pronoun"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPronoun(item))) : undefined,
    readOnlyProfileInfo: data["readOnlyProfileInfo"] !== undefined ? data["readOnlyProfileInfo"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiReadOnlyProfileInfo(item))) : undefined,
    relation: data["relation"] !== undefined ? data["relation"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiRelation(item))) : undefined,
    relationshipInterest: data["relationshipInterest"] !== undefined ? data["relationshipInterest"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiRelationshipInterest(item))) : undefined,
    relationshipStatus: data["relationshipStatus"] !== undefined ? data["relationshipStatus"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiRelationshipStatus(item))) : undefined,
    rightOfPublicityState: data["rightOfPublicityState"] !== undefined ? data["rightOfPublicityState"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiRightOfPublicityState(item))) : undefined,
    rosterDetails: data["rosterDetails"] !== undefined ? data["rosterDetails"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiRosterDetails(item))) : undefined,
    searchProfile: data["searchProfile"] !== undefined ? data["searchProfile"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiSearchProfile(item))) : undefined,
    sipAddress: data["sipAddress"] !== undefined ? data["sipAddress"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiSipAddress(item))) : undefined,
    skills: data["skills"] !== undefined ? data["skills"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiSkills(item))) : undefined,
    socialConnection: data["socialConnection"] !== undefined ? data["socialConnection"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiSocialConnection(item))) : undefined,
    sshPublicKey: data["sshPublicKey"] !== undefined ? data["sshPublicKey"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiSshPublicKey(item))) : undefined,
    tagline: data["tagline"] !== undefined ? data["tagline"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiTagline(item))) : undefined,
    teamsExtendedData: data["teamsExtendedData"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiTeamsExtendedData(data["teamsExtendedData"]) : undefined,
    userDefined: data["userDefined"] !== undefined ? data["userDefined"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiUserDefined(item))) : undefined,
    visibleToGuests: data["visibleToGuests"] !== undefined ? data["visibleToGuests"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiVisibleToGuests(item))) : undefined,
    website: data["website"] !== undefined ? data["website"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiWebsite(item))) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPerson(data: any): AppsPeopleOzExternalMergedpeopleapiPerson {
  return {
    ...data,
    about: data["about"] !== undefined ? data["about"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiAbout(item))) : undefined,
    address: data["address"] !== undefined ? data["address"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiAddress(item))) : undefined,
    ageRangeRepeated: data["ageRangeRepeated"] !== undefined ? data["ageRangeRepeated"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiAgeRangeType(item))) : undefined,
    birthday: data["birthday"] !== undefined ? data["birthday"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiBirthday(item))) : undefined,
    braggingRights: data["braggingRights"] !== undefined ? data["braggingRights"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiBraggingRights(item))) : undefined,
    calendar: data["calendar"] !== undefined ? data["calendar"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiCalendar(item))) : undefined,
    certifiedBornBefore: data["certifiedBornBefore"] !== undefined ? data["certifiedBornBefore"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiCertifiedBornBefore(item))) : undefined,
    circleMembership: data["circleMembership"] !== undefined ? data["circleMembership"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiCircleMembership(item))) : undefined,
    clientData: data["clientData"] !== undefined ? data["clientData"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiClientData(item))) : undefined,
    communicationEmail: data["communicationEmail"] !== undefined ? data["communicationEmail"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiCommunicationEmail(item))) : undefined,
    connectionReminder: data["connectionReminder"] !== undefined ? data["connectionReminder"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiConnectionReminder(item))) : undefined,
    contactCreateContextInfo: data["contactCreateContextInfo"] !== undefined ? data["contactCreateContextInfo"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiContactCreateContextInfo(item))) : undefined,
    contactEditContextInfo: data["contactEditContextInfo"] !== undefined ? data["contactEditContextInfo"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiContactEditContextInfo(item))) : undefined,
    contactGroupMembership: data["contactGroupMembership"] !== undefined ? data["contactGroupMembership"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiContactGroupMembership(item))) : undefined,
    contactStateInfo: data["contactStateInfo"] !== undefined ? data["contactStateInfo"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiContactStateInfo(item))) : undefined,
    coverPhoto: data["coverPhoto"] !== undefined ? data["coverPhoto"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiCoverPhoto(item))) : undefined,
    customSchemaField: data["customSchemaField"] !== undefined ? data["customSchemaField"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiCustomSchemaField(item))) : undefined,
    email: data["email"] !== undefined ? data["email"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiEmail(item))) : undefined,
    emergencyInfo: data["emergencyInfo"] !== undefined ? data["emergencyInfo"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiEmergencyInfo(item))) : undefined,
    event: data["event"] !== undefined ? data["event"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiEvent(item))) : undefined,
    extendedData: data["extendedData"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonExtendedData(data["extendedData"]) : undefined,
    externalId: data["externalId"] !== undefined ? data["externalId"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiExternalId(item))) : undefined,
    fileAs: data["fileAs"] !== undefined ? data["fileAs"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiFileAs(item))) : undefined,
    gender: data["gender"] !== undefined ? data["gender"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiGender(item))) : undefined,
    im: data["im"] !== undefined ? data["im"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiIm(item))) : undefined,
    inAppNotificationTarget: data["inAppNotificationTarget"] !== undefined ? data["inAppNotificationTarget"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiInAppNotificationTarget(item))) : undefined,
    inAppReachability: data["inAppReachability"] !== undefined ? data["inAppReachability"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiInAppReachability(item))) : undefined,
    interactionSettings: data["interactionSettings"] !== undefined ? data["interactionSettings"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiInteractionSettings(item))) : undefined,
    interest: data["interest"] !== undefined ? data["interest"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiInterest(item))) : undefined,
    language: data["language"] !== undefined ? data["language"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiLanguage(item))) : undefined,
    limitedProfileSettings: data["limitedProfileSettings"] !== undefined ? data["limitedProfileSettings"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiLimitedProfileSettingsField(item))) : undefined,
    linkedPerson: data["linkedPerson"] !== undefined ? data["linkedPerson"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
    location: data["location"] !== undefined ? data["location"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiLocation(item))) : undefined,
    managementUpchain: data["managementUpchain"] !== undefined ? data["managementUpchain"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiManagementUpchain(item))) : undefined,
    mapsProfile: data["mapsProfile"] !== undefined ? data["mapsProfile"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiMapsProfile(item))) : undefined,
    membership: data["membership"] !== undefined ? data["membership"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiMembership(item))) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonMetadata(data["metadata"]) : undefined,
    mission: data["mission"] !== undefined ? data["mission"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiMission(item))) : undefined,
    name: data["name"] !== undefined ? data["name"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiName(item))) : undefined,
    namePronunciationAudioMetadataInfo: data["namePronunciationAudioMetadataInfo"] !== undefined ? data["namePronunciationAudioMetadataInfo"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiNamePronunciationAudioMetadataInfo(item))) : undefined,
    nickname: data["nickname"] !== undefined ? data["nickname"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiNickname(item))) : undefined,
    occupation: data["occupation"] !== undefined ? data["occupation"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiOccupation(item))) : undefined,
    organization: data["organization"] !== undefined ? data["organization"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiOrganization(item))) : undefined,
    otherKeyword: data["otherKeyword"] !== undefined ? data["otherKeyword"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiOtherKeyword(item))) : undefined,
    peopleInCommon: data["peopleInCommon"] !== undefined ? data["peopleInCommon"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
    personAttribute: data["personAttribute"] !== undefined ? data["personAttribute"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPersonAttribute(item))) : undefined,
    phone: data["phone"] !== undefined ? data["phone"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPhone(item))) : undefined,
    photo: data["photo"] !== undefined ? data["photo"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPhoto(item))) : undefined,
    placeDetails: data["placeDetails"] !== undefined ? data["placeDetails"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPlaceDetails(item))) : undefined,
    plusPageInfo: data["plusPageInfo"] !== undefined ? data["plusPageInfo"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPlusPageInfo(item))) : undefined,
    posixAccount: data["posixAccount"] !== undefined ? data["posixAccount"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPosixAccount(item))) : undefined,
    profileUrlRepeated: data["profileUrlRepeated"] !== undefined ? data["profileUrlRepeated"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiProfileUrl(item))) : undefined,
    pronoun: data["pronoun"] !== undefined ? data["pronoun"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPronoun(item))) : undefined,
    readOnlyProfileInfo: data["readOnlyProfileInfo"] !== undefined ? data["readOnlyProfileInfo"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiReadOnlyProfileInfo(item))) : undefined,
    relation: data["relation"] !== undefined ? data["relation"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiRelation(item))) : undefined,
    relationshipInterest: data["relationshipInterest"] !== undefined ? data["relationshipInterest"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiRelationshipInterest(item))) : undefined,
    relationshipStatus: data["relationshipStatus"] !== undefined ? data["relationshipStatus"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiRelationshipStatus(item))) : undefined,
    rightOfPublicityState: data["rightOfPublicityState"] !== undefined ? data["rightOfPublicityState"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiRightOfPublicityState(item))) : undefined,
    rosterDetails: data["rosterDetails"] !== undefined ? data["rosterDetails"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiRosterDetails(item))) : undefined,
    searchProfile: data["searchProfile"] !== undefined ? data["searchProfile"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiSearchProfile(item))) : undefined,
    sipAddress: data["sipAddress"] !== undefined ? data["sipAddress"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiSipAddress(item))) : undefined,
    skills: data["skills"] !== undefined ? data["skills"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiSkills(item))) : undefined,
    socialConnection: data["socialConnection"] !== undefined ? data["socialConnection"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiSocialConnection(item))) : undefined,
    sshPublicKey: data["sshPublicKey"] !== undefined ? data["sshPublicKey"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiSshPublicKey(item))) : undefined,
    tagline: data["tagline"] !== undefined ? data["tagline"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiTagline(item))) : undefined,
    teamsExtendedData: data["teamsExtendedData"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiTeamsExtendedData(data["teamsExtendedData"]) : undefined,
    userDefined: data["userDefined"] !== undefined ? data["userDefined"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiUserDefined(item))) : undefined,
    visibleToGuests: data["visibleToGuests"] !== undefined ? data["visibleToGuests"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiVisibleToGuests(item))) : undefined,
    website: data["website"] !== undefined ? data["website"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiWebsite(item))) : undefined,
  };
}

/**
 * Client-specific binary blob stored with Person data. This differs from
 * ClientData, which stores structured, key-value pairs.
 */
export interface AppsPeopleOzExternalMergedpeopleapiPersonAttribute {
  attributeKey?:  | "PERSON_ATTRIBUTE_UNKNOWN" | "REJECTED_CLEANUP_CARD_SUGGESTIONS";
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiPersonAttribute(data: any): AppsPeopleOzExternalMergedpeopleapiPersonAttribute {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPersonAttribute(data: any): AppsPeopleOzExternalMergedpeopleapiPersonAttribute {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Extension data for the whole person entity.
 */
export interface AppsPeopleOzExternalMergedpeopleapiPersonExtendedData {
  /**
   * For use by AboutMe and SmartProfile clients.
   */
  aboutMeExtendedData?: AppsPeopleOzExternalMergedpeopleapiAboutMeExtendedData;
  /**
   * For use with Apps Waldo Availability Data extension
   */
  appsWaldoExtendedData?: SocialGraphWireProtoPeopleapiExtensionAppsWaldoExtendedData;
  /**
   * For use with caller ID extension
   */
  callerIdExtendedData?: AppsPeopleOzExternalMergedpeopleapiCallerIdExtendedData;
  /**
   * For use with Contacts extension.
   */
  contactsExtendedData?: AppsPeopleOzExternalMergedpeopleapiWebContactsExtendedData;
  /**
   * Hosted domain this person is a member of. The domain_name is also returned
   * as part of the person's ReadOnlyProfileInfo, so requesting it via this
   * extension is no longer necessary.
   */
  domainName?: string[];
  /**
   * For use with Dynamite extension.
   */
  dynamiteExtendedData?: SocialGraphWireProtoPeopleapiExtensionDynamiteExtendedData;
  /**
   * For use with Google Pay extension.
   */
  gpayExtendedData?: AppsPeopleOzExternalMergedpeopleapiGPayExtendedData;
  /**
   * For use with Google+ extension.
   */
  gplusExtendedData?: AppsPeopleOzExternalMergedpeopleapiGplusExtendedData;
  /**
   * For use with Hangouts extension.
   */
  hangoutsExtendedData?: AppsPeopleOzExternalMergedpeopleapiHangoutsExtendedData;
  /**
   * For use with gmail extensions and lookup by email. If true, no person was
   * actually found using the specified email address, but we want to return TLS
   * info about the email address regardless.
   */
  isPlaceholder?: boolean;
  /**
   * For use with Maps extension.
   */
  mapsExtendedData?: AppsPeopleOzExternalMergedpeopleapiMapsExtendedData;
  /**
   * For use with Paisa extension
   */
  paisaExtendedData?: SocialGraphWireProtoPeopleapiExtensionPaisaExtendedData;
  /**
   * DEPRECATED: Use people_stack_person_extended_data instead. For use with
   * PeopleStack extension.
   */
  peopleStackExtendedData?: SocialGraphWireProtoPeopleapiExtensionPeopleStackExtendedData;
  /**
   * For use with PeopleStack extension.
   */
  peopleStackPersonExtendedData?: SocialGraphWireProtoPeopleapiExtensionPeopleStackPersonExtendedData;
  /**
   * For use with Play Games Product Profile extension. See
   * go/jam-games-profile. The play games profile will be returned only for
   * profile-centric requests.
   */
  playGamesExtendedData?: AppsPeopleOzExternalMergedpeopleapiPlayGamesExtendedData;
  /**
   * For use with the TLS extension and lookup by email. If true, no person was
   * actually found using the specified email address, but we want to return TLS
   * info about the email address regardless. DEPRECATED: Use is_placeholder
   * instead.
   */
  tlsIsPlaceholder?: boolean;
  /**
   * For use with Youtube extension.
   */
  youtubeExtendedData?: AppsPeopleOzExternalMergedpeopleapiYoutubeExtendedData;
}

function serializeAppsPeopleOzExternalMergedpeopleapiPersonExtendedData(data: any): AppsPeopleOzExternalMergedpeopleapiPersonExtendedData {
  return {
    ...data,
    aboutMeExtendedData: data["aboutMeExtendedData"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiAboutMeExtendedData(data["aboutMeExtendedData"]) : undefined,
    appsWaldoExtendedData: data["appsWaldoExtendedData"] !== undefined ? serializeSocialGraphWireProtoPeopleapiExtensionAppsWaldoExtendedData(data["appsWaldoExtendedData"]) : undefined,
    dynamiteExtendedData: data["dynamiteExtendedData"] !== undefined ? serializeSocialGraphWireProtoPeopleapiExtensionDynamiteExtendedData(data["dynamiteExtendedData"]) : undefined,
    mapsExtendedData: data["mapsExtendedData"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiMapsExtendedData(data["mapsExtendedData"]) : undefined,
    playGamesExtendedData: data["playGamesExtendedData"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPlayGamesExtendedData(data["playGamesExtendedData"]) : undefined,
    youtubeExtendedData: data["youtubeExtendedData"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiYoutubeExtendedData(data["youtubeExtendedData"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPersonExtendedData(data: any): AppsPeopleOzExternalMergedpeopleapiPersonExtendedData {
  return {
    ...data,
    aboutMeExtendedData: data["aboutMeExtendedData"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiAboutMeExtendedData(data["aboutMeExtendedData"]) : undefined,
    appsWaldoExtendedData: data["appsWaldoExtendedData"] !== undefined ? deserializeSocialGraphWireProtoPeopleapiExtensionAppsWaldoExtendedData(data["appsWaldoExtendedData"]) : undefined,
    dynamiteExtendedData: data["dynamiteExtendedData"] !== undefined ? deserializeSocialGraphWireProtoPeopleapiExtensionDynamiteExtendedData(data["dynamiteExtendedData"]) : undefined,
    mapsExtendedData: data["mapsExtendedData"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiMapsExtendedData(data["mapsExtendedData"]) : undefined,
    playGamesExtendedData: data["playGamesExtendedData"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPlayGamesExtendedData(data["playGamesExtendedData"]) : undefined,
    youtubeExtendedData: data["youtubeExtendedData"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiYoutubeExtendedData(data["youtubeExtendedData"]) : undefined,
  };
}

/**
 * Metadata for a single Person field. See go/understanding-merged-person
 */
export interface AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata {
  /**
   * When the container is PROFILE/DOMAIN_PROFILE and the profile owner is the
   * requester, this read-only, synthesized field indicates which ACLs the user
   * is allowed to set on the profile field. This is distinct from field_acl,
   * which is the field's currently set ACL. field_acl will always be a valid
   * ACL choice, except for the case of default synthesized profile fields like
   * monogram profile photos. For those, field_acl does not represent a user-set
   * field ACL, so it may or may not be a valid choice. In all cases,
   * default_acl_choice will always be a valid choice. This is currently only
   * populated on the photo field when the "person.photo.metadata.acl_choices"
   * mask is set.
   */
  aclChoices?: AppsPeopleOzExternalMergedpeopleapiFieldAcl[];
  /**
   * Additional information about the container of this field.
   */
  additionalContainerInfo?: AppsPeopleOzExternalMergedpeopleapiAdditionalContainerInfo;
  /**
   * For field-level affinity scores. The affinity between the requester and
   * this particular field in the Person (e.g., frequency of calling a
   * particular phone number).
   */
  affinity?: AppsPeopleOzExternalMergedpeopleapiAffinity[];
  /**
   * Each field can have different visibility settings Only returned when
   * explicitly requested.
   */
  contactVisibility?:  | "CONTACT_VISIBILITY_UNSPECIFIED" | "VISIBLE_TO_GUEST"[];
  /**
   * DEPRECATED. Use container_type instead. Having the Container be an enum at
   * the PFM message level causes circular dependency when other types try to
   * refer to it. It breaks javascript build targets.
   */
  container?:  | "UNKNOWN" | "PROFILE" | "CONTACT" | "CIRCLE" | "PLACE" | "ACCOUNT" | "EXTERNAL_ACCOUNT" | "DOMAIN_PROFILE" | "DOMAIN_CONTACT" | "DEVICE_CONTACT" | "GOOGLE_GROUP" | "AFFINITY" | "RAW_DEVICE_CONTACT" | "CONTACT_ANNOTATION" | "DELEGATED_CONTACT";
  /**
   * DEPRECATED. Use encoded_container_id instead. The numeric id of the data
   * source. The id is only unique within a single container type. This is only
   * set when the id of the container is numeric, e.g. contact id.
   */
  containerId?: bigint;
  /**
   * Indicates if this field is the primary field for the container and
   * container_id.
   */
  containerPrimary?: boolean;
  /**
   * The source for the data in the field.
   */
  containerType?:  | "UNKNOWN_CONTAINER" | "PROFILE" | "CONTACT" | "CIRCLE" | "PLACE" | "ACCOUNT" | "EXTERNAL_ACCOUNT" | "DOMAIN_PROFILE" | "DOMAIN_CONTACT" | "DEVICE_CONTACT" | "GOOGLE_GROUP" | "NAMED_CHAT_ROOM" | "UNNAMED_CHAT_ROOM" | "AFFINITY" | "RAW_DEVICE_CONTACT" | "CONTACT_ANNOTATION" | "DELEGATED_CONTACT";
  /**
   * True if this field can be used on other devices than the one it originated
   * from. Assigned by the server. Currently only used for device contacts.
   */
  crossDeviceAllowed?: boolean;
  /**
   * When the container is PROFILE/DOMAIN_PROFILE and the profile owner is the
   * requester, this read-only, synthesized field contains the default ACL
   * choice. This can be used to select a preferred choice from acl_choices.
   * Generally, default_acl_choice should only be preferred for default
   * synthesized profile fields like monogram profile photos. Otherwise, the
   * existing field_acl should be preferred. This is currently only populated on
   * the photo field when the "person.photo.metadata.acl_choices" mask is set.
   */
  defaultAclChoice?: AppsPeopleOzExternalMergedpeopleapiFieldAcl;
  /**
   * DEPRECATED. Use container_id. Not populated or used at all.
   */
  deprecatedContactContainerId?: bigint;
  /**
   * Field is an edge key for this person. Modifying it breaks the link between
   * data sources. This is equivalent to edge_key_info having at least one entry
   * with materialized = true.
   */
  edgeKey?: boolean;
  /**
   * Edges that this field creates. This includes all edges and not necessarily
   * just the edge relevant to the joined entities.
   */
  edgeKeyInfo?: AppsPeopleOzExternalMergedpeopleapiEdgeKeyInfo[];
  /**
   * The encoded id of the data source. The id is only unique within a single
   * container type. This field correlates to
   * person.metadata.identity_info.source_id.id. This field may not be populated
   * in some special cases, where the id is not visible to the querying user.
   * e.g. ListAutocompletions with full phone number query.
   */
  encodedContainerId?: string;
  /**
   * When the container is PROFILE and the profile owner is the requester, this
   * field indicates how the profile field is accessible.
   */
  fieldAcl?: AppsPeopleOzExternalMergedpeopleapiFieldAcl;
  /**
   * Indicates the time that the field was added or last edited. Currently this
   * is populated for: (1) person.birthday with ContainerType PROFILE,
   * DOMAIN_PROFILE or ACCOUNT. (2) person.name, person.address,
   * person.relation, person.email and person.phone with ContainerType
   * CONTACT_ANNOTATION;
   */
  lastUpdateTime?: Date;
  /**
   * The matching informations if there was a query against this field.
   */
  matchingInfo?: AppsPeopleOzExternalMergedpeopleapiMatchInfo[];
  /**
   * When deduping fields by value, list of containers of the fields that where
   * deduped.
   */
  otherDedupedContainers?: AppsPeopleOzExternalMergedpeopleapiDedupedContainerInfo[];
  /**
   * If true, indicates this field is the Person's primary field eg. Contact,
   * and (Profile) Person could have different Name fields, and the Name
   * represented by the Person is primary. For selecting a primary field from
   * RepeatedFields within a Person, use container_primary.
   */
  primary?: boolean;
  /**
   * The product(s) that generated the data in this field. Empty is equivalent
   * to DEFAULT. ST_USER_METADATA
   */
  productMetadata?: AppsPeopleOzExternalMergedpeopleapiProductMetadata[];
  /**
   * Indicates whether this is a verified field. It is synthesized from
   * verification and is read-only. If there is at least one verification with
   * status PASSED, the field is considered verified. Currently this is
   * applicable to address, email, name, and phone for PROFILE and
   * DOMAIN_PROFILE. Use .metadata.verified in the request mask.
   */
  verified?: boolean;
  /**
   * Currently, only people.get may set this value
   */
  visibility?:  | "VISIBILITY_UNKNOWN" | "PUBLIC" | "USER";
  /**
   * Whether the field is writeable to the requester.
   */
  writeable?: boolean;
}

function serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data: any): AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata {
  return {
    ...data,
    additionalContainerInfo: data["additionalContainerInfo"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiAdditionalContainerInfo(data["additionalContainerInfo"]) : undefined,
    containerId: data["containerId"] !== undefined ? String(data["containerId"]) : undefined,
    deprecatedContactContainerId: data["deprecatedContactContainerId"] !== undefined ? String(data["deprecatedContactContainerId"]) : undefined,
    lastUpdateTime: data["lastUpdateTime"] !== undefined ? data["lastUpdateTime"].toISOString() : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data: any): AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata {
  return {
    ...data,
    additionalContainerInfo: data["additionalContainerInfo"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiAdditionalContainerInfo(data["additionalContainerInfo"]) : undefined,
    containerId: data["containerId"] !== undefined ? BigInt(data["containerId"]) : undefined,
    deprecatedContactContainerId: data["deprecatedContactContainerId"] !== undefined ? BigInt(data["deprecatedContactContainerId"]) : undefined,
    lastUpdateTime: data["lastUpdateTime"] !== undefined ? new Date(data["lastUpdateTime"]) : undefined,
  };
}

/**
 * A person list with total number specified.
 */
export interface AppsPeopleOzExternalMergedpeopleapiPersonListWithTotalNumber {
  people?: AppsPeopleOzExternalMergedpeopleapiPerson[];
  /**
   * The total number of people, which is aways no less than the size of the
   * above list.
   */
  totalNumber?: number;
}

function serializeAppsPeopleOzExternalMergedpeopleapiPersonListWithTotalNumber(data: any): AppsPeopleOzExternalMergedpeopleapiPersonListWithTotalNumber {
  return {
    ...data,
    people: data["people"] !== undefined ? data["people"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPersonListWithTotalNumber(data: any): AppsPeopleOzExternalMergedpeopleapiPersonListWithTotalNumber {
  return {
    ...data,
    people: data["people"] !== undefined ? data["people"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
  };
}

/**
 * Metadata for the entire Person resource.
 */
export interface AppsPeopleOzExternalMergedpeopleapiPersonMetadata {
  /**
   * Affinities associated with the person, with respect to the requester.
   */
  affinity?: AppsPeopleOzExternalMergedpeopleapiAffinity[];
  /**
   * Populated when the data for the MergedPerson comes from a 3rd party
   * provider or data source. Clients must display these attributions to the
   * user if they are present. NOTE: This field is only relevant when requesting
   * the following containers: - PLACE (data read from Maps)
   */
  attribution?: string[];
  /**
   * The best name to use for this person for user-facing display. See
   * go/people-api-howto:names for details about how this field is computed. In
   * many cases this will simply be Person.name[0]. However, Person.name returns
   * only explicit Name fields, but other fields maybe usable as a name (for
   * example: nicknames, file_as, ...). `best_display_name` will be calculated
   * from all fields in storage which are usable as a name, even fields which
   * are not explicitly requested in the MergedPerson result. See
   * go/javagoog/apps/tacotown/socialgraph/entity/PersonNameFormatter.java
   */
  bestDisplayName?: AppsPeopleOzExternalMergedpeopleapiBestDisplayName;
  /**
   * DEPRECATED. Indicates whether the profile owner has blocked this person.
   * Please use `person.read_only_profile_info.block_type` instead.
   */
  blockType?:  | "BLOCK_TYPE_UNKNOWN" | "CIRCLE" | "LEGACY"[];
  /**
   * DEPRECATED. The circles the person belongs to.
   */
  circleId?: string[];
  /**
   * DEPRECATED. Please use `person.contact_group_memberships` instead. The
   * contact groups the person belongs to.
   */
  contactGroupId?: string[];
  /**
   * The IDs of all contacts contributing to this person.
   */
  contactId?: bigint[];
  /**
   * DEPRECATED. Customized masking of the response similar to the legacy
   * People2RequestMask People2Params request message. NOTE: This param is
   * inherently client-specific, limited to specific legacy clients, and not
   * open to new usage. NOTE: Effects may be applied to a subset of people in
   * the response.
   */
  customResponseMaskingType?:  | "UNKNOWN" | "NONE" | "MENAGERIE";
  /**
   * For sync requests (i.e., changed since the provided sync_token), indicates
   * the resource is a tombstone for a Person resource that has been entirely
   * deleted.
   */
  deleted?: boolean;
  /**
   * DEPRECATED. Please use `person.read_only_profile_info.block_type` instead.
   */
  deprecatedBlocked?: boolean;
  /**
   * DEPRECATED. This field is no longer populated or read.
   */
  deprecatedMembershipCircleId?: bigint[];
  /**
   * DEPRECATED. This field is no longer populated or read.
   */
  deprecatedMembershipContactGroupId?: bigint[];
  /**
   * Info about the aggregated device contacts. When the person contains
   * RAW_DEVICE_CONTACT containers, each DeviceContactInfo represents a single
   * aggregate device contact made up of one or more raw device contacts.
   */
  deviceContactInfo?: AppsPeopleOzExternalMergedpeopleapiDeviceContactInfo[];
  /**
   * Detailed metadata about the lookup IDs and data sources included in a
   * MergedPerson result.
   */
  identityInfo?: AppsPeopleOzExternalMergedpeopleapiIdentityInfo;
  /**
   * DEPRECATED. Indicates whether this person is blocking the profile owner.
   * Please use `person.read_only_profile_info.incoming_block_type` instead.
   */
  incomingBlockType?:  | "BLOCK_TYPE_UNKNOWN" | "CIRCLE" | "LEGACY"[];
  /**
   * DEPRECATED. Indicates whether this person is in the same domain as the
   * viewer. For proxying trust between two users based on organization
   * membership, see: - go/flex-orgs-platform - go/flex-orgs-compliance-handbook
   * (especially http://shortn/_ChwfAY36Ys)
   */
  inViewerDomain?: boolean;
  /**
   * DEPRECATED. The last update timestamps for the constituent components of
   * this person are available in `identity_info.source_ids`. The time of the
   * most recent change to this person, in !!!NANOS!!! (due to a bug). May be a
   * change to any of the underlying parts of the person (profile, contact,
   * etc.). Not guaranteed to be the timestamp of the most recent change, due to
   * limitations in the backend. This field is not fully deprecated for backend
   * container-specific storage services like ProfileService which lack
   * identity_info. The use is still discouraged in such systems and they should
   * prefer to use the `last_update_time` field of this message instead.
   */
  lastUpdateTimeMicros?: bigint;
  /**
   * The person model that is used to construct this person.
   */
  model?:  | "PERSON_MODEL_UNKNOWN" | "PROFILE_CENTRIC" | "CONTACT_CENTRIC";
  /**
   * DEPRECATED.
   */
  objectType?:  | "OBJECT_TYPE_UNKNOWN" | "PERSON" | "PAGE";
  /**
   * DEPRECATED. Please use `person.read_only_profile_info.owner_id` instead.
   */
  ownerId?: string;
  /**
   * DEPRECATED. See `person.read_only_profile_info.owner_user_type` instead.
   */
  ownerUserType?:  | "OWNER_USER_TYPE_UNKNOWN" | "GOOGLE_USER" | "GPLUS_USER" | "GPLUS_DISABLED_BY_ADMIN" | "GOOGLE_APPS_USER" | "GOOGLE_APPS_SELF_MANAGED_USER" | "GOOGLE_FAMILY_USER" | "GOOGLE_FAMILY_CHILD_USER" | "GOOGLE_APPS_ADMIN_DISABLED" | "GOOGLE_ONE_USER" | "GOOGLE_FAMILY_CONVERTED_CHILD_USER"[];
  /**
   * DEPRECATED. Please use `Person.plus_page_info` instead.
   */
  plusPageType?:  | "PLUS_PAGE_TYPE_UNKNOWN" | "LOCAL" | "COMPANY" | "BRAND" | "CELEBRITY" | "CAUSE" | "ENTERTAINMENT" | "OTHER" | "OBSOLETE_PRIVATE";
  /**
   * DEPRECATED. This field is no longer populated or read.
   */
  previousPersonId?: string[];
  /**
   * DEPRECATED. Stats/counters pertaining to followers and incoming edges.
   * Please use `person.read_only_profile_info.profile_owner_stats` instead.
   */
  profileOwnerStats?: AppsPeopleOzExternalMergedpeopleapiProfileOwnerStats;
  /**
   * Contact people-directory-dev-team@ if you want to use this field.
   */
  scoringInfo?: AppsPeopleOzExternalMergedpeopleapiPersonMetadataScoringInfo;
  /**
   * DEPRECATED. This field is no longer populated or read.
   */
  userVisibleStats?: AppsPeopleOzExternalMergedpeopleapiUserVisibleStats;
}

function serializeAppsPeopleOzExternalMergedpeopleapiPersonMetadata(data: any): AppsPeopleOzExternalMergedpeopleapiPersonMetadata {
  return {
    ...data,
    contactId: data["contactId"] !== undefined ? data["contactId"].map((item: any) => (String(item))) : undefined,
    deprecatedMembershipCircleId: data["deprecatedMembershipCircleId"] !== undefined ? data["deprecatedMembershipCircleId"].map((item: any) => (String(item))) : undefined,
    deprecatedMembershipContactGroupId: data["deprecatedMembershipContactGroupId"] !== undefined ? data["deprecatedMembershipContactGroupId"].map((item: any) => (String(item))) : undefined,
    deviceContactInfo: data["deviceContactInfo"] !== undefined ? data["deviceContactInfo"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiDeviceContactInfo(item))) : undefined,
    identityInfo: data["identityInfo"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiIdentityInfo(data["identityInfo"]) : undefined,
    lastUpdateTimeMicros: data["lastUpdateTimeMicros"] !== undefined ? String(data["lastUpdateTimeMicros"]) : undefined,
    profileOwnerStats: data["profileOwnerStats"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiProfileOwnerStats(data["profileOwnerStats"]) : undefined,
    userVisibleStats: data["userVisibleStats"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiUserVisibleStats(data["userVisibleStats"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPersonMetadata(data: any): AppsPeopleOzExternalMergedpeopleapiPersonMetadata {
  return {
    ...data,
    contactId: data["contactId"] !== undefined ? data["contactId"].map((item: any) => (BigInt(item))) : undefined,
    deprecatedMembershipCircleId: data["deprecatedMembershipCircleId"] !== undefined ? data["deprecatedMembershipCircleId"].map((item: any) => (BigInt(item))) : undefined,
    deprecatedMembershipContactGroupId: data["deprecatedMembershipContactGroupId"] !== undefined ? data["deprecatedMembershipContactGroupId"].map((item: any) => (BigInt(item))) : undefined,
    deviceContactInfo: data["deviceContactInfo"] !== undefined ? data["deviceContactInfo"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiDeviceContactInfo(item))) : undefined,
    identityInfo: data["identityInfo"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiIdentityInfo(data["identityInfo"]) : undefined,
    lastUpdateTimeMicros: data["lastUpdateTimeMicros"] !== undefined ? BigInt(data["lastUpdateTimeMicros"]) : undefined,
    profileOwnerStats: data["profileOwnerStats"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiProfileOwnerStats(data["profileOwnerStats"]) : undefined,
    userVisibleStats: data["userVisibleStats"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiUserVisibleStats(data["userVisibleStats"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiPersonMetadataScoringInfo {
  /**
   * Only populated on a SearchDirectoryPeople call, when results are scored.
   * Contact people-directory-dev-team@ if you want to use this field.
   */
  rawMatchQualityScore?: number;
  /**
   * Only populated on a SearchDirectoryPeople call that sends a request with
   * StFieldSpecExpressions. - Used for linking indexed terms with query terms
   * for go/better-name-matching - Name should be alphanumeric or underscores -
   * Value should be an st expression following the syntax at go/stsyntax
   * Contact people-directory-dev-team@ if you want to use this field.
   */
  stExpressionResults?: AppsPeopleOzExternalMergedpeopleapiPersonMetadataScoringInfoStExpressionResult[];
}

export interface AppsPeopleOzExternalMergedpeopleapiPersonMetadataScoringInfoStExpressionResult {
  name?: string;
  value?: string;
}

export interface AppsPeopleOzExternalMergedpeopleapiPhone {
  /**
   * Canonicalized form that follows ITU-T E.164 international public
   * telecommunication numbering plan.
   */
  canonicalizedForm?: string;
  /**
   * Emergency information. See go/emergency-trusted-contacts-papi.
   */
  emergencyInfo?: AppsPeopleOzExternalMergedpeopleapiFieldEmergencyInfo;
  /**
   * Read-only. Field requested by specifying `HANGOUTS_PHONE_DATA` in
   * `extension_set.extension_names`.
   */
  extendedData?: AppsPeopleOzExternalMergedpeopleapiPhoneExtendedData;
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * The type of the phone number. The type can be free form or one of these
   * predefined values: * `home` * `work` * `mobile` * `homeFax` * `workFax` *
   * `otherFax` * `pager` * `workMobile` * `workPager` * `main` * `googleVoice`
   * * `other`
   */
  type?: string;
  uri?: string;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiPhone(data: any): AppsPeopleOzExternalMergedpeopleapiPhone {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPhone(data: any): AppsPeopleOzExternalMergedpeopleapiPhone {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiPhoneExtendedData {
  /**
   * For use with Hangouts extension.
   */
  structuredPhone?: AppsPeopleOzExternalMergedpeopleapiStructuredPhone;
}

export interface AppsPeopleOzExternalMergedpeopleapiPhoto {
  /**
   * Read-only. Use UpdatePersonPhoto to change photo decorations. If this
   * photo is decorated, this field contains information about its decorations.
   * For now, this will contain at most one entry.
   */
  decoration?: SocialGraphApiProtoDecorationOverlay[];
  /**
   * URL of an emoji avatar as an image. See go/emoji-cdn. PeopleAPI will
   * return the SVG format so that it can be scaled client side and so that the
   * images will not be animated. All clients that use this field must also have
   * fall-back handling for using the `Photo.url` field if this is empty. When
   * we have FIFE-compatible emoji-image URLs we will drop this field and return
   * the Photo.url instead. Clients that have their own go/emoji-rendering
   * integration may prefer to render the emoji-avatar from `Photo.glyph` field
   * using their rendering system so that the emoji version/style match the rest
   * of the application. For further background, see
   * go/chatroom-avatar-as-roster-metadata. This field will only be populated if
   * all of: - The PersonFieldMetadata `container_type` for the Photo is
   * NAMED_CHAT_ROOM - The chat room has an emoji type avatar image set
   */
  emojiAvatarUrl?: string;
  /**
   * Unicode emoji representation of the chat room emoji avatar. This can be
   * used by clients that use go/emoji-rendering directly so that they can
   * present this with the same version/style as the rest of their application.
   * This value may also be useful to clients as alt-text for the image. This
   * field will only be populated if all of: - The PersonFieldMetadata
   * `container_type` for the Photo is NAMED_CHAT_ROOM - The chat room has an
   * emoji type avatar image set
   */
  glyph?: string;
  /**
   * A set of HTML data provider attributions that must be shown with the
   * result. Supported for PLACES photos only. See:
   * go/understanding-places-api-attribution-requirements
   */
  htmlAttribution?: string[];
  /**
   * True when the photo is synthetic or generated (i.e. a monogram or default
   * photo), false when the person has a custom photo.
   */
  isDefault?: boolean;
  /**
   * Indicates if the photo is a monogram avatar. Combined with is_default, the
   * type of photo can be determined by: is_default=true, is_monogram=true:
   * Default monogram avatar. is_default=true, is_monogram=false: Default
   * silhouette avatar. is_default=false: Custom photo. is_monogram is
   * irrelevant in this case.
   */
  isMonogram?: boolean;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * When is_monogram=true, this is the background color of the monogram photo
   * as a hex RGB formatted string "RRGGBB".
   */
  monogramBackground?: string;
  /**
   * Read-only. A reference to the original, undecorated profile photo in
   * storage. This field is not stored. It is populated by a live read to
   * /SocialGraphImageService.GetActiveProfilePhoto. This field is only returned
   * when "person.photo.original_photo" is specified in the request mask.
   */
  originalPhoto?: SocialGraphApiProtoImageReference;
  /**
   * For writes only. Indicates photo content for person photo-field update.
   * Currently only used for profile-photo updates (not contact photos yet).
   */
  photoId?: AppsPeopleOzExternalMergedpeopleapiPhotoPhotoStorageId;
  /**
   * Most clients don't need to worry about this field and should just use the
   * `url` to fetch the photo. See go/phototoken-migration-plan for some more
   * context about this field. If you think you want to use this please talk
   * with people-api-eng@ first.
   */
  photoToken?: string;
  /**
   * See go/people-api-concepts/photos for info on the different
   * representations of URLs.
   */
  url?: string;
  /**
   * A URL for a UI to view the photo in its original context. For example, for
   * a place photo, this is the url of a Google Maps page displaying the photo.
   * Supported for place photos only.
   */
  viewerUrl?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiPhoto(data: any): AppsPeopleOzExternalMergedpeopleapiPhoto {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    originalPhoto: data["originalPhoto"] !== undefined ? serializeSocialGraphApiProtoImageReference(data["originalPhoto"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPhoto(data: any): AppsPeopleOzExternalMergedpeopleapiPhoto {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    originalPhoto: data["originalPhoto"] !== undefined ? deserializeSocialGraphApiProtoImageReference(data["originalPhoto"]) : undefined,
  };
}

/**
 * Info necessary for looking up a photo in storage.
 */
export interface AppsPeopleOzExternalMergedpeopleapiPhotoPhotoStorageId {
  /**
   * For writes only, pass the media key that represents the image in photos
   * backend. Note, this is not populated on reads.
   */
  mediaKey?: string;
}

/**
 * Metadata specific to places.
 */
export interface AppsPeopleOzExternalMergedpeopleapiPlaceDetails {
  /**
   * A URL hosted by Google providing more information about this place This is
   * the URL returned by Places API in the Place.Url.google field
   */
  googleUrl?: string;
  latLng?: AppsPeopleOzExternalMergedpeopleapiLatLng;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  openingHours?: AppsPeopleOzExternalMergedpeopleapiOpeningHours;
  /**
   * The name of the primary type. Examples of primary type are: "art_school",
   * "clothing_wholesaler", etc. All primary types can be found at
   * http://shortn/_veqh6UwWdc
   */
  primaryTypeName?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiPlaceDetails(data: any): AppsPeopleOzExternalMergedpeopleapiPlaceDetails {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPlaceDetails(data: any): AppsPeopleOzExternalMergedpeopleapiPlaceDetails {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Extension data for use in Play Games Product Profile. See
 * go/jam-games-profile.
 */
export interface AppsPeopleOzExternalMergedpeopleapiPlayGamesExtendedData {
  /**
   * User's top achievements that are sorted for example by rarity.
   */
  achievements?: AppsPeopleOzExternalMergedpeopleapiPlayGamesExtendedDataAchievement[];
  /**
   * The avatar image to display for the user.
   */
  avatarImageUrl?: string;
  /**
   * Failure type if there is an error when fetching product profile data.
   */
  failure?: AppsPeopleOzExternalMergedpeopleapiProductProfileFailure;
  /**
   * The gamer tag set by the user. Not set if the user hasn't set a gamer tag
   * yet.
   */
  gamerTag?: string;
  /**
   * User's level.
   */
  playerLevel?: number;
  /**
   * Specifies the visibility of the player's profile.
   */
  profileVisibility?:  | "UNKNOWN_CLIENT_PLAYER_PROFILE_VISIBILITY" | "PRIVATE_VISIBILITY" | "PUBLIC_VISIBILITY" | "FRIENDS_VISIBILITY";
  /**
   * Total number of friends.
   */
  totalFriendsCount?: bigint;
  /**
   * How many achievements this player has unlocked.
   */
  totalUnlockedAchievements?: bigint;
}

function serializeAppsPeopleOzExternalMergedpeopleapiPlayGamesExtendedData(data: any): AppsPeopleOzExternalMergedpeopleapiPlayGamesExtendedData {
  return {
    ...data,
    totalFriendsCount: data["totalFriendsCount"] !== undefined ? String(data["totalFriendsCount"]) : undefined,
    totalUnlockedAchievements: data["totalUnlockedAchievements"] !== undefined ? String(data["totalUnlockedAchievements"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPlayGamesExtendedData(data: any): AppsPeopleOzExternalMergedpeopleapiPlayGamesExtendedData {
  return {
    ...data,
    totalFriendsCount: data["totalFriendsCount"] !== undefined ? BigInt(data["totalFriendsCount"]) : undefined,
    totalUnlockedAchievements: data["totalUnlockedAchievements"] !== undefined ? BigInt(data["totalUnlockedAchievements"]) : undefined,
  };
}

/**
 * Details of an achievement that the user has unlocked.
 */
export interface AppsPeopleOzExternalMergedpeopleapiPlayGamesExtendedDataAchievement {
  /**
   * The name of the achievement.
   */
  achievementName?: string;
  /**
   * The achievement icon url shown to the user if it is unlocked.
   */
  achievementUnlockedIconUrl?: string;
  /**
   * Rarity of unlocking this achievement (3% of players unlocked would be 3)
   */
  rarityPercentage?: number;
}

/**
 * Information about a plus page and the entity it represents.
 */
export interface AppsPeopleOzExternalMergedpeopleapiPlusPageInfo {
  /**
   * Int64 ID of packaging-service entry; if set, the plus page is associated
   * with a third-party application.
   */
  applicationId?: bigint;
  entityType?:  | "ENTITY_TYPE_UNSPECIFIED" | "LOCAL" | "COMPANY" | "BRAND" | "CELEBRITY" | "CAUSE" | "ENTERTAINMENT" | "OTHER" | "OBSOLETE_PRIVATE";
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiPlusPageInfo(data: any): AppsPeopleOzExternalMergedpeopleapiPlusPageInfo {
  return {
    ...data,
    applicationId: data["applicationId"] !== undefined ? String(data["applicationId"]) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPlusPageInfo(data: any): AppsPeopleOzExternalMergedpeopleapiPlusPageInfo {
  return {
    ...data,
    applicationId: data["applicationId"] !== undefined ? BigInt(data["applicationId"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Map marker location for an address.
 */
export interface AppsPeopleOzExternalMergedpeopleapiPointSpec {
  bounds?: GeostoreRectProto;
  point?: GeostorePointProto;
  pointSource?:  | "UNKNOWN_POINT_SOURCE" | "POINT_SOURCE_UNSPECIFIED" | "USER_PROVIDED" | "SYSTEM_PROVIDED" | "USER_CONFIRMED";
}

/**
 * Custom field that represents POSIX account information. Description of the
 * field family: go/fbs-posix. If account has non-empty Username or Uid we will
 * enforce global uniqueness of (AccountNamespace, CustomerKey, SystemId, Uid)
 * and (AccountNamespace, CustomerKey, SystemId, Username) tuples to ensure
 * there are no duplicates.
 */
export interface AppsPeopleOzExternalMergedpeopleapiPosixAccount {
  /**
   * The user visible value is used to distinguish identical posix account
   * fields with different customer key values.
   */
  accountId?: string;
  /**
   * Value indicates the uniqueness namespace that applies to the POSIX
   * information. The value is included in all POSIX account uniqueness indices.
   * The indexing prevents two accounts within the same customer from having the
   * same username. Namespacing allows Windows and Linux users to share the same
   * username.
   */
  accountNamespace?:  | "LINUX_GSUITE" | "LINUX_CONSUMER" | "WINDOWS_GSUITE" | "WINDOWS_CONSUMER";
  /**
   * Value indicates whether the POSIX information is associated with a
   * non-human entity and the validation logic to apply during PosixAccount
   * mutation.
   */
  accountType?:  | "LINUX_USER_ACCOUNT" | "LINUX_SERVICE_ACCOUNT" | "LINUX_EXTERNAL_USER" | "WINDOWS_USER_ACCOUNT" | "WINDOWS_SERVICE_ACCOUNT" | "WINDOWS_EXTERNAL_USER";
  /**
   * The customer associated with the POSIX identity. If the user is already
   * associated with a G Suite Customer, this field has the same value as
   * http://google3/ccc/hosted/policies/settings/dthree_customer_info.proto
   */
  customerKey?: bigint;
  /**
   * The value is automatically set to a SHA-256 fingerprint of the POSIX
   * account. A fingerprint should uniquely identify a POSIX account entry.
   */
  fingerprint?: string;
  /**
   * The GECOS (user information) entry for this account.
   */
  gecos?: string;
  /**
   * The default group ID.
   */
  gid?: bigint;
  /**
   * The path to the home directory for this account.
   */
  homeDirectory?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * Value indicates whether to use Linux or Windows specific validation logic
   * during PosixAccount mutation.
   */
  operatingSystemType?:  | "OPERATING_SYSTEM_TYPE_UNSPECIFIED" | "LINUX" | "WINDOWS";
  /**
   * The path to the login shell for this account.
   */
  shell?: string;
  /**
   * System identifier for which account Username or Uid apply to. If not
   * specified on mutate by a caller it will default to empty value if either
   * Username or Uid are being set. SystemId does require to have a value (even
   * an empty one) because it is included into null-filtered Spanner index used
   * to enforce uniqueness on Username and Uid fields.
   */
  systemId?: string;
  /**
   * The user ID.
   */
  uid?: bigint;
  /**
   * The username of the account.
   */
  username?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiPosixAccount(data: any): AppsPeopleOzExternalMergedpeopleapiPosixAccount {
  return {
    ...data,
    customerKey: data["customerKey"] !== undefined ? String(data["customerKey"]) : undefined,
    gid: data["gid"] !== undefined ? String(data["gid"]) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    uid: data["uid"] !== undefined ? String(data["uid"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPosixAccount(data: any): AppsPeopleOzExternalMergedpeopleapiPosixAccount {
  return {
    ...data,
    customerKey: data["customerKey"] !== undefined ? BigInt(data["customerKey"]) : undefined,
    gid: data["gid"] !== undefined ? BigInt(data["gid"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    uid: data["uid"] !== undefined ? BigInt(data["uid"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiProductMetadata {
  productSource?:  | "PRODUCT_SOURCE_UNKNOWN" | "PRODUCT_SOURCE_DEFAULT" | "PRODUCT_SOURCE_ASSISTANT" | "PRODUCT_SOURCE_JANATA" | "PRODUCT_SOURCE_SPEED_DIAL";
}

/**
 * Product profiles failure type: the status of the rpc to fetch the product
 * profile.
 */
export interface AppsPeopleOzExternalMergedpeopleapiProductProfileFailure {
  failureType?:  | "PRODUCT_PROFILE_FAILURE_TYPE_UNKNOWN" | "RPC_FAILURE";
}

/**
 * Stats pertaining to incoming edges and views, visible to the requester (with
 * acls applied). Related to, but not equal to,
 * com.google.focus.proto.Storage.UserVisibleStats.
 */
export interface AppsPeopleOzExternalMergedpeopleapiProfileOwnerStats {
  /**
   * Replacement for deprecated follower_count. Comes from the EdgeSummary.
   */
  incomingAnyCircleCount?: bigint;
  /**
   * Deprecated. This field is no longer populated by the server.
   */
  viewCount?: bigint;
}

function serializeAppsPeopleOzExternalMergedpeopleapiProfileOwnerStats(data: any): AppsPeopleOzExternalMergedpeopleapiProfileOwnerStats {
  return {
    ...data,
    incomingAnyCircleCount: data["incomingAnyCircleCount"] !== undefined ? String(data["incomingAnyCircleCount"]) : undefined,
    viewCount: data["viewCount"] !== undefined ? String(data["viewCount"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiProfileOwnerStats(data: any): AppsPeopleOzExternalMergedpeopleapiProfileOwnerStats {
  return {
    ...data,
    incomingAnyCircleCount: data["incomingAnyCircleCount"] !== undefined ? BigInt(data["incomingAnyCircleCount"]) : undefined,
    viewCount: data["viewCount"] !== undefined ? BigInt(data["viewCount"]) : undefined,
  };
}

/**
 * This is a Google+-only field (and thus does not exist for consumer users).
 * See go/fbs-g+-deprecation.
 */
export interface AppsPeopleOzExternalMergedpeopleapiProfileUrl {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  url?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiProfileUrl(data: any): AppsPeopleOzExternalMergedpeopleapiProfileUrl {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiProfileUrl(data: any): AppsPeopleOzExternalMergedpeopleapiProfileUrl {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Message to represent a user's set of preferred pronouns, see
 * go/pronouns-backend.
 */
export interface AppsPeopleOzExternalMergedpeopleapiPronoun {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  pronounData?: SocialGraphApiProtoPronounData;
}

function serializeAppsPeopleOzExternalMergedpeopleapiPronoun(data: any): AppsPeopleOzExternalMergedpeopleapiPronoun {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiPronoun(data: any): AppsPeopleOzExternalMergedpeopleapiPronoun {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiRawDeviceContactAnalyticalInfo {
  /**
   * The data set within the account that this raw contact belongs to.
   */
  dataSet?: string;
  /**
   * The CP2 dirty field which indicates the sync state of the raw contact:
   * https://developer.android.com/reference/android/provider/ContactsContract.SyncColumns#DIRTY
   * True if the row is changed but not synced
   */
  dirty?: boolean;
  /**
   * Whether the source ID exists for non-Google contacts. Won't set for Google
   * contacts.
   */
  sourceIdExist?: boolean;
  /**
   * The Sync Info of a raw contact.
   */
  syncInfo?: SocialGraphApiProtoSyncInfo;
}

/**
 * Raw device contact information.
 */
export interface AppsPeopleOzExternalMergedpeopleapiRawDeviceContactInfo {
  /**
   * Account name of raw contact, e.g. "google@gmail.com".
   */
  accountName?: string;
  /**
   * Account type of raw contact, e.g. "com.google" or "com.linkedin.android".
   */
  accountType?: string;
  /**
   * The detailed app-specific endpoint data available for the given
   * RawDeviceContactInfo instance. This proto should be used to obtain the list
   * of actions and mimetypes supported by the third-party app. Design:
   * go/3p-contact-upload
   */
  appContactData?: SocialGraphApiAppContactData[];
  /**
   * The app-specific endpoint data needed for app action fulfillment. Usage of
   * this field should be avoided on the server-side, and should use the more
   * detailed |full_app_info| field.
   */
  appInfo?: AppsPeopleOzExternalMergedpeopleapiAppUniqueInfo;
  /**
   * If true, this raw contact can be used on other devices than the one it
   * originated from. Assigned by the server.
   */
  crossDeviceAllowed?: boolean;
  /**
   * Extra metadata for this raw contact.
   */
  deviceContactMetadata?: AppsPeopleOzExternalMergedpeopleapiDeviceContactExtraMetadata;
  /**
   * The focus contact id for Google contacts.
   */
  googleContactId?: bigint;
  /**
   * The base64 serialized
   * social.graph.peopleapi.proto.internal.RawDeviceContactId. This id should be
   * used to correlate to field.metadata.encoded_container_id when the
   * field.metadata.container_type is RAW_DEVICE_CONTACT The id also correlates
   * to person.metadata.identity_info.source_id.id.
   */
  id?: string;
  /**
   * The type of photo from the device (if any).
   */
  photoType?:  | "PHOTO_TYPE_UNKNOWN" | "NO_PHOTO" | "THUMBNAIL" | "FULL_SIZE_PHOTO";
  /**
   * The id of the raw contact on the device.
   */
  rawContactId?: bigint;
  /**
   * Only to be used by Romanesco team specifically for analytics.
   */
  rawDeviceContactAnalyticalInfo?: AppsPeopleOzExternalMergedpeopleapiRawDeviceContactAnalyticalInfo;
}

function serializeAppsPeopleOzExternalMergedpeopleapiRawDeviceContactInfo(data: any): AppsPeopleOzExternalMergedpeopleapiRawDeviceContactInfo {
  return {
    ...data,
    deviceContactMetadata: data["deviceContactMetadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiDeviceContactExtraMetadata(data["deviceContactMetadata"]) : undefined,
    googleContactId: data["googleContactId"] !== undefined ? String(data["googleContactId"]) : undefined,
    rawContactId: data["rawContactId"] !== undefined ? String(data["rawContactId"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiRawDeviceContactInfo(data: any): AppsPeopleOzExternalMergedpeopleapiRawDeviceContactInfo {
  return {
    ...data,
    deviceContactMetadata: data["deviceContactMetadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiDeviceContactExtraMetadata(data["deviceContactMetadata"]) : undefined,
    googleContactId: data["googleContactId"] !== undefined ? BigInt(data["googleContactId"]) : undefined,
    rawContactId: data["rawContactId"] !== undefined ? BigInt(data["rawContactId"]) : undefined,
  };
}

/**
 * Metadata information about a profile. This message replaces legacy
 * profile-specific singleton fields from the PersonMetadata proto (singleton
 * top level Person fields are not compatible with non-profile-centric person
 * results, which may include multiple profile containers).
 */
export interface AppsPeopleOzExternalMergedpeopleapiReadOnlyProfileInfo {
  /**
   * The account email linked to the profile, if any exists and is visible to
   * the requester.
   */
  accountEmail?: AppsPeopleOzExternalMergedpeopleapiAccountEmail;
  /**
   * Indicates whether the profile owner has blocked this person.
   */
  blockType?:  | "BLOCK_TYPE_UNKNOWN" | "CIRCLE" | "LEGACY"[];
  /**
   * CustomerInfo for dasher user. The reader has to explicitly request this in
   * the field_mask as 'read_only_profile_info.customer_info'
   */
  customerInfo?: AppsPeopleOzExternalMergedpeopleapiCustomerInfo;
  /**
   * DEPRECATED. Use the `ReadOnlyProfileInfo.customer_info` field instead
   * (b/138120418). Only populated if in_viewer_domain is true.
   */
  domainInfo?: AppsPeopleOzExternalMergedpeopleapiReadOnlyProfileInfoDomainInfo;
  /**
   * Indicates whether this person is blocking the profile owner.
   */
  incomingBlockType?:  | "BLOCK_TYPE_UNKNOWN" | "CIRCLE" | "LEGACY"[];
  /**
   * DEPRECATED. Proxying trust between users in a domain should use
   * go/flex-orgs-platform. For more info see:
   * http://doc/18i0-C7vWcz2UuXYBsmulnriVCK3_EuMPpRlPa2OmMHw#heading=h.dobotdwx25kg
   * Indicates whether the profile owner is in the same domain as the viewer.
   */
  inViewerDomain?: boolean;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * DEPRECATED.
   */
  objectType?:  | "OBJECT_TYPE_UNKNOWN" | "PERSON" | "PAGE";
  /**
   * The Focus-obfuscated Gaia ID of the profile owner (go/obfuscated-ids).
   */
  ownerId?: string;
  ownerUserType?:  | "OWNER_USER_TYPE_UNKNOWN" | "GOOGLE_USER" | "GPLUS_USER" | "GPLUS_DISABLED_BY_ADMIN" | "GOOGLE_APPS_USER" | "GOOGLE_APPS_SELF_MANAGED_USER" | "GOOGLE_FAMILY_USER" | "GOOGLE_FAMILY_CHILD_USER" | "GOOGLE_APPS_ADMIN_DISABLED" | "GOOGLE_ONE_USER" | "GOOGLE_FAMILY_CONVERTED_CHILD_USER"[];
  /**
   * DEPRECATED. Please use `person.plus_page_info` instead.
   */
  plusPageType?:  | "PLUS_PAGE_TYPE_UNKNOWN" | "LOCAL" | "COMPANY" | "BRAND" | "CELEBRITY" | "CAUSE" | "ENTERTAINMENT" | "OTHER" | "OBSOLETE_PRIVATE";
  /**
   * Stats/counters pertaining to followers and incoming edges.
   */
  profileOwnerStats?: AppsPeopleOzExternalMergedpeopleapiProfileOwnerStats;
}

function serializeAppsPeopleOzExternalMergedpeopleapiReadOnlyProfileInfo(data: any): AppsPeopleOzExternalMergedpeopleapiReadOnlyProfileInfo {
  return {
    ...data,
    customerInfo: data["customerInfo"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiCustomerInfo(data["customerInfo"]) : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    profileOwnerStats: data["profileOwnerStats"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiProfileOwnerStats(data["profileOwnerStats"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiReadOnlyProfileInfo(data: any): AppsPeopleOzExternalMergedpeopleapiReadOnlyProfileInfo {
  return {
    ...data,
    customerInfo: data["customerInfo"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiCustomerInfo(data["customerInfo"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    profileOwnerStats: data["profileOwnerStats"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiProfileOwnerStats(data["profileOwnerStats"]) : undefined,
  };
}

/**
 * DEPRECATED.
 */
export interface AppsPeopleOzExternalMergedpeopleapiReadOnlyProfileInfoDomainInfo {
  /**
   * DEPRECATED. Organization badge for the domain this person is a member of.
   * The badge is the primary hosted domain.
   */
  domainBadge?: string[];
  /**
   * DEPRECATED. Hosted domain this person is a member of. Formerly only
   * available via PersonExtendedData.
   */
  domainName?: string[];
}

/**
 * Relation stores the related person between the contact or profile and a
 * third person. See go/relation-vs-relationship for relation vs relationship
 * explanation. This field currently includes RelationshipToMe data in fields
 * value and canonical_value for ContainerType CONTACT_ANNOTATION. This will be
 * moved to RelationshipToMe in b/221081499.
 */
export interface AppsPeopleOzExternalMergedpeopleapiRelation {
  /**
   * Canonicalized `value` of the relation from this person to the user. This
   * is currently used for data from contact annotations. Possible canonical
   * values are based from
   * http://google3/googledata/quality/aliases/relationship_en.config.
   */
  canonicalValue?: string;
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * The person whose email matches the Relation.value field, if it is a valid
   * email address. This field is read-only and ignored on update.
   */
  relationDetails?: AppsPeopleOzExternalMergedpeopleapiRelationRelationDetails;
  /**
   * The relation type. The type can be free form or one of these predefined
   * values: * `spouse` * `child` * `mother` * `father` * `parent` * `brother` *
   * `sister` * `friend` * `relative` * `domesticPartner` * `manager` *
   * `assistant` * `referredBy` * `partner`
   */
  type?: string;
  /**
   * The person this relation applies to. Custom value provided by the user.
   */
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiRelation(data: any): AppsPeopleOzExternalMergedpeopleapiRelation {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiRelation(data: any): AppsPeopleOzExternalMergedpeopleapiRelation {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiRelationRelationDetails {
  /**
   * Equivalent to Name.display_name for the person_id profile.
   */
  displayName?: string;
  /**
   * Equivalent to Organization.title for the primary organization of the
   * person_id profile.
   */
  jobTitle?: string;
  personId?: string;
  /**
   * Equivalent to Photo.url for the person_id profile.
   */
  photoUrl?: string;
}

/**
 * Deprecated in b/122464133. No data returned for this field.
 */
export interface AppsPeopleOzExternalMergedpeopleapiRelationshipInterest {
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * These fields may give away the sexual orientation of the user.
   */
  type?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiRelationshipInterest(data: any): AppsPeopleOzExternalMergedpeopleapiRelationshipInterest {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiRelationshipInterest(data: any): AppsPeopleOzExternalMergedpeopleapiRelationshipInterest {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Deprecated in b/122464133. No data returned for this field.
 */
export interface AppsPeopleOzExternalMergedpeopleapiRelationshipStatus {
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  type?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiRelationshipStatus(data: any): AppsPeopleOzExternalMergedpeopleapiRelationshipStatus {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiRelationshipStatus(data: any): AppsPeopleOzExternalMergedpeopleapiRelationshipStatus {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * User preference for shared endorsements. See go/se-devguide and
 * go/sharedendorsements for details, including guidance on which contexts are
 * which.
 */
export interface AppsPeopleOzExternalMergedpeopleapiRightOfPublicityState {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  state?:  | "STATE_UNSPECIFIED" | "NOT_OK_TO_DISPLAY" | "OK_TO_DISPLAY" | "OK_TO_DISPLAY_IN_NON_ADS_COMMERCIAL_CONTEXT";
}

function serializeAppsPeopleOzExternalMergedpeopleapiRightOfPublicityState(data: any): AppsPeopleOzExternalMergedpeopleapiRightOfPublicityState {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiRightOfPublicityState(data: any): AppsPeopleOzExternalMergedpeopleapiRightOfPublicityState {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * Information specific to rosters like Google Groups and Chatrooms.
 */
export interface AppsPeopleOzExternalMergedpeopleapiRosterDetails {
  /**
   * Abridged / sample subset of member details of the roster. NOTE: This field
   * is only returned if the request's field mask includes
   * "person.roster_details.abridged_roster_memberships".
   * http://cs/symbol:google.apps.cloudidentity.groups.internal.GroupSummary.abridged_memberships
   */
  abridgedRosterMemberships?: AppsPeopleOzExternalMergedpeopleapiRosterMember[];
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * Indicates the number of members and sub-rosters of the roster. Corresponds
   * to
   * http://cs/symbol:google.apps.cloudidentity.groups.internal.Group.direct_member_count_per_type
   */
  rosterMemberCount?: AppsPeopleOzExternalMergedpeopleapiRosterMemberCount;
}

function serializeAppsPeopleOzExternalMergedpeopleapiRosterDetails(data: any): AppsPeopleOzExternalMergedpeopleapiRosterDetails {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    rosterMemberCount: data["rosterMemberCount"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiRosterMemberCount(data["rosterMemberCount"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiRosterDetails(data: any): AppsPeopleOzExternalMergedpeopleapiRosterDetails {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    rosterMemberCount: data["rosterMemberCount"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiRosterMemberCount(data["rosterMemberCount"]) : undefined,
  };
}

/**
 * Represents details of a member of a roster. Used in RosterDetails.
 * Corresponds to
 * http://cs/symbol:google.apps.cloudidentity.groups.internal.Membership
 */
export interface AppsPeopleOzExternalMergedpeopleapiRosterMember {
  /**
   * Type of the member.
   */
  memberType?:  | "ROSTER_MEMBER_TYPE_UNSPECIFIED" | "PERSON" | "ROSTER";
  /**
   * Focus-Obfuscated Gaia Id of the member.
   */
  personId?: string;
}

/**
 * Represents the summary of member counts of a roster. Used in RosterDetails.
 * Corresponds to
 * http://cs/symbol:google.apps.cloudidentity.groups.internal.Group.DirectMemberCountPerType
 */
export interface AppsPeopleOzExternalMergedpeopleapiRosterMemberCount {
  /**
   * Indicates the number of direct sub-rosters of the roster. This comes from
   * http://cs/symbol:google.apps.cloudidentity.groups.internal.Group.DirectMemberCountPerType.group_count
   */
  directGroupCount?: bigint;
  /**
   * Indicates the number of direct, non-roster members of the roster. This
   * comes from
   * http://cs/symbol:google.apps.cloudidentity.groups.internal.Group.DirectMemberCountPerType.user_count
   */
  directUserCount?: bigint;
}

function serializeAppsPeopleOzExternalMergedpeopleapiRosterMemberCount(data: any): AppsPeopleOzExternalMergedpeopleapiRosterMemberCount {
  return {
    ...data,
    directGroupCount: data["directGroupCount"] !== undefined ? String(data["directGroupCount"]) : undefined,
    directUserCount: data["directUserCount"] !== undefined ? String(data["directUserCount"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiRosterMemberCount(data: any): AppsPeopleOzExternalMergedpeopleapiRosterMemberCount {
  return {
    ...data,
    directGroupCount: data["directGroupCount"] !== undefined ? BigInt(data["directGroupCount"]) : undefined,
    directUserCount: data["directUserCount"] !== undefined ? BigInt(data["directUserCount"]) : undefined,
  };
}

/**
 * Profile for Janata and Search. go/janata-profile-in-sgbe
 */
export interface AppsPeopleOzExternalMergedpeopleapiSearchProfile {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  searchProfileData?: SocialGraphApiProtoSearchProfileData;
}

function serializeAppsPeopleOzExternalMergedpeopleapiSearchProfile(data: any): AppsPeopleOzExternalMergedpeopleapiSearchProfile {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    searchProfileData: data["searchProfileData"] !== undefined ? serializeSocialGraphApiProtoSearchProfileData(data["searchProfileData"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiSearchProfile(data: any): AppsPeopleOzExternalMergedpeopleapiSearchProfile {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
    searchProfileData: data["searchProfileData"] !== undefined ? deserializeSocialGraphApiProtoSearchProfileData(data["searchProfileData"]) : undefined,
  };
}

/**
 * As of 03/2018 is not supported for user Profile.
 */
export interface AppsPeopleOzExternalMergedpeopleapiSipAddress {
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * The type of the SIP address. The type can be free form or or one of these
   * predefined values: * `home` * `work` * `mobile` * `other`
   */
  type?: string;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiSipAddress(data: any): AppsPeopleOzExternalMergedpeopleapiSipAddress {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiSipAddress(data: any): AppsPeopleOzExternalMergedpeopleapiSipAddress {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiSkills {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiSkills(data: any): AppsPeopleOzExternalMergedpeopleapiSkills {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiSkills(data: any): AppsPeopleOzExternalMergedpeopleapiSkills {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * The social connection of this person to the viewer. NOTE: this is used by
 * go/starlight, but not actually used or returned in PeopleAPI. See b/27281119
 * for context.
 */
export interface AppsPeopleOzExternalMergedpeopleapiSocialConnection {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  type?:  | "SOCIAL_CONNECTION_UNKNOWN" | "NO_CONNECTION" | "GPLUS_SECOND_HOP" | "DIRECT_CONNECTION" | "SELF"[];
}

function serializeAppsPeopleOzExternalMergedpeopleapiSocialConnection(data: any): AppsPeopleOzExternalMergedpeopleapiSocialConnection {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiSocialConnection(data: any): AppsPeopleOzExternalMergedpeopleapiSocialConnection {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiSortKeys {
  affinity?: AppsPeopleOzExternalMergedpeopleapiAffinity[];
  /**
   * Deprecated. This field is only populated with 0.000 for legacy reasons.
   * Clients should not use this field.
   */
  interactionRank?: string;
  lastName?: string;
  lastNameRaw?: string;
  name?: string;
  /**
   * Raw name strings that were used to generate the name and last_name sort
   * keys fields above. Contacts+ need them to generate section headers for list
   * view (b/30642866).
   */
  nameRaw?: string;
}

/**
 * Id of a single source from the merged person.
 */
export interface AppsPeopleOzExternalMergedpeopleapiSourceIdentity {
  /**
   * The type of source. To be deprecated infavor of container_type
   */
  container?:  | "UNKNOWN" | "PROFILE" | "CONTACT" | "CIRCLE" | "PLACE" | "ACCOUNT" | "EXTERNAL_ACCOUNT" | "DOMAIN_PROFILE" | "DOMAIN_CONTACT" | "DEVICE_CONTACT" | "GOOGLE_GROUP" | "AFFINITY" | "RAW_DEVICE_CONTACT" | "CONTACT_ANNOTATION" | "DELEGATED_CONTACT";
  /**
   * The type of the source.
   */
  containerType?:  | "UNKNOWN_CONTAINER" | "PROFILE" | "CONTACT" | "CIRCLE" | "PLACE" | "ACCOUNT" | "EXTERNAL_ACCOUNT" | "DOMAIN_PROFILE" | "DOMAIN_CONTACT" | "DEVICE_CONTACT" | "GOOGLE_GROUP" | "NAMED_CHAT_ROOM" | "UNNAMED_CHAT_ROOM" | "AFFINITY" | "RAW_DEVICE_CONTACT" | "CONTACT_ANNOTATION" | "DELEGATED_CONTACT";
  /**
   * In sync responses, indicates whether the identity source has been deleted.
   * Not applicable to GOOGLE_GROUP.
   */
  deleted?: boolean;
  /**
   * The encoded id of the data source. This field correlates to
   * PersonFieldMetadata.encoded_container_id. The possible values of this `id`
   * field are as follows based on the value of the `container_type` field:
   * CONTACT: Hex-encoded contact id. PROFILE: DOMAIN_PROFILE: GOOGLE_GROUP:
   * NAMED_CHAT_ROOM: Focus-obfuscated Gaia ID. DOMAIN_CONTACT:
   * Synthetic-contact id representing the domain shared contact. PLACE: Encoded
   * PlaceId (go/javagoog/maps/api/places/util/PlaceIdEncoder.java)
   * RAW_DEVICE_CONTACT: Pair of device_id and raw_contact_id, encoded as base64
   * serialized social.graph.peopleapi.proto.internal.RawDeviceContactId proto.
   * CONTACT_ANNOTATION: Pair of annotation_id and event_timestamp, encoded as
   * base64 serialized social.graph.peopleapi.proto.internal.ContactAnnotationId
   * proto. -- DEPRECATED container types -- If the container is CIRCLE, then
   * the id is going to be the synthetic- contact id representing the email-only
   * circle member or gaia circle member for which the requester does not have a
   * contact for.
   */
  id?: string;
  /**
   * Last update timestamp of this source. NOTE: Only populated for CONTACT
   * container type in Java PeopleAPI. Populated for CONTACT, PROFILE,
   * DOMAIN_PROFILE in Sharpen implementation. NOTE: Not populated for
   * GOOGLE_GROUP.
   */
  lastUpdated?: Date;
  /**
   * **DEPRECATED** Please use `last_updated` field instead. Last update
   * timestamp of this source in microseconds. NOTE: Only populated for CONTACT
   * container type.
   */
  lastUpdatedMicros?: bigint;
  /**
   * NOTE: Not populated for GOOGLE_GROUP.
   */
  sourceEtag?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiSourceIdentity(data: any): AppsPeopleOzExternalMergedpeopleapiSourceIdentity {
  return {
    ...data,
    lastUpdated: data["lastUpdated"] !== undefined ? data["lastUpdated"].toISOString() : undefined,
    lastUpdatedMicros: data["lastUpdatedMicros"] !== undefined ? String(data["lastUpdatedMicros"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiSourceIdentity(data: any): AppsPeopleOzExternalMergedpeopleapiSourceIdentity {
  return {
    ...data,
    lastUpdated: data["lastUpdated"] !== undefined ? new Date(data["lastUpdated"]) : undefined,
    lastUpdatedMicros: data["lastUpdatedMicros"] !== undefined ? BigInt(data["lastUpdatedMicros"]) : undefined,
  };
}

/**
 * Custom field that represents SSH public keys associated with the user. We
 * can treat the field as a map from a string fingerprint to the SSH public key
 * information.
 */
export interface AppsPeopleOzExternalMergedpeopleapiSshPublicKey {
  expirationTime?: Date;
  /**
   * The value is automatically set to a SHA-256 fingerprint of an SSH public
   * key. A fingerprint should uniquely identify an SSH public key.
   */
  fingerprint?: string;
  key?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiSshPublicKey(data: any): AppsPeopleOzExternalMergedpeopleapiSshPublicKey {
  return {
    ...data,
    expirationTime: data["expirationTime"] !== undefined ? data["expirationTime"].toISOString() : undefined,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiSshPublicKey(data: any): AppsPeopleOzExternalMergedpeopleapiSshPublicKey {
  return {
    ...data,
    expirationTime: data["expirationTime"] !== undefined ? new Date(data["expirationTime"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * This message mirrors the ContactPhoneNumber message in
 * ccc/grand_central/common/types.proto. For various reasons, we cannot take on
 * a direct dependency. See other proto file for most recent documentation.
 */
export interface AppsPeopleOzExternalMergedpeopleapiStructuredPhone {
  /**
   * The phone formatted type. See docs from mirrored proto:
   * http://google3/ccc/grand_central/common/types.proto?l=128&rcl=241000760
   */
  formattedType?: string;
  phoneNumber?: AppsPeopleOzExternalMergedpeopleapiStructuredPhonePhoneNumber;
  shortCode?: AppsPeopleOzExternalMergedpeopleapiStructuredPhoneShortCode;
  /**
   * The type of phone. See docs from mirrored proto:
   * http://google3/ccc/grand_central/common/types.proto?l=125&rcl=241000760
   */
  type?: string;
}

export interface AppsPeopleOzExternalMergedpeopleapiStructuredPhonePhoneNumber {
  e164?: string;
  i18nData?: AppsPeopleOzExternalMergedpeopleapiStructuredPhonePhoneNumberI18nData;
}

export interface AppsPeopleOzExternalMergedpeopleapiStructuredPhonePhoneNumberI18nData {
  countryCode?: number;
  internationalNumber?: string;
  isValid?: boolean;
  nationalNumber?: string;
  regionCode?: string;
  validationResult?:  | "UNKNOWN" | "IS_POSSIBLE" | "INVALID_COUNTRY_CODE" | "TOO_SHORT" | "TOO_LONG" | "IS_POSSIBLE_LOCAL_ONLY" | "INVALID_LENGTH";
}

export interface AppsPeopleOzExternalMergedpeopleapiStructuredPhoneShortCode {
  /**
   * The phone code. See docs from mirrored proto:
   * http://google3/ccc/grand_central/common/types.proto?l=70&rcl=241000760
   */
  code?: string;
  countryCode?: string;
}

export interface AppsPeopleOzExternalMergedpeopleapiTagline {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiTagline(data: any): AppsPeopleOzExternalMergedpeopleapiTagline {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiTagline(data: any): AppsPeopleOzExternalMergedpeopleapiTagline {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * *UNSUPPORTED*. This message is never populated and is no longer used.
 */
export interface AppsPeopleOzExternalMergedpeopleapiTeamsExtendedData {
  admins?: AppsPeopleOzExternalMergedpeopleapiPerson[];
  adminTo?: AppsPeopleOzExternalMergedpeopleapiPerson[];
  dottedLineManagers?: AppsPeopleOzExternalMergedpeopleapiPerson[];
  dottedLineReports?: AppsPeopleOzExternalMergedpeopleapiPersonListWithTotalNumber;
  failures?:  | "UNKNOWN_FAILURE" | "MANAGEMENT_CHAIN" | "REPORTS" | "DOTTED_LINE_REPORTS" | "DOTTED_LINE_MANAGERS" | "ADMINS" | "ADMIN_TO"[];
  managementChain?: AppsPeopleOzExternalMergedpeopleapiPerson[];
  reports?: AppsPeopleOzExternalMergedpeopleapiPersonListWithTotalNumber;
}

function serializeAppsPeopleOzExternalMergedpeopleapiTeamsExtendedData(data: any): AppsPeopleOzExternalMergedpeopleapiTeamsExtendedData {
  return {
    ...data,
    admins: data["admins"] !== undefined ? data["admins"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
    adminTo: data["adminTo"] !== undefined ? data["adminTo"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
    dottedLineManagers: data["dottedLineManagers"] !== undefined ? data["dottedLineManagers"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
    dottedLineReports: data["dottedLineReports"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonListWithTotalNumber(data["dottedLineReports"]) : undefined,
    managementChain: data["managementChain"] !== undefined ? data["managementChain"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
    reports: data["reports"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonListWithTotalNumber(data["reports"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiTeamsExtendedData(data: any): AppsPeopleOzExternalMergedpeopleapiTeamsExtendedData {
  return {
    ...data,
    admins: data["admins"] !== undefined ? data["admins"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
    adminTo: data["adminTo"] !== undefined ? data["adminTo"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
    dottedLineManagers: data["dottedLineManagers"] !== undefined ? data["dottedLineManagers"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
    dottedLineReports: data["dottedLineReports"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonListWithTotalNumber(data["dottedLineReports"]) : undefined,
    managementChain: data["managementChain"] !== undefined ? data["managementChain"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiPerson(item))) : undefined,
    reports: data["reports"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonListWithTotalNumber(data["reports"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiUserDefined {
  key?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiUserDefined(data: any): AppsPeopleOzExternalMergedpeopleapiUserDefined {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiUserDefined(data: any): AppsPeopleOzExternalMergedpeopleapiUserDefined {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

/**
 * DEPRECATED in favor of ProfileStats. Stats pertaining to incoming edges and
 * views, visible to the requester (with acls applied). Related to, but not
 * equal to, com.google.focus.proto.Storage.UserVisibleStats.
 */
export interface AppsPeopleOzExternalMergedpeopleapiUserVisibleStats {
  /**
   * Replacement for deprecated follower_count. Comes from the EdgeSummary.
   */
  incomingAnyCircleCount?: bigint;
  viewCount?: bigint;
}

function serializeAppsPeopleOzExternalMergedpeopleapiUserVisibleStats(data: any): AppsPeopleOzExternalMergedpeopleapiUserVisibleStats {
  return {
    ...data,
    incomingAnyCircleCount: data["incomingAnyCircleCount"] !== undefined ? String(data["incomingAnyCircleCount"]) : undefined,
    viewCount: data["viewCount"] !== undefined ? String(data["viewCount"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiUserVisibleStats(data: any): AppsPeopleOzExternalMergedpeopleapiUserVisibleStats {
  return {
    ...data,
    incomingAnyCircleCount: data["incomingAnyCircleCount"] !== undefined ? BigInt(data["incomingAnyCircleCount"]) : undefined,
    viewCount: data["viewCount"] !== undefined ? BigInt(data["viewCount"]) : undefined,
  };
}

/**
 * Store metadata information like annotation-id and product source for visible
 * to guests contacts go/visible-to-guests.
 */
export interface AppsPeopleOzExternalMergedpeopleapiVisibleToGuests {
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
}

function serializeAppsPeopleOzExternalMergedpeopleapiVisibleToGuests(data: any): AppsPeopleOzExternalMergedpeopleapiVisibleToGuests {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiVisibleToGuests(data: any): AppsPeopleOzExternalMergedpeopleapiVisibleToGuests {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiWebContactsExtendedData {
  /**
   * Used by Contacts client-side to indicate whether a person is not
   * completed.
   */
  isIncomplete?: boolean;
}

export interface AppsPeopleOzExternalMergedpeopleapiWebsite {
  /**
   * The `type` translated and formatted in the request locale. See
   * go/people-api-howto/localization for details on how to usage.
   */
  formattedType?: string;
  metadata?: AppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata;
  /**
   * Currently in Oz: "Links": Links with no rel. "Other profiles": Links with
   * rel=ME. "Contributor to": Links with rel=CONTRIBUTOR_TO or
   * PAST_CONTRIBUTOR_TO.
   */
  rel?: AppsPeopleOzExternalMergedpeopleapiWebsiteRelationshipInfo[];
  /**
   * The type of the website. The type can be free form or one of these
   * predefined values: * `home` * `work` * `blog` * `profile` * `homePage` *
   * `ftp` * `reservations` * `appInstallPage`: website for a Currents
   * application. * `other`
   */
  type?: string;
  value?: string;
}

function serializeAppsPeopleOzExternalMergedpeopleapiWebsite(data: any): AppsPeopleOzExternalMergedpeopleapiWebsite {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? serializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiWebsite(data: any): AppsPeopleOzExternalMergedpeopleapiWebsite {
  return {
    ...data,
    metadata: data["metadata"] !== undefined ? deserializeAppsPeopleOzExternalMergedpeopleapiPersonFieldMetadata(data["metadata"]) : undefined,
  };
}

export interface AppsPeopleOzExternalMergedpeopleapiWebsiteRelationshipInfo {
  type?:  | "UNKNOWN" | "ME" | "NOT_ME" | "CONTRIBUTOR_TO" | "PAST_CONTRIBUTOR_TO";
}

/**
 * Extension data for use in Youtube Product Profile.
 */
export interface AppsPeopleOzExternalMergedpeopleapiYoutubeExtendedData {
  /**
   * Information about a channel created by the user. A user can create
   * multiple Youtube channels.
   */
  channelData?: AppsPeopleOzExternalMergedpeopleapiChannelData[];
  /**
   * Failure type if there is an error when fetching product profile data.
   */
  failure?: AppsPeopleOzExternalMergedpeopleapiProductProfileFailure;
}

function serializeAppsPeopleOzExternalMergedpeopleapiYoutubeExtendedData(data: any): AppsPeopleOzExternalMergedpeopleapiYoutubeExtendedData {
  return {
    ...data,
    channelData: data["channelData"] !== undefined ? data["channelData"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiChannelData(item))) : undefined,
  };
}

function deserializeAppsPeopleOzExternalMergedpeopleapiYoutubeExtendedData(data: any): AppsPeopleOzExternalMergedpeopleapiYoutubeExtendedData {
  return {
    ...data,
    channelData: data["channelData"] !== undefined ? data["channelData"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiChannelData(item))) : undefined,
  };
}

/**
 * Access settings for providers.
 */
export interface AssistantApiAccessControlOutput {
  /**
   * If true, the user consented to use YouTube Kids as a video provider for
   * non-unicorn users(voice recognized adults or guest). Unicorn accounts
   * shouldn’t use this setting.
   */
  allowNonUnicornUserAccessYoutubeKids?: boolean;
  guestAccessOnYoutube?:  | "UNKNOWN_GUEST_ACCESS" | "USE_DEFAULT_ACCOUNT_FOR_GUEST" | "DISABLED_FOR_GUEST";
}

/**
 * The features supported by the ActionV2 protocol. Note that after we move on
 * to ConversationProto for all surfaces we can remove this message.
 */
export interface AssistantApiActionV2SupportedFeatures {
  /**
   * This flag is used to work around a bug in AGSA 6.8 that got away. The bug
   * prevents users from accessing their shopping list if the URL of the
   * shopping list is not a keep.google.com URL. This will happen when switch
   * the backend that stores the shopping list from Keep to a backend maintained
   * by the Google Shopping Express team.
   */
  expressUrlInSettingsResponseSupported?: boolean;
  /**
   * Whether client supports reconnect client input in action v2 payload. This
   * capability is needed to determine if client supports parsing client input
   * payload from actionv2 proto for workflow purposes. See
   * go/personal-workflow. OWNER:nyzstar,vvvemuri.
   */
  reconnectClientInputSupported?: boolean;
  /**
   * Whether or not the surface supports a simple UnsupportedAction instead of
   * a ModalState punt card for rendering. For ActionV2 punt cards, the
   * ModalState extension on the ResourceSet is the canonical way of building
   * punt cards. However, while most all devices support the ActionV2 protocol,
   * not all devices handle the ModalState rendering as part of the ActionV2.
   * For these devices, we want to build a modified ActionV2 for punt cards
   * which omits this ModalState. At present, this is only Android Wear and
   * should not be used for other devices if they support ModalState or
   * Conversation protocol.
   */
  simpleActionV2PuntSupported?: boolean;
  /**
   * A list of all the action types supported by the client. These should be
   * the string representation of majel.ActionTypes within
   * "quality/majel/api/proto/action_v2.proto".
   */
  supportedActionType?: string[];
  /**
   * Checks if screenshots can be taken on the client. This field is set on the
   * client from AGSA 7.2 onwards.
   */
  takeScreenshotSupported?: boolean;
  /**
   * If IMMERSIVE_ACTIONS UiType is supported by the client.
   */
  voiceDelightImmersiveUiSupported?: boolean;
  /**
   * If Voice Delight Stickers are supported by the client. In order to support
   * Voice Delight stickers, the client should know how to extract sticker_url
   * from VoiceDelightSystemInteractionSegment.
   */
  voiceDelightStickersSupported?: boolean;
  /**
   * If Voice Delight Suggestion Chips are supported by the client. In order to
   * support Voice Delight Suggestion Chips, the client should know how to
   * extract suggestions form VoiceDelightSystemInteraction.ResourceSet.
   */
  voiceDelightSuggestionsSupported?: boolean;
}

/**
 * Capabilities related to Android intent support. These capabilities can apply
 * to any device on the Android platform. Provides the list of Android package
 * names that support a given Android intent.
 */
export interface AssistantApiAndroidIntentCapabilities {
  androidIntentCapability?: AssistantApiAndroidIntentCapabilitiesAndroidIntentCapability[];
}

export interface AssistantApiAndroidIntentCapabilitiesAndroidIntentCapability {
  /**
   * The Action name of the Android Intent in standard notation
   * (https://developer.android.com/reference/android/content/Intent#getAction()).
   */
  intentActionName?: string;
  /**
   * The Android provider packages that support the intent, e.g.
   * "com.google.android.deskclock".
   */
  packageNames?: string[];
}

/**
 * Used to describe app capabilities of the device installed apps reported to
 * the server.
 */
export interface AssistantApiAppCapabilities {
  /**
   * Indicates whether the provider is compatible for media fulfillment on this
   * surface. For example, Amazon Music isn't compatible with the driving mode.
   */
  allowlistedForMediaFulfillment?: boolean;
  /**
   * Currently unused. Will be used in the future when integrating with
   * incremental app capabilities.
   */
  appIntegrationsSettings?: AssistantApiAppIntegrationsSettings;
  /**
   * This system app is disabled in settings.
   */
  disabledSystemApp?: boolean;
  /**
   * The installed app of the provider.
   */
  provider?: AssistantApiCoreTypesProvider;
  /**
   * This provider has integrated its cloud backend with Google, and Google can
   * route the user queries to the provider's cloud.
   */
  routableToProviderCloud?: boolean;
  /**
   * This provider has an app that supports on-device search through the
   * provider's own inventory.
   */
  searchableOnDevice?: boolean;
  /**
   * This provider has integrated its content with Google, and Google has
   * enabled to serve its content as a server-side solution.
   */
  searchableOnServer?: boolean;
  /**
   * This provider has an app that supports starting new media playback when
   * there is no screen (e.g. by integrating with the Bisto SDK).
   */
  supportsScreenlessInitiation?: boolean;
  /**
   * This provider is an app which should be used for query annotations. This
   * is useful for apps which may not be already indexed by Google or are client
   * specific.
   */
  whitelistedForAnnotation?: boolean;
}

function serializeAssistantApiAppCapabilities(data: any): AssistantApiAppCapabilities {
  return {
    ...data,
    provider: data["provider"] !== undefined ? serializeAssistantApiCoreTypesProvider(data["provider"]) : undefined,
  };
}

function deserializeAssistantApiAppCapabilities(data: any): AssistantApiAppCapabilities {
  return {
    ...data,
    provider: data["provider"] !== undefined ? deserializeAssistantApiCoreTypesProvider(data["provider"]) : undefined,
  };
}

/**
 * Used to describe the incremental change of app capabilities of the device
 * installed apps reported to the server.
 */
export interface AssistantApiAppCapabilitiesDelta {
  /**
   * Currently unused. Will be used in the future when integrating with
   * incremental app capabilities.
   */
  appIntegrationsSettings?: AssistantApiAppIntegrationsSettings;
  /**
   * The installed app of the provider.
   */
  providerDelta?: AssistantApiCoreTypesProviderDelta;
}

function serializeAssistantApiAppCapabilitiesDelta(data: any): AssistantApiAppCapabilitiesDelta {
  return {
    ...data,
    providerDelta: data["providerDelta"] !== undefined ? serializeAssistantApiCoreTypesProviderDelta(data["providerDelta"]) : undefined,
  };
}

function deserializeAssistantApiAppCapabilitiesDelta(data: any): AssistantApiAppCapabilitiesDelta {
  return {
    ...data,
    providerDelta: data["providerDelta"] !== undefined ? deserializeAssistantApiCoreTypesProviderDelta(data["providerDelta"]) : undefined,
  };
}

export interface AssistantApiAppControlSupport {
  enabled?:  | "DEFAULT_DISABLED" | "ENABLED_WITH_SMART_DICTATION";
}

/**
 * Contains the app privacy bits used for App Integrations implicit request.
 * (go/app-privacy-settings-for-implicit-requests)
 */
export interface AssistantApiAppIntegrationsSettings {
  /**
   * Whether to enable Assistant to handle request with predicted apps.
   */
  handleRequestsWithPredictedApps?:  | "UNSET" | "FALSE" | "TRUE";
}

export interface AssistantApiAssistantContinuedPresenceSupport {
  /**
   * Indicates in what cases assistant continued presence can be shown as a
   * plate. This field is white-listed as being PII-free. Please do not add PII
   * here.
   */
  plateSupport?:  | "DEFAULT_NO_PLATE" | "SEARCH_ONLY";
}

/**
 * These capabilities represent the audio input features associated with the
 * device. This includes what kind of audio input the device can handle, and
 * what the privacy circumstances of that input are.
 */
export interface AssistantApiAudioInput {
  environment?:  | "SURROUNDING_USERS" | "AUTHENTICATED_USER_ONLY";
  quality?:  | "VOICE_QUALITY" | "MUSIC_QUALITY";
}

/**
 * These capabilities represent the audio output features associated with the
 * device. This includes what kind of audio output the device can handle, and
 * what the privacy circumstances of that output are.
 */
export interface AssistantApiAudioOutput {
  alwaysOnSpeaker?:  | "UNKNOWN" | "NOT_SUPPORTED" | "SUPPORTED";
  environment?:  | "SURROUNDING_USERS" | "AUTHENTICATED_USER_ONLY";
  mediaTtsMixable?:  | "MEDIA_TTS_MIXABLE_UNKNOWN" | "MEDIA_TTS_MIXABLE_NOT_SUPPORTED" | "MEDIA_TTS_MIXABLE_SUPPORTED";
  quality?:  | "VOICE_QUALITY" | "MUSIC_QUALITY";
  volumeProperties?: AssistantApiVolumeProperties;
}

/**
 * Bluetooth capabilities related to usage of a feature.
 */
export interface AssistantApiBluetoothCapabilities {
  /**
   * If this surface needs to bluetooth pair a phone before using a feature.
   */
  isBluetoothConnectedProfileRequired?: boolean;
}

/**
 * CallCapabilities supported by a surface. See go/call-capabilities. Next ID:
 * 7
 */
export interface AssistantApiCallCapabilities {
  /**
   * The supported call formats on the surface.
   */
  callFormats?:  | "UNSPECIFIED_FORMAT" | "AUDIO" | "VIDEO" | "TEXT"[];
  /**
   * The supported call mediums on the surface.
   */
  callMediums?:  | "UNSPECIFIED_MEDIUM" | "PSTN" | "VOIP" | "EMAIL" | "ONLINE_CHAT" | "TEXT_MESSAGING" | "MESSAGE"[];
  /**
   * The call options this surface can provide. For example, SPEAKERPHONE is
   * available on Android OPA while iOPA doesn't support it yet.
   */
  callOptions?:  | "UNSPECIFIED_CALL_OPTION" | "SPEAKERPHONE" | "BLUETOOTH" | "HEADSET" | "MIC" | "CAMERA"[];
  /**
   * If true, APP_ID queries initiated by this device should fall back to
   * execution on the tethered device if it's available and if the primary
   * device cannot perform the action (e.g. due to the app not being installed).
   */
  fallbackToTetheredDeviceAppCapabilities?: boolean;
  /**
   * Should only be checked if nonempty.
   */
  supportedRecipientTypes?:  | "UNSPECIFIED_ENDPOINT" | "PHONE_NUMBER" | "EMAIL_ADDRESS" | "APP_UNIQUE_ID" | "EMERGENCY_PHONE_NUMBER" | "VOICEMAIL"[];
  /**
   * Whether the surface supports Duo calling email endpoints.
   */
  supportsDuoEmailEndpoint?: boolean;
}

/**
 * These capabilities represent the camera features associated with the device.
 */
export interface AssistantApiCameraCapabilities {
  /**
   * Whether the device supports Face Match.
   */
  faceMatchCapable?: boolean;
  /**
   * Whether the device has a camera.
   */
  hasCamera?: boolean;
}

/**
 * These capabilities present the capability of the device running camera
 * receiver apps.
 */
export interface AssistantApiCameraReceiverCapabilities {
  /**
   * Whether the device has limited camera stream capability. If true, check
   * supported_camera_receivers for detailed supported cameras.
   */
  hasLimitedCameraStreamCapability?: boolean;
  /**
   * The camera receiver cast apps the device supports. Only used if
   * has_limited_camera_stream_capability is true.
   */
  supportedCameraReceivers?: AssistantApiCoreTypesCastAppInfo[];
}

/**
 * Information about the readiness of Home app features on the device. As of
 * January 2023, this is only populated by Assistant on Android.
 */
export interface AssistantApiCapabilitiesHomeAppCapabilities {
  /**
   * The app's installation and setup state. This is most pertinent for Tangor,
   * where lock screen Smart Home queries are fulfilled by a Home app activity
   * that may be blocked if this value is not `SETUP_STATE_COMPLETE`.
   */
  setupState?:  | "SETUP_STATE_UNKNOWN" | "SETUP_STATE_INCOMPLETE" | "SETUP_STATE_COMPLETE";
}

/**
 * Capabilities that are associated with Assistants on auto surfaces. This is
 * different from other capabilities such as CarSettingsCapabilities,
 * CloudCarCapabilities since they are specific to settings and 3P cloud
 * information. All the auto/car Assistant specific capabilities should live
 * here.
 */
export interface AssistantApiCarAssistantCapabilities {
  /**
   * Indicates whether the current Assistant should provide a multi Assistant
   * specific punt when there are multiple Auto specific Google Assistants
   * (Android Auto Projected (AAP) and Android Auto Embedded (AAE)) in the same
   * GAS enabled car. This will be used by both AAP and AAE. Design doc:
   * go/doubledash++
   */
  shouldPuntMultiAssistantMode?: boolean;
}

/**
 * Capabilities that are associated with Assistant Settings on auto surfaces.
 */
export interface AssistantApiCarSettingsCapabilities {
  /**
   * If true, it indicates that the auto surface client should receive a warmer
   * welcome TTS for signed-out users. For signed-in user, we will rely on
   * server side metadata. go/aaae:preview-lang
   */
  playWarmerWelcome?: boolean;
  /**
   * If true, it indicates that the client can be used to add cars after
   * account linking with the OEM.
   */
  supportsAddingCars?: boolean;
}

export interface AssistantApiCastAssistantSettingLinkingResult {
  /**
   * Cast linking status for ATV surfaces. This is derived from error messages
   * returned from Cast Orchestration Server and will be used for data profiling
   * only(go/katniss-settings-dashboard).
   */
  castLinkingStatus?:  | "NOT_SET" | "SUCCEED" | "DEVICE_CONFLICT" | "DEVICE_NAME_EMPTY" | "CLIENT_ID_MISSING_TAG" | "INVALID_DEVICE_ID" | "DATA_SYNC_THROTTLED" | "CREATE_ROBOT_ACCOUNT_FAILED" | "UNAUTHORIZED_CLIENT" | "OTHER_ERROR";
  /**
   * The error msg returned from COS, truncated in case it's too large.
   */
  truncatedErrorMsg?: string;
}

/**
 * These capabilities represent capabilities that have to do with casting that
 * pertain to this device. Next ID: 9
 */
export interface AssistantApiCastCapabilities {
  /**
   * Whether the device has limited camera stream capability and if yes, which
   * receivers are supported.
   */
  cameraReceiverCapabilities?: AssistantApiCameraReceiverCapabilities;
  /**
   * The supported protocols for camera streaming. The value is used as string
   * in go/smarthome-internal-api#camera-stream, so using a string for this
   * field instead of an enum. Supported protocols: (align the definition in
   * go/smarthome-camerastream-trait) - "hls": HTTP Live Streaming - "dash":
   * Dynamic Adaptive Streaming over HTTP - "smooth_stream": Smooth Streaming -
   * "progressive_mp4": Progressive MP4 (will likely only be used for Clips) -
   * "webrtc": WebRTC (currently, only H.264 is supported) - "nexustalk":
   * Internal-only protocol used for Nest
   */
  cameraStreamSupportedProtocols?: string[];
  /**
   * True if we can cast things to this device.
   */
  canReceiveCast?: boolean;
  /**
   * Optional for primarily cast devices (e.g., Chirp, Chromecast). For devices
   * that are NOT primarily cast devices, but having a cast receiver as
   * secondary functionality, this field SHOULD store the cast-device-id to be
   * used to send remote casting commands to the device. Example: Android TV,
   * which supports both Android-native actions as well as remote casting using
   * its built-in cast receiver. Android TV device id contains a DUSI id, which
   * is not a cast-device-id. When executing a cast command on the Android TV,
   * this field is used to route the cast command (through CloudCastService) to
   * the cast receiver on the device.
   */
  deviceId?: AssistantApiCoreTypesDeviceId;
  /**
   * Whether this device supports dynamic groups or not. It implies if a Stream
   * Control operation (transfer, expansion, and contraction) could be applied
   * on this device since Stream Control is implemented as part of dynamic
   * groups (ie, adding/removing devices from playback)
   */
  dynamicGroupsSupported?: boolean;
  groupType?:  | "NONE" | "STATIC_GROUP" | "DYNAMIC_GROUP" | "STEREO_PAIR";
  /**
   * Whether UI overlay applications are supported on this device. It's used by
   * Chromecast only.
   */
  overlayApplicationsSupported?: boolean;
  /**
   * Whether the device supports playing games through Yeti. This is set by the
   * cast device when the device is updated: Chromecast updates -> Chromecast
   * registers its capabilities with CCS -> CCS passes the capabilities to the
   * AssistantSettingsService -> AssistantSettingsService stores the device's
   * capabilities. go/yeti-gaming-supported-cast-capability
   */
  yetiGamingSupported?: boolean;
}

/**
 * The properties of the client op device.MODIFY_SETTING. This proto is stored
 * in the SupportedClientOp proto.
 */
export interface AssistantApiClientOpPropertiesDeviceModifySettingClientOpProperty {
  /**
   * Additional specific setting capabilities. This boolean is used to indicate
   * whether we want to skip the Android and GSA version check in
   * CheckSettingSchemaAndMaybeGetUris() from
   * assistant/vertical/device/fulfillment/utils/setting_utils.h. Consider
   * setting this field to true if your device is neither Android or GSA
   * (especially when the UserAgent string of your device's TaskRequest will not
   * contain a valid/up-to-date Android/GSA version).
   */
  skipAndroidAndGsaVersionCheck?: boolean;
  /**
   * Uses DeviceSetting enum which corresponds to setting_id. This indicates
   * which specific settings are supported by client. An empty list implies all
   * settings are supported.
   */
  supportedSettings?:  | "UNSPECIFIED" | "ABOUT_ME" | "ACCESSIBILITY" | "ACTIVE_EDGE" | "ACTIVE_EDGE_SENSITIVITY" | "ADAPTIVE_BATTERY" | "ADAPTIVE_BRIGHTNESS" | "ADAPTIVE_CHARGING" | "ADAPTIVE_CONNECTIVITY" | "ADAPTIVE_SOUND" | "ADD_ACCOUNT" | "ADD_BLUETOOTH_DEVICE" | "ADD_DEVICE" | "ADD_FINGERPRINT" | "ADS_TRACKING" | "AIRPLANE_MODE" | "ALARM_VOLUME" | "ALARM_SOUND" | "ALLOW_MULTIPLE_USERS" | "AMBIENT_DISPLAY_ALWAYS_ON" | "AMBIENT_DISPLAY_NEW_NOTIFICATION" | "ANDROID_AUTO" | "ANDROID_VERSION" | "APP_BATTERY_USAGE" | "APP_DATA_USAGE" | "APP_DETAILS" | "APP_SHORTCUT" | "APPS_NOTIFICATIONS" | "APPS_STORAGE" | "ASSISTANT_ACCOUNT" | "ASSISTANT_FACE_MATCH" | "ASSISTANT_LANGUAGE" | "ASSISTANT_VOICE_MATCH" | "AUTO_ROTATE" | "AUTO_ROTATE_FACE_DETECTION" | "BACKUP" | "BATTERY_LEVEL" | "BATTERY_LOW" | "BATTERY_PERCENTAGE" | "BATTERY_PRESENT" | "BATTERY_SAVER" | "BATTERY_SAVER_SCHEDULE" | "BATTERY_SHARE" | "BATTERY_USAGE" | "BIOMETRIC" | "BLUETOOTH" | "BLUETOOTH_NAME" | "BLUETOOTH_ADDRESS" | "BLUETOOTH_SETTINGS" | "BRIGHTNESS_LEVEL" | "BUBBLES" | "CALL_VOLUME" | "CAMERA_DOUBLE_TWIST" | "CAST" | "CAR_CRASH_DETECTION" | "COLOR_INVERSION" | "COLOR_CORRECTION" | "CONVERSATIONS" | "CHARGING_SOUNDS_AND_VIBRATION" | "CHARGING_STATE" | "CONNECTED_DEVICES" | "CONTACTLESS_PAYMENTS" | "DATA_ROAMING" | "DATA_SAVER" | "DATA_USAGE" | "DATA_LIMIT" | "DATA_LIMIT_LEVEL" | "DATA_WARNING" | "DATA_WARNING_LEVEL" | "DEFAULT_ALARM_SOUND" | "DEFAULT_NOTIFICATION_SOUND" | "DEFAULT_APPS" | "DEVELOPER_OPTIONS" | "DEVICE_ASSISTANT_APP" | "DEVICE_NAME" | "DISPLAY_OVER_OTHER_APPS" | "DISPLAY_SIZE" | "DO_NOT_DISTURB" | "DO_NOT_DISTURB_MESSAGES" | "DO_NOT_DISTURB_CALLS" | "DO_NOT_DISTURB_ALARMS" | "DO_NOT_DISTURB_SCHEDULES" | "DOUBLE_TAP_CHECK_PHONE" | "DRIVING_MODE" | "EARTHQUAKE_ALERTS" | "EMERGENCY" | "EMERGENCY_ALERTS" | "EMERGENCY_CONTACTS" | "EMERGENCY_INFORMATION" | "ETHERNET_TETHERING" | "EXTRA_DIM" | "EXTREME_BATTERY_SAVER" | "FACTORY_RESET" | "FIND_MY_DEVICE" | "FLASHLIGHT" | "FOCUS_MODE" | "FONT_SIZE" | "FREE_UP_SPACE" | "FINGERPRINT_MANAGER" | "GESTURES" | "HAPTIC_FEEDBACK_VIBRATION" | "HARD_KEYBOARD" | "HEADS_UP" | "HIGH_REFRESH_RATE" | "HOT_SPOT" | "HOTSPOT_TETHERING" | "HOT_WORD" | "IP_ADDRESS" | "IMPROVE_LOCATION_ACCURACY" | "JUMP_TO_CAMERA" | "KEYBOARD_SHORTCUTS" | "LIFT_CHECK_PHONE" | "LIVE_TRANSLATE" | "LOCATION" | "LOCATION_HISTORY" | "LOCATION_BLUETOOTH_SCANNING" | "LOCATION_WIFI_SCANNING" | "LOCK_SCREEN" | "LOCK_SCREEN_DEVICE_CONTROLS" | "LOCK_SCREEN_WALLET" | "MAC_ADDRESS" | "MAGNIFICATION" | "MAGNIFY_BUTTON" | "MAGNIFY_TRIPLE_TAP" | "MANIFY_BUTTON" | "MANIFY_TRIPLE_TAP" | "MEDIA" | "MEDIA_VOLUME" | "MICROPHONE_ACCESS" | "MOBILE" | "MOBILE_DATA" | "MUSIC" | "MUTE_MODE" | "NETWORK" | "NETWORK_RESET" | "NFC" | "NIGHT_LIGHT_INTENSITY" | "NIGHT_LIGHT_SWITCH" | "NIGHT_MODE" | "NOTIFICATION_BADGE" | "NOTIFICATION_SOUND" | "NOTIFICATION_ON_SCREEN" | "NOTIFICATION_HISTORY" | "NOTIFY_FOR_PUBLIC_NETWORKS" | "ONEHANDED_MODE" | "OS_VERSION" | "PASSWORD" | "PERMISSION_MANAGER" | "PERMISSION_USAGE" | "PERSONALIZATION" | "PRINTING" | "PHONE_NUMBER" | "PICTURE_IN_PICTURE" | "POINTER_SPEED" | "POWER_MENU" | "REMINDERS" | "REQUIRE_DEVICE_UNLOCK_FOR_NFC" | "RINGTONE" | "RING_VOLUME" | "NEARBY_DEVICES_SCANNING" | "NEARBY_SHARE" | "SCREEN_LOCKING_SOUND" | "SCREEN_MAGNIFICATION" | "SCREEN_TIMEOUT" | "SCREEN_LOCK" | "SCREEN_SAVER" | "SELECT_TO_SPEAK" | "SET_TIME_AUTOMATICALLY" | "SET_TIME_ZONE_AUTOMATICALLY" | "SETTINGS" | "SIM" | "SIM_MANAGER" | "SPEECH_RATE" | "STORAGE_USAGE" | "SWIPE_FOR_NOTIFICATION" | "SWITCH_ACCESS" | "SYSTEM_UPDATE" | "SYSTEM_UPDATES" | "SYSTEM_NAVIGATION" | "SYSTEM_NAVIGATION_GESTURES" | "SYSTEM_NAVIGATION_BUTTONS" | "TALKBACK_PASSWORDS" | "TEXT_TO_SPEECH" | "TIME_ZONE" | "UNUSED_APPS" | "USB" | "USB_TETHERING" | "VERBOSE_TTS" | "VIBRATE" | "VIBRATION" | "VIBRATION_MODE" | "VOICE" | "VOLUME_LEVEL" | "WAKE_SCREEN_FOR_NOTIFICATIONS" | "WALLPAPERS" | "WEBVIEW" | "WIFI" | "WIFI_ADD_NETWORK" | "WIFI_ADD_NETWORK_QR_CODE" | "WIFI_CALLING" | "WIFI_HOTSPOT" | "ABOUT_PHONE" | "ACCOUNTS" | "APPLICATION" | "ASSISTANT" | "AUDIO" | "BATTERY" | "BELL_SCHEDULE" | "CONTINUED_CONVERSATION" | "DATE_TIME" | "DARK_THEME" | "DEVICE_INFO" | "DICTIONARY" | "DIGITAL_WELLBEING" | "DISPLAY" | "LANGUAGE" | "NIGHT_LIGHT" | "NOTIFICATION" | "NOTIFICATION_VOLUME" | "PHONE_RINGTONE" | "PRIVACY" | "ROAMING" | "ROUTINES" | "SEARCH" | "SECURITY" | "SOUND" | "SPELL_CHECKER" | "SYSTEM" | "STORAGE" | "VPN" | "AUTOCLICK" | "CARET_HIGHLIGHT" | "CHROMEVOX" | "CURSOR_HIGHLIGHT" | "DOCKED_MAGNIFIER" | "FOCUS_HIGHLIGHT" | "FULLSCREEN_MAGNIFIER" | "HIGH_CONTRAST_MODE" | "LARGE_CURSOR" | "MONO_AUDIO" | "STICKY_KEYS" | "TAP_DRAGGING" | "VIRTUAL_KEYBOARD" | "WEARABLE_AMBIENT" | "WEARABLE_NOISE_CANCELLATION" | "WEARABLE_TOUCH_CONTROLS" | "RAISE_TO_TALK" | "BEDTIME_MODE" | "THEATER_MODE" | "TOUCH_LOCK"[];
  /**
   * Additional specific setting capabilities. This boolean is used to indicate
   * if do not disturb with duration is supported through device.MODIFY_SETTING
   * clientop on a client or not.
   */
  supportsDoNotDisturbWithDuration?: boolean;
  /**
   * Additional specific setting capabilities. This boolean is used to indicate
   * if new unmute logic is enabled on a client or not.
   */
  supportsMuteUnmute?: boolean;
}

/**
 * The properties of the provider.OPEN ClientOp. This proto is stored in the
 * SupportedClientOp proto with the key provider.OPEN.
 */
export interface AssistantApiClientOpPropertiesProviderOpenClientOpProperty {
  /**
   * Whether conversation is kept alive after opening the app. See
   * go/keep-opa-conversation-alive for details.
   */
  keepsConversationAliveAfterOpeningApp?: boolean;
}

/**
 * Used to describe clock capabilities of the device (for example, capabilities
 * related to maximum number of supported alarms and timers that can be created
 * on the device). Fields may be populated by clients or be backfilled by SAL
 * (in case of Timon, for example).
 */
export interface AssistantApiClockCapabilities {
  /**
   * Maximum number of alarms that can be created on the client.
   */
  maxSupportedAlarms?: number;
  /**
   * Maximum extended timer duration supported by the client. The extended
   * timer duration is the total start-to-finish duration after an
   * AddTimeToTimer operation. E.g. if a user sets a timer for 30 minutes, and
   * later adds 10 minutes, the extended duration is 40 minutes.
   */
  maxSupportedExtendedTimerDuration?: AssistantApiDuration;
  /**
   * Maximum duration of timers that can be created on the client.
   */
  maxSupportedTimerDuration?: AssistantApiDuration;
  /**
   * Maximum number of timers that can be created on the client.
   */
  maxSupportedTimers?: number;
  /**
   * The preferred provider to use for stopwatch related functionality.
   */
  preferredStopwatchProvider?: AssistantApiCoreTypesProvider;
  /**
   * Whether the client restricts alarms to ring within the next 24 hours.
   */
  restrictAlarmsToNext24h?: boolean;
}

function serializeAssistantApiClockCapabilities(data: any): AssistantApiClockCapabilities {
  return {
    ...data,
    maxSupportedExtendedTimerDuration: data["maxSupportedExtendedTimerDuration"] !== undefined ? serializeAssistantApiDuration(data["maxSupportedExtendedTimerDuration"]) : undefined,
    maxSupportedTimerDuration: data["maxSupportedTimerDuration"] !== undefined ? serializeAssistantApiDuration(data["maxSupportedTimerDuration"]) : undefined,
    preferredStopwatchProvider: data["preferredStopwatchProvider"] !== undefined ? serializeAssistantApiCoreTypesProvider(data["preferredStopwatchProvider"]) : undefined,
  };
}

function deserializeAssistantApiClockCapabilities(data: any): AssistantApiClockCapabilities {
  return {
    ...data,
    maxSupportedExtendedTimerDuration: data["maxSupportedExtendedTimerDuration"] !== undefined ? deserializeAssistantApiDuration(data["maxSupportedExtendedTimerDuration"]) : undefined,
    maxSupportedTimerDuration: data["maxSupportedTimerDuration"] !== undefined ? deserializeAssistantApiDuration(data["maxSupportedTimerDuration"]) : undefined,
    preferredStopwatchProvider: data["preferredStopwatchProvider"] !== undefined ? deserializeAssistantApiCoreTypesProvider(data["preferredStopwatchProvider"]) : undefined,
  };
}

/**
 * UI capabilities for the surfaces rendering Comms features. See
 * go/rohan-comms-fluid-actions-customization.
 */
export interface AssistantApiCommunicationUiCapabilities {
  fluidActionsUiType?:  | "DEFAULT" | "SIMPLIFIED";
}

export interface AssistantApiContactLookupCapabilities {
  /**
   * If true, contact.LOOKUP should be routed to the tethered device (if
   * present) if the tethered device supports contact.LOOKUP and the primary
   * device does not.
   */
  fallbackToTetheredDevice?: boolean;
}

/**
 * The android app information of the provider. Like, Spotify. Next ID: 16
 * LINT.IfChange
 */
export interface AssistantApiCoreTypesAndroidAppInfo {
  accountType?: string;
  /**
   * Intent associated with the app. We include intents here as different
   * versions of the same app may support different intents. In those cases, the
   * package_name is not enough to identify the app and we should use the
   * combination of package_name and android_intent. This field might contain
   * sensitive data, if represents ClientOp with encapsulated PII such as user
   * query.
   */
  androidIntent?: string;
  /**
   * Store the app unique id endpoint. This will be passed over to app to
   * fulfill the action.
   */
  appUniqueId?: string;
  /**
   * The android app version. Deprecated because
   * https://developer.android.com/reference/android/content/pm/PackageInfo.html#getLongVersionCode
   */
  appVersion?: number;
  /**
   * data_mimetype and account_type are the what AGSA uses to filter which
   * contacts support this Android app in ContactProvider.
   */
  dataMimetype?: string;
  /**
   * If true, client should broadcast the intent instead of open the intent.
   */
  isBroadcastIntent?: boolean;
  /**
   * App is the default app for it's core functionality. For example, it will
   * be true for Android messages if it is the default app to send and receive
   * SMS on the phone.
   */
  isDefault?: boolean;
  /**
   * The localized app name.
   */
  localizedAppName?: string;
  /**
   * The long android app version.
   */
  longVersionCode?: bigint;
  /**
   * Store mimetype of this endpoint. We will use this as the differentiator
   * for Assistant to know whether to use the RawContact for messaging, call or
   * video call. For example, send message mimetype for whatsapp:
   * "vnd.android.cursor.item/vnd.com.whatsapp.profile" voice call mimetype for
   * whatsapp: "vnd.android.cursor.item/vnd.com.whatsapp.voip.call"
   */
  mimetype?: string;
  /**
   * The android app package of the provider, like "com.spotify.music".
   */
  packageName?: string;
  /**
   * The OemProviderType is specific for OEM system Android apps. For example,
   * in Auto Embedded, the OEM will have a system Radio/Media app. The system
   * app’s capabilities/core functionalities are captured here. For physical
   * media sources, the OEM may decide to implement one media app (thus, one
   * package name) that handles multiple physical media sources. For these
   * cases, each physical media source will be sent as different providers even
   * though the package name is the same.
   */
  providerType?:  | "UNKNOWN_OEM_PROVIDER_TYPE" | "RADIO_PROVIDER_TYPE" | "SXM_RADIO_PROVIDER_TYPE";
  /**
   * Id of the app's Android shortcut to be launched by Assistant. The client
   * is expected to use the Android LauncherApps API to execute this shortcut
   * which in turn will open the app. For example, Whatsapp may create an
   * Android shortcut for a frequently messaged contact with an id
   * "contact_123". This field will contain that id and the client can execute
   * it to open up the chat with that particular contact. If this field is set,
   * the package_name field must also be set since both will be used by the
   * LauncherApps API for execution. If this field is set, the intent related
   * fields will be ignored and not used as a fallback. Design:
   * go/shortcut-id-in-provider-open-clientop This field should only be set for
   * devices with Android API level >= 25 (since that is the version from which
   * the LauncherApps startShortcut API is available)
   */
  shortcutId?: string;
  /**
   * The fully qualified target class name of the provider, like
   * "com.example.myapp.GetOrderService".
   */
  targetClass?: string;
  /**
   * The android app version name, like "4.1.091.05.40d", "11.2.7.21.alpha".
   * Android Docs:
   * https://developer.android.com/reference/android/content/pm/PackageInfo#versionName
   */
  versionName?: string;
}

function serializeAssistantApiCoreTypesAndroidAppInfo(data: any): AssistantApiCoreTypesAndroidAppInfo {
  return {
    ...data,
    longVersionCode: data["longVersionCode"] !== undefined ? String(data["longVersionCode"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesAndroidAppInfo(data: any): AssistantApiCoreTypesAndroidAppInfo {
  return {
    ...data,
    longVersionCode: data["longVersionCode"] !== undefined ? BigInt(data["longVersionCode"]) : undefined,
  };
}

/**
 * The change of AndroidAppInfo, e.g. app installation or deletion for
 * incremental delta app info upload.
 */
export interface AssistantApiCoreTypesAndroidAppInfoDelta {
  /**
   * The android app information of the provider. Like, Spotify.
   */
  androidAppInfo?: AssistantApiCoreTypesAndroidAppInfo;
  /**
   * The client-side timestamp in millis when the app is last updated,
   * installed or deleted.
   */
  lastUpdateTimestamp?: Date;
  /**
   * App is installed or deleted.
   */
  updateType?:  | "UNKNOWN_TYPE" | "IS_INSTALLED" | "IS_DELETED";
}

function serializeAssistantApiCoreTypesAndroidAppInfoDelta(data: any): AssistantApiCoreTypesAndroidAppInfoDelta {
  return {
    ...data,
    androidAppInfo: data["androidAppInfo"] !== undefined ? serializeAssistantApiCoreTypesAndroidAppInfo(data["androidAppInfo"]) : undefined,
    lastUpdateTimestamp: data["lastUpdateTimestamp"] !== undefined ? data["lastUpdateTimestamp"].toISOString() : undefined,
  };
}

function deserializeAssistantApiCoreTypesAndroidAppInfoDelta(data: any): AssistantApiCoreTypesAndroidAppInfoDelta {
  return {
    ...data,
    androidAppInfo: data["androidAppInfo"] !== undefined ? deserializeAssistantApiCoreTypesAndroidAppInfo(data["androidAppInfo"]) : undefined,
    lastUpdateTimestamp: data["lastUpdateTimestamp"] !== undefined ? new Date(data["lastUpdateTimestamp"]) : undefined,
  };
}

/**
 * This proto contains the information of a calendar event, including title,
 * start time, end time, etc. IMPORTANT: The definition of CalendarEvent proto
 * is being moved to
 * //assistant/api/core_types/governed/calendar_event_type.proto. All existing
 * references will be updated to point to the new location. If you are adding a
 * reference, use the new one instead. LINT.IfChange(CalendarEvent) NEXT_ID: 26
 */
export interface AssistantApiCoreTypesCalendarEvent {
  /**
   * Attendees invited to the event, usually includes also the organizer.
   */
  attendees?: AssistantApiCoreTypesCalendarEventAttendee[];
  /**
   * The background color of the event, in RGB format.
   */
  backgroundColor?: number;
  /**
   * Optional calendar containing the event.
   */
  calendarId?: string;
  /**
   * The person who created this event.
   */
  creator?: AssistantApiCoreTypesCalendarEventAttendee;
  /**
   * Optional description of the event (plain text).
   */
  description?: string;
  /**
   * The end time of the event. Start and end time must either both be date or
   * both be datetime. End is exclusive, ie. the first day / first second when
   * the event is over.
   */
  end?: AssistantApiDateTime;
  /**
   * Optional event id provided by assistant server. Needs to be unique, at
   * least on a per-user and calendar level, ideally globally unique. If none is
   * given, the server will assign an id.
   */
  eventId?: string;
  /**
   * The flair name, calculated according to the event title (go/as-cal-flair).
   * With the flair name, background images can be got from gstatic (go/scs):
   * https://ssl.gstatic.com/tmly/f8944938hffheth4ew890ht4i8/flairs/
   */
  flairName?: string;
  /**
   * The foreground color of the event, in RGB format.
   */
  foregroundColor?: number;
  /**
   * Whether the guests can invite other guests.
   */
  guestsCanInviteOthers?: boolean;
  /**
   * Whether the guests can modify the event.
   */
  guestsCanModify?: boolean;
  /**
   * Whether the guests of the event can be seen. If false, the user is
   * reported as the only attendee to the event, even though there may be more
   * attendees.
   */
  guestsCanSeeGuests?: boolean;
  /**
   * Optional id of the Habit (Calendar Goal) this event is linked to
   */
  habitId?: string;
  /**
   * Optional status for this habit event instance.
   */
  habitStatus?:  | "UNKNOWN_STATUS" | "ACTIVE" | "DEFERRAL_REQUESTED" | "COMPLETE" | "UNDEFERRABLE";
  /**
   * Absolute link to this event in the Calendar web UI.
   */
  htmlLink?: string;
  /**
   * Optional location of the event (plain text).
   */
  location?: string;
  meetingContacts?: AssistantApiCoreTypesCalendarEventMeetingContact[];
  /**
   * The organizer of this event.
   */
  organizer?: AssistantApiCoreTypesCalendarEventAttendee;
  /**
   * Whether not all attendees are included in the attendee list. This is set
   * when the attendees list has been truncated (e.g., when the number of
   * attendees is beyond the maxAttendees limitation).
   */
  otherAttendeesExcluded?: boolean;
  /**
   * The user's response (the owner of this copy of the event) to this event.
   */
  participationResponse?:  | "RESPONSE_STATUS_UNSPECIFIED" | "NEEDS_ACTION" | "DECLINED" | "TENTATIVE" | "ACCEPTED";
  /**
   * If this is an instance of a recurring event, recurring_event_id identifies
   * the recurring series as a whole.
   */
  recurringEventId?: string;
  /**
   * Meeting rooms associated to this event.
   */
  rooms?: AssistantApiCoreTypesCalendarEventRoom[];
  /**
   * The start time of the event. This event is an all-day event if start has
   * no time_of_day.
   */
  start?: AssistantApiDateTime;
  /**
   * The title of the event.
   */
  summary?: string;
  /**
   * Optional visibility of the event.
   */
  visibility?:  | "DEFAULT" | "PUBLIC" | "PRIVATE" | "CONFIDENTIAL" | "SECRET" | "SHADOW" | "UNKNOWN";
}

function serializeAssistantApiCoreTypesCalendarEvent(data: any): AssistantApiCoreTypesCalendarEvent {
  return {
    ...data,
    meetingContacts: data["meetingContacts"] !== undefined ? data["meetingContacts"].map((item: any) => (serializeAssistantApiCoreTypesCalendarEventMeetingContact(item))) : undefined,
  };
}

function deserializeAssistantApiCoreTypesCalendarEvent(data: any): AssistantApiCoreTypesCalendarEvent {
  return {
    ...data,
    meetingContacts: data["meetingContacts"] !== undefined ? data["meetingContacts"].map((item: any) => (deserializeAssistantApiCoreTypesCalendarEventMeetingContact(item))) : undefined,
  };
}

/**
 * Next id: 8
 */
export interface AssistantApiCoreTypesCalendarEventAttendee {
  /**
   * Display name, present only if available.
   */
  displayName?: string;
  /**
   * Email address of the attendee (calendar), for regular events. For +Events,
   * this field is not populated, instead "id" is used.
   */
  email?: string;
  /**
   * Given (first) name, present only if available. This is used for generating
   * meeting titles as given name is preferred over display (full) name (ie:
   * "Jeff : Sundar" is better than "Jeff Dean : Sundar Pichai").
   */
  givenName?: string;
  /**
   * Profile ID of the principal, for +Events. For regular events, this field
   * is not populated, instead "email" is used.
   */
  id?: string;
  /**
   * Is this the organizer?
   */
  organizer?: boolean;
  /**
   * Attendees response status.
   */
  responseStatus?:  | "RESPONSE_STATUS_UNSPECIFIED" | "NEEDS_ACTION" | "DECLINED" | "TENTATIVE" | "ACCEPTED";
  /**
   * Is this the owner of this copy of the event?
   */
  self?: boolean;
}

/**
 * Next id: 10
 */
export interface AssistantApiCoreTypesCalendarEventMeetingContact {
  /**
   * ID that corresponds to in ConferenceData.conference_id in
   * calendar.common.ConferenceData proto. For Meet, this is the identifier used
   * to join a meeting via URL.
   */
  conferenceId?: string;
  dialInNumberClasses?:  | "NUMBER_CLASS_UNSPECIFIED" | "LOW_COST" | "HIGH_COST" | "LEGACY"[];
  /**
   * Default meeting phone number, for example: "tel:+1-475-777-1840"
   */
  phoneNumberUri?: string;
  /**
   * A PIN that the participant will need to input after dialing in the
   * conference.
   */
  pinNumber?: string;
  /**
   * Provider info for the meeting.
   */
  provider?: AssistantApiCoreTypesProvider;
  /**
   * The region code for the default meeting phone number
   */
  regionCode?: string;
  source?:  | "SOURCE_UNSPECIFIED" | "STRUCTURED_DATA" | "UNSTRUCTURED_DATA";
  /**
   * The universal meeting PIN number for phone numbers in all available
   * countries
   */
  universalPinNumber?: string;
  /**
   * URL that can be used to join the meeting.
   */
  url?: string;
}

function serializeAssistantApiCoreTypesCalendarEventMeetingContact(data: any): AssistantApiCoreTypesCalendarEventMeetingContact {
  return {
    ...data,
    provider: data["provider"] !== undefined ? serializeAssistantApiCoreTypesProvider(data["provider"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesCalendarEventMeetingContact(data: any): AssistantApiCoreTypesCalendarEventMeetingContact {
  return {
    ...data,
    provider: data["provider"] !== undefined ? deserializeAssistantApiCoreTypesProvider(data["provider"]) : undefined,
  };
}

/**
 * A room that is available for a potential meeting or has been booked for a
 * scheduled meeting. Next id: 4
 */
export interface AssistantApiCoreTypesCalendarEventRoom {
  /**
   * Room email that identifies the room and is used to book it.
   */
  email?: string;
  /**
   * Additional room details. Read-only, populated on request.
   */
  locationDetails?: AssistantApiCoreTypesCalendarEventRoomRoomLocationDetails;
  /**
   * Room name (ex: "MTV-PR55-5-A-Shadow 5K0 (13) GVC (No external guests)").
   */
  name?: string;
}

/**
 * Room location details. Read-only, populated on request. Next id: 8
 */
export interface AssistantApiCoreTypesCalendarEventRoomRoomLocationDetails {
  /**
   * Building where the room is (ex: "PR55").
   */
  building?: string;
  /**
   * City where the room is (ex: "MTV").
   */
  city?: string;
  /**
   * Floor where the room is (ex: "5").
   */
  floor?: string;
  /**
   * The latitude in degrees.
   */
  latitude?: number;
  /**
   * The longitude in degrees.
   */
  longitude?: number;
  /**
   * Section in the floor (ex: "A").
   */
  section?: string;
  /**
   * Room name (ex: "Shadow 5K0").
   */
  simpleName?: string;
}

/**
 * This empty type allows us to publish sensitive calendar events to
 * go/attentional-entities, while maintaining BUILD visibility protection for
 * their contents. The BUILD-visibility-protected extension to this message is
 * defined at
 * http://google3/assistant/verticals/calendar/proto/multi_account_calendar_event.proto
 * IMPORTANT: The definition of CalendarEventWrapper proto is being moved to
 * //assistant/api/core_types/governed/calendar_event_type.proto. All existing
 * references will be updated to point to the new location. If you are adding a
 * reference, use the new one instead.
 */
export interface AssistantApiCoreTypesCalendarEventWrapper {
}

/**
 * The cast app information of the provider.
 */
export interface AssistantApiCoreTypesCastAppInfo {
  /**
   * The cast app id. |cast_app_id| is the ID of the cast app used on the
   * current device and |content_app_id| is the ID of the app that provides the
   * actual content. For example, in a group playback, on a follower device, the
   * |cast_app_id| is the follower cast app ID and the |content_app_id| is the
   * leader cast app ID.
   */
  castAppId?: string;
  /**
   * The id of the cast app that provides the content in a group. The field
   * will always be filled. In the case of a group playback and the current
   * device is a follower, the |cast_app_id| has the ID of the follower app, and
   * |content_app_id| has ID of the actual content app. In all other cases,
   * |content_app_id| and |cast_app_id| will be the same.
   */
  contentAppId?: string;
}

/**
 * The ChromeOS app information of the provider. Next ID: 3
 */
export interface AssistantApiCoreTypesChromeOsAppInfo {
  /**
   * The localized app name.
   */
  localizedAppName?: string;
  /**
   * Unique package name that identifies a ChromeOS app of the provider.
   */
  packageName?: string;
}

/**
 * The third party provider information.
 */
export interface AssistantApiCoreTypesCloudProviderInfo {
  agentStyle?: AssistantApiCoreTypesCloudProviderInfoAgentStyle;
  /**
   * URL to a directory page about the third party agent in Assistant HQ. This
   * is a universal (https) URL that may be handled natively by clients to show
   * HQ or launch to the HQ directory web page.
   */
  directoryUrl?: string;
  /**
   * The logo url for the third party provider.
   */
  logoUrl?: string;
  /**
   * The user visible name of the cloud provider, which may be used for example
   * in the chat header during a conversation with the third party.
   */
  name?: string;
}

/**
 * The style customizations for the 3p agent.
 */
export interface AssistantApiCoreTypesCloudProviderInfoAgentStyle {
  /**
   * The background color of the agent. Used if no background image is
   * specified for the given display orientation, or if the provided background
   * image does not fit.
   */
  backgroundColor?: AssistantApiCoreTypesGovernedColor;
  headerTheme?:  | "DEFAULT" | "DARK" | "LIGHT";
  /**
   * URL for the background image of the agent on landscape display.
   */
  landscapeBackgroundImageUrl?: string;
  /**
   * URL for the image containing the 3p logo. This can include logomark and
   * logotype, or logotype only. If present, this can be used in place of the
   * square logo contained in the top level logo_url field in CloudProviderInfo.
   * See go/cards-logo-customization for details on applying this logo.
   */
  logoUrl?: string;
  /**
   * The color of the mask to apply to the background. See
   * go/aog-cards-background-mask for details on applying this mask.
   */
  maskColor?: AssistantApiCoreTypesGovernedColor;
  /**
   * URL for the background image of the agent on portrait display.
   */
  portraitBackgroundImageUrl?: string;
  /**
   * The primary color of the agent. Used by the client to style the header and
   * suggestion chips.
   */
  primaryColor?: AssistantApiCoreTypesGovernedColor;
}

/**
 * The identification information for third party devices that integrates with
 * the assistant. All of these fields will be populated by the third party when
 * the query is sent from the third party device. Next Id: 5
 */
export interface AssistantApiCoreTypesDeviceConfig {
  /**
   * Pantheon Project ID that uniquely identifies the consumer project ID.
   * Required
   */
  agentId?: string;
  /**
   * Unique identifier for the device. Example: DBCDW098234. Required
   */
  deviceId?: string;
}

/**
 * LINT.IfChange(DeviceId) Specifies identifier of a device AKA surface. Note
 * there may be multiple device ids for the same physical device E.g. Allo app
 * and Assistant app on Nexus. Note: DeviceId usage is complicated. Please do
 * not depend on it for surface specific logic. Please use
 * google3/assistant/api/capabilities.proto instead. IMPORTANT: When checking
 * for equality between two `DeviceId`s, you should always use an
 * `isSameDevice{As}` function to check for equality, as deep equality between
 * `DeviceId`'s is not guaranteed. * C++:
 * http://google3/assistant/assistant_server/util/device_id_util.cc;l=23;rcl=421295740
 * * Dart:
 * http://google3/assistant/context/util/lib/device_id.dart;l=26;rcl=442126145 *
 * Java:
 * http://google3/java/com/google/assistant/assistantserver/utils/DeviceIdHelper.java;l=9;rcl=390378522
 * See http://go/deviceid-equality for more details. Next ID: 14
 */
export interface AssistantApiCoreTypesDeviceId {
  /**
   * The client_instance_id on devices with GSA. See 'client_instance_field' in
   * go/androidids.
   */
  agsaClientInstanceId?: string;
  /**
   * Allo Id. Corresponds to the GBotRequest.Sender.sender. NOTE(dychen): This
   * may change to standard android/ios physical device ids in order to enable
   * shared data (e.g. installed app on physical device shared between Allo and
   * Opa apps on Nexus).
   */
  alloDeviceId?: string;
  /**
   * A unique device ID for Assistant devices as proposed by go/ocelot-team to
   * solve the device id fragmentation problem. The value of this id is the
   * HomeGraph id of the device. See go/ocelot-track-0-registry-design. New
   * surfaces should use the canonical_device_id instead of using other ids, and
   * the registration should utilize the DeviceDataLayer (go/ddl-v0). Please
   * contact the assistant-state-management@ team for guidance. Note: We didn't
   * reuse |home_graph_device_id| because in Assistant code base
   * |home_graph_device_id| is common to associate it with 3P devices. See
   * go/project-yellowstone for more context.
   */
  canonicalDeviceId?: string;
  /**
   * If set, indicates that the device is a cast device, and contains the UUID
   * of the cast device. Corresponds to the device_id field of the CastDevice
   * proto.
   */
  castDeviceId?: string;
  /**
   * DUSI (go/dusi) is used as the identifier here. This identifier is unique
   * to the user and device. This will help identify which device or application
   * the user's request originated from. This is not to be confused with the
   * client_instance_id that android devices provide. This is currently used by
   * surfaces that use the assistant-legacy-nexus and assistant-legacy-clockwork
   * pipelines. DUSI is created and set in S3. This field is only filled for
   * GAIA requests.
   */
  clientInstanceId?: string;
  /**
   * A device ID produced by a connected dock, which is registered in
   * HomeGraph.
   */
  connectedDockId?: string;
  /**
   * The unique DeviceConfig to the specific third party device. It is also
   * used by Android Auto Embedded first party device. See go/opa-ids.
   */
  deviceConfig?: AssistantApiCoreTypesDeviceConfig;
  /**
   * The device's surface type. This is the string version of surface_type. The
   * server should use the SurfaceType value derived from this string. If the
   * device_type isn't supported within the SurfaceType enum, it will be set as
   * UNKNOWN. Developers should use the enum in ServerParams instead of this
   * string.
   */
  deviceType?: string;
  /**
   * The unique device ID for HomeGraph devices. This is the HomeGraph ID,
   * created when the device is registered into HomeGraph. It is immutable for
   * the same device unless it is completely deleted and recreated. See
   * go/home-graph for details.
   */
  homeGraphDeviceId?: string;
  /**
   * The unique ID for libassistant based devices. See go/libassistant-id for
   * details.
   */
  libassistantDeviceId?: string;
  /**
   * If set, indicates that the device is participating the multi-hotword
   * arbitration and the id is an UUID to distinguish it from other devices. It
   * should also be consistent between requests from a single device within a
   * session (or short duration).
   */
  multiHotwordArbitrationDeviceId?: string;
  /**
   * The unique device ID for the Assistant App on iOS. See go/opa-ios-design
   * for details.
   */
  opaIosDeviceId?: string;
  /**
   * The unique ID of a Quartz device. See go/quartz-design-doc for more
   * details. Quartz ID is a hash of (android_id + gaia).
   */
  quartzDeviceId?: string;
}

/**
 * IMPORTANT: The definition of DeviceUserIdentity is being moved to
 * //assistant/api/core_types/governed/device_user_identity.proto. All existing
 * references will be updated to point to the new location. If you are adding a
 * reference, use the new DeviceUserIdentity instead of this one. //
 * LINT.IfChange
 */
export interface AssistantApiCoreTypesDeviceUserIdentity {
  /**
   * The identifier of the device.
   */
  deviceId?: AssistantApiCoreTypesDeviceId;
  /**
   * The identifier of the user.
   */
  gaiaId?: bigint;
}

function serializeAssistantApiCoreTypesDeviceUserIdentity(data: any): AssistantApiCoreTypesDeviceUserIdentity {
  return {
    ...data,
    gaiaId: data["gaiaId"] !== undefined ? String(data["gaiaId"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesDeviceUserIdentity(data: any): AssistantApiCoreTypesDeviceUserIdentity {
  return {
    ...data,
    gaiaId: data["gaiaId"] !== undefined ? BigInt(data["gaiaId"]) : undefined,
  };
}

/**
 * Represents a color in the RGBA color space. This message mirrors
 * google.type.Color.
 */
export interface AssistantApiCoreTypesGovernedColor {
  /**
   * The fraction of this color that should be applied to the pixel. That is,
   * the final pixel color is defined by the equation: pixel color = alpha *
   * (this color) + (1.0 - alpha) * (background color) This means that a value
   * of 1.0 corresponds to a solid color, whereas a value of 0.0 corresponds to
   * a completely transparent color. If omitted, this color object is to be
   * rendered as a solid color (as if the alpha value had been explicitly given
   * with a value of 1.0).
   */
  alpha?: number;
  /**
   * The amount of blue in the color as a value in the interval [0, 1].
   */
  blue?: number;
  /**
   * The amount of green in the color as a value in the interval [0, 1].
   */
  green?: number;
  /**
   * The amount of red in the color as a value in the interval [0, 1].
   */
  red?: number;
}

/**
 * Task metadata information describing the ringtone. Next id: 11
 */
export interface AssistantApiCoreTypesGovernedRingtoneTaskMetadata {
  /**
   * The category related with the ringtone. It's used to generate ringtone
   * related with the category if the entity_mid is not be populated. E.g. for
   * instrument, the ringtone may be piano sound.
   */
  category?:  | "UNKNOWN_CATEGORY" | "ANIMAL" | "CHARACTER" | "EMOTION" | "INSTRUMENT" | "MEDIA" | "SPORTS_EQUIPMENT" | "VEHICLE" | "ON_DEVICE" | "FUNTIME";
  characterAlarmMetadata?: AssistantApiCoreTypesGovernedRingtoneTaskMetadataCharacterAlarmMetadata;
  characterTag?: string;
  /**
   * The freebase mid of the entity related to the ringtone. It will be used to
   * generate the ringtone for the alarm or timer (with support for i18n). For
   * instance, for the "cat" mid, the related ringtone will be a cat sound in
   * some language, and for the "Beyonce" mid, the ringtone will be, e.g., a
   * playlist of Beyonce's best hits.
   */
  entityMid?: string;
  funtimeMetadata?: AssistantApiCoreTypesGovernedRingtoneTaskMetadataFuntimeMetadata;
  genMlAlarmMetadata?: AssistantApiCoreTypesGovernedRingtoneTaskMetadataGenMlAlarmMetadata;
  /**
   * Gentle wake information for this alarm.
   */
  gentleWakeInfo?: AssistantApiCoreTypesGovernedRingtoneTaskMetadataGentleWakeInfo;
  onDeviceAlarmMetadata?: AssistantApiCoreTypesGovernedRingtoneTaskMetadataOnDeviceAlarmMetadata;
  /**
   * Will be deprecated. Use OnDeviceAlarmMetadata.
   */
  onDeviceAlarmSound?:  | "DEFAULT" | "MELLOW" | "MODERN_TIMES" | "BEAUTIFUL_MIND" | "LITTLE_SUNSHINE" | "TOUCH_OF_ZEN" | "ABOUT_TIME" | "RANDOM" | "BOROBUDUR" | "PEBBLES" | "BRIGHT_MORNING" | "ACROSS_THE_VALLEY" | "MORNING_SONG" | "KYOTO" | "AWAKEN" | "CUCKOO" | "DIGITAL_BLAST" | "ACOUSTIC_SUNLIGHT" | "SUNRISE_BOSSA" | "CALM_GLOW" | "ANTIQUE_CLOCK" | "JUST_BIRDS" | "JUNGLE_AMBIENCE" | "QUAINT_VILLAGE" | "BUBBLY_BOSSA" | "ACOUSTIC_JAM" | "EUPHORIC";
  routineAlarmMetadata?: AssistantApiCoreTypesGovernedRingtoneTaskMetadataRoutineAlarmMetadata;
}

function serializeAssistantApiCoreTypesGovernedRingtoneTaskMetadata(data: any): AssistantApiCoreTypesGovernedRingtoneTaskMetadata {
  return {
    ...data,
    funtimeMetadata: data["funtimeMetadata"] !== undefined ? serializeAssistantApiCoreTypesGovernedRingtoneTaskMetadataFuntimeMetadata(data["funtimeMetadata"]) : undefined,
    gentleWakeInfo: data["gentleWakeInfo"] !== undefined ? serializeAssistantApiCoreTypesGovernedRingtoneTaskMetadataGentleWakeInfo(data["gentleWakeInfo"]) : undefined,
    onDeviceAlarmMetadata: data["onDeviceAlarmMetadata"] !== undefined ? serializeAssistantApiCoreTypesGovernedRingtoneTaskMetadataOnDeviceAlarmMetadata(data["onDeviceAlarmMetadata"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesGovernedRingtoneTaskMetadata(data: any): AssistantApiCoreTypesGovernedRingtoneTaskMetadata {
  return {
    ...data,
    funtimeMetadata: data["funtimeMetadata"] !== undefined ? deserializeAssistantApiCoreTypesGovernedRingtoneTaskMetadataFuntimeMetadata(data["funtimeMetadata"]) : undefined,
    gentleWakeInfo: data["gentleWakeInfo"] !== undefined ? deserializeAssistantApiCoreTypesGovernedRingtoneTaskMetadataGentleWakeInfo(data["gentleWakeInfo"]) : undefined,
    onDeviceAlarmMetadata: data["onDeviceAlarmMetadata"] !== undefined ? deserializeAssistantApiCoreTypesGovernedRingtoneTaskMetadataOnDeviceAlarmMetadata(data["onDeviceAlarmMetadata"]) : undefined,
  };
}

export interface AssistantApiCoreTypesGovernedRingtoneTaskMetadataCharacterAlarmMetadata {
  /**
   * For character alarm, the media resources are provided through AOG apps.
   * During alarm trigger phase, aog apps with the specified agent_ids are used
   * to get the media resources. Multiple "AoG agents" can satisfy a
   * character_tag. So the user will select the agents they want at alarm
   * creation time. The chosen agents will be recorded so that the resources
   * only from those agents will be used at trigger time. The number of selected
   * agent_ids will not exceed 3. See go/character-alarm-aog.
   */
  agentIds?: string[];
  /**
   * The Character Alarm tag. Tags are needed to identify the theme of the
   * alarm. For example, if the tag is 'astronaut', astronaut based audio is
   * played during alarm ring. Note : We have made it repeated so that the user
   * can choose multiple character alarm themes at one go. At present, the user
   * is allowed to choose only one theme during alarm creation.
   */
  characterTags?: string[];
  /**
   * Icons urls corresponding to a character. Note : We have made it repeated
   * so that we can show different images when the alarm rings. At present, we
   * only support only one image.
   */
  iconUrls?: string[];
}

/**
 * Used to make timers and alarms more delightful. See go/funtime-engdesign for
 * more details.
 */
export interface AssistantApiCoreTypesGovernedRingtoneTaskMetadataFuntimeMetadata {
  /**
   * For FunTime alarms and timers, the media resources are provided through
   * AOG apps during their ringtone. Multiple AoG agents can satisfy a label. So
   * a random agent will be chosen from those that are supplied. See
   * go/funtime-engdesign.
   */
  agentIds?: string[];
  /**
   * These bytes may represent the blob of the Rive animation that we pass to
   * the Opal App. We will deprecate this field if we figure out a solution to
   * load the animation from the web.
   */
  animationBlob?: Uint8Array;
  /**
   * Url for Rive animation that is brought up on ring. Rive is a lightweight
   * animation library that is compatible with Flutter on Opal. See
   * https://rive.app/.
   */
  animationUrl?: string;
  /**
   * The url used to load the image that is at the center of the timer during
   * timer countdown visuals.
   */
  timerHeroUrl?: string;
  /**
   * This is used to call S3 to realize the TTS. Is in the form of bytes
   * because of a circular dependency issue in libassistant protos. It is a
   * serialized proto of type speech.s3.TtsServiceRequest.
   */
  ttsServiceRequestBytes?: Uint8Array;
}

function serializeAssistantApiCoreTypesGovernedRingtoneTaskMetadataFuntimeMetadata(data: any): AssistantApiCoreTypesGovernedRingtoneTaskMetadataFuntimeMetadata {
  return {
    ...data,
    animationBlob: data["animationBlob"] !== undefined ? encodeBase64(data["animationBlob"]) : undefined,
    ttsServiceRequestBytes: data["ttsServiceRequestBytes"] !== undefined ? encodeBase64(data["ttsServiceRequestBytes"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesGovernedRingtoneTaskMetadataFuntimeMetadata(data: any): AssistantApiCoreTypesGovernedRingtoneTaskMetadataFuntimeMetadata {
  return {
    ...data,
    animationBlob: data["animationBlob"] !== undefined ? decodeBase64(data["animationBlob"] as string) : undefined,
    ttsServiceRequestBytes: data["ttsServiceRequestBytes"] !== undefined ? decodeBase64(data["ttsServiceRequestBytes"] as string) : undefined,
  };
}

/**
 * Metadata for machine learning generated audio samples. This will be similar
 * to character alarms, Category will be set MEDIA but this metadata field will
 * be used to identify the ringtone type on surface.
 * (go/magenta-alarm-ringtones).
 */
export interface AssistantApiCoreTypesGovernedRingtoneTaskMetadataGenMlAlarmMetadata {
  isEnabled?: boolean;
  /**
   * Label for the generated ringtone.
   */
  ringtoneLabel?: string;
}

/**
 * Gentle wake actions like slowly brightening the room/device screen leading
 * up to the alarm firing (go/cube-gentle-wake-up).
 */
export interface AssistantApiCoreTypesGovernedRingtoneTaskMetadataGentleWakeInfo {
  /**
   * Specifies how long the effect lasts. Allowed for effect to last after the
   * alarm has started ringing. If unset or negative or 0, effect is assumed to
   * last until alarm trigger time.
   */
  effectDurationMs?: bigint;
  /**
   * Indicates if gentle wake action is to be performed before this alarm
   * fires. This is enabled only if the device supports sunrise alarm
   * capability. http://cs/symbol:assistant.api.SunriseFeaturesSupport
   */
  isEnabled?: boolean;
  /**
   * Specifies how long before the alarm fire time, the wakeup effect will
   * start. ALWAYS POSITIVE.
   */
  startTimedeltaMs?: bigint;
}

function serializeAssistantApiCoreTypesGovernedRingtoneTaskMetadataGentleWakeInfo(data: any): AssistantApiCoreTypesGovernedRingtoneTaskMetadataGentleWakeInfo {
  return {
    ...data,
    effectDurationMs: data["effectDurationMs"] !== undefined ? String(data["effectDurationMs"]) : undefined,
    startTimedeltaMs: data["startTimedeltaMs"] !== undefined ? String(data["startTimedeltaMs"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesGovernedRingtoneTaskMetadataGentleWakeInfo(data: any): AssistantApiCoreTypesGovernedRingtoneTaskMetadataGentleWakeInfo {
  return {
    ...data,
    effectDurationMs: data["effectDurationMs"] !== undefined ? BigInt(data["effectDurationMs"]) : undefined,
    startTimedeltaMs: data["startTimedeltaMs"] !== undefined ? BigInt(data["startTimedeltaMs"]) : undefined,
  };
}

/**
 * This describes the alarm sound resource enum and the alarm sound label for
 * the on device alarm sound. On-device ringtones are product specific, hence
 * Opal/UI layer will be responsible for populating this metadata at
 * creation/edit. The enum map will be used to convert to an internal resource
 * id used by libassistant for accessing the asset which are not exposed to UI.
 */
export interface AssistantApiCoreTypesGovernedRingtoneTaskMetadataOnDeviceAlarmMetadata {
  /**
   * Opal/UI layer will set this bit based on the user selection.
   */
  onDeviceAlarmSound?:  | "DEFAULT" | "MELLOW" | "MODERN_TIMES" | "BEAUTIFUL_MIND" | "LITTLE_SUNSHINE" | "TOUCH_OF_ZEN" | "ABOUT_TIME" | "RANDOM" | "BOROBUDUR" | "PEBBLES" | "BRIGHT_MORNING" | "ACROSS_THE_VALLEY" | "MORNING_SONG" | "KYOTO" | "AWAKEN" | "CUCKOO" | "DIGITAL_BLAST" | "ACOUSTIC_SUNLIGHT" | "SUNRISE_BOSSA" | "CALM_GLOW" | "ANTIQUE_CLOCK" | "JUST_BIRDS" | "JUNGLE_AMBIENCE" | "QUAINT_VILLAGE" | "BUBBLY_BOSSA" | "ACOUSTIC_JAM" | "EUPHORIC";
  /**
   * A string label to identify the alarm sound name. Opal/UI layer will set
   * this as per product definition. This will be used to display the name of
   * the selected ringtone.
   */
  onDeviceAlarmSoundLabel?: string;
  /**
   * This is used to call S3 to realize the TTS. Is in the form of bytes
   * because of a circular dependency issue in libassistant protos. It is a
   * serialized proto of type speech.s3.TtsServiceRequest. This request will
   * contain an ssml with the url to the ringtone files hosted on gstatic.
   */
  ttsServiceRequestBytes?: Uint8Array;
}

function serializeAssistantApiCoreTypesGovernedRingtoneTaskMetadataOnDeviceAlarmMetadata(data: any): AssistantApiCoreTypesGovernedRingtoneTaskMetadataOnDeviceAlarmMetadata {
  return {
    ...data,
    ttsServiceRequestBytes: data["ttsServiceRequestBytes"] !== undefined ? encodeBase64(data["ttsServiceRequestBytes"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesGovernedRingtoneTaskMetadataOnDeviceAlarmMetadata(data: any): AssistantApiCoreTypesGovernedRingtoneTaskMetadataOnDeviceAlarmMetadata {
  return {
    ...data,
    ttsServiceRequestBytes: data["ttsServiceRequestBytes"] !== undefined ? decodeBase64(data["ttsServiceRequestBytes"] as string) : undefined,
  };
}

export interface AssistantApiCoreTypesGovernedRingtoneTaskMetadataRoutineAlarmMetadata {
  /**
   * The unique id for each routine. When the alrm is dismissed, it will
   * trigger the routine of the routine alarm's creator if feasible.
   */
  routineId?: string;
}

/**
 * The Home app information of the provider. Next ID: 3
 */
export interface AssistantApiCoreTypesHomeAppInfo {
  /**
   * The localized app name.
   */
  localizedAppName?: string;
  /**
   * Unique package name that identifies a Home app of the provider.
   */
  packageName?: string;
}

/**
 * An image represents the data about an image or a photo. IMPORTANT: The
 * definition of the Image message is being moved to
 * //assistant/api/core_types/governed/image_type.proto. All existing references
 * will be updated to point to the new location. If you are adding a reference,
 * use the new Image message instead of this one. LINT.IfChange NextId: 13
 */
export interface AssistantApiCoreTypesImage {
  /**
   * A text description of the image to be used for accessibility, e.g. screen
   * readers.
   */
  accessibilityText?: string;
  /**
   * App identifier. This field is specific to mobile surfaces and stands for
   * app package name for Android surface, and app bundle identifier for iOS. In
   * case identifier is specified but invalid, some default icon will be used,
   * e.g. PackageManager.getDefaultActivityIcon() for Android. If you want to
   * show image for AGSA versions which don't support this field, you can
   * specify source_url as backup.
   */
  appIconIdentifier?: string;
  /**
   * This is the image that is displayed as the badge on the main image.
   */
  badgeImage?: AssistantApiCoreTypesImage;
  /**
   * Content of the image in bytes.
   */
  content?: Uint8Array;
  height?: number;
  /**
   * Indicate the data source where the image is fetched.
   */
  imageSource?:  | "UNKNOWN" | "PLACEHOLDER" | "VISUAL_DICT" | "LAVD" | "VISUAL_DICT_DEFAULT_LOCALE";
  /**
   * Content of image in form of JSON representation.
   */
  jsonContent?: string;
  /**
   * Text used to generate a letter drawable (a letter icon with color). It
   * will be the default icon if the source_url is empty or cannot be rendered.
   */
  letterDrawableText?: string;
  /**
   * Url of the image provider, which is the website containing the image. For
   * example, https://www.agentx.com.
   */
  providerUrl?: string;
  /**
   * The source url of the image. For example, https://www.agentx.com/logo.png
   */
  sourceUrl?: string;
  /**
   * Type of the source url.
   */
  sourceUrlType?:  | "DEFAULT_URL_TYPE" | "LOTTIE" | "DUO_CLIENT" | "CONTACT_ID";
  /**
   * The width and height of the image in pixels.
   */
  width?: number;
}

function serializeAssistantApiCoreTypesImage(data: any): AssistantApiCoreTypesImage {
  return {
    ...data,
    badgeImage: data["badgeImage"] !== undefined ? serializeAssistantApiCoreTypesImage(data["badgeImage"]) : undefined,
    content: data["content"] !== undefined ? encodeBase64(data["content"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesImage(data: any): AssistantApiCoreTypesImage {
  return {
    ...data,
    badgeImage: data["badgeImage"] !== undefined ? deserializeAssistantApiCoreTypesImage(data["badgeImage"]) : undefined,
    content: data["content"] !== undefined ? decodeBase64(data["content"] as string) : undefined,
  };
}

/**
 * Info for targeting a feature provided directly by the Assistant surface
 * itself. i.e Could be pointing to AGSA audio player for AUDIO_PLAYER on AGSA.
 */
export interface AssistantApiCoreTypesInternalProviderInfo {
  /**
   * Specifying which type of internal provider.
   */
  type?:  | "UNKNOWN_INTERNAL_PROVIDER_TYPE" | "AUDIO_PLAYER" | "AUDIO_PLAYER_V2" | "MEDIA_PLAYER" | "MEDIA_PLAYER_IOS" | "AUDIO_ONLY_PLAYER" | "NARRATED_WEB_MEDIA_PLAYER" | "LIBASSISTANT_MEDIA_PLAYER" | "LENS_PLAYER" | "NEWS_PLAYER";
}

/**
 * The iOS app information of the provider. Next ID: 4
 */
export interface AssistantApiCoreTypesIosAppInfo {
  /**
   * Bundle identifier that identifies an iOS app of the provider.
   */
  bundleIdentifier?: string;
  /**
   * The localized app name.
   */
  localizedAppName?: string;
  /**
   * A URL to open the provider's app.
   */
  openAppUrl?: string;
}

/**
 * The KaiOS app information of the provider. Next ID: 4
 */
export interface AssistantApiCoreTypesKaiOsAppInfo {
  /**
   * The localized app name.
   */
  localizedAppName?: string;
  /**
   * A URL to open the provider's app.
   */
  openAppUrl?: string;
  /**
   * Unique package name that identifies a KaiOS app of the provider.
   */
  packageName?: string;
}

/**
 * Geographic coordinate information for location.
 */
export interface AssistantApiCoreTypesLocationCoordinates {
  /**
   * The accuracy of the coordinates in meters.
   */
  accuracyMeters?: number;
  /**
   * Latitude degrees.
   */
  latDegrees?: number;
  /**
   * Longitude degrees.
   */
  lngDegrees?: number;
}

/**
 * This proto captures the contents of a messaging app notification that is
 * typically part of a conversation thread. Next Id: 20
 */
export interface AssistantApiCoreTypesMessageNotification {
  /**
   * App name of the message notification, e.g. Hangouts.
   */
  appName?: string;
  /**
   * The key used to group this notification into a cluster.
   */
  bundleId?: string;
  /**
   * Uri for the attachment (image, audio, video etc.).
   */
  dataUri?: string;
  /**
   * The group key of a proactive notification. Details in
   * assistant.api.client_op.NotificationArgs.grouping_key.
   */
  groupingKey?: string;
  /**
   * Name of the group associated with the message notification. This field is
   * set iff this is a group message.
   */
  groupName?: string;
  /**
   * Index of the message notification.
   */
  index?: number;
  /**
   * Boolean indicating if the mark_as_read action is available for this
   * message.
   */
  markAsReadActionAvailable?: boolean;
  /**
   * Length of the message/notification content in characters. Note: We can't
   * send the full content because of privacy restriction, preventing sending
   * client content to our backends. Concatenated message_length of all
   * notification_entries.
   */
  messageLength?: number;
  messageRecipientType?:  | "UNKNOWN" | "INDIVIDUAL" | "GROUP";
  /**
   * Mime type of the data_uri. e.g. 'audio/wav', 'video/mp4', 'image/png'.
   */
  mimeType?: string;
  notificationEntries?: AssistantApiCoreTypesMessageNotificationNotificationEntry[];
  /**
   * On-device cache key for notification icon.
   */
  notificationIconKey?: string;
  /**
   * String key of the notification. It is the key from original
   * StatusBarNotification received from Android OS. It is used to identify the
   * original notification to send a reply.
   */
  notificationKey?: string;
  /**
   * The opaque_token of a proactive notification. Details in
   * assistant.api.client_op.NotificationArgs.opaque_token.
   */
  opaqueToken?: Uint8Array;
  /**
   * App pkg of the message notification, e.g. "com.google.android.talk".
   */
  packageName?: string;
  /**
   * Timestamp of the last notification's post time.
   */
  postTime?: bigint;
  /**
   * Boolean indicating if the reply action is available for this message.
   */
  replyActionAvailable?: boolean;
  sender?: AssistantApiCoreTypesMessageNotificationPerson;
  /**
   * Sender's name of the message notification, e.g. Elsa. Last sender name in
   * case of a group conversation.
   */
  senderName?: string;
}

function serializeAssistantApiCoreTypesMessageNotification(data: any): AssistantApiCoreTypesMessageNotification {
  return {
    ...data,
    notificationEntries: data["notificationEntries"] !== undefined ? data["notificationEntries"].map((item: any) => (serializeAssistantApiCoreTypesMessageNotificationNotificationEntry(item))) : undefined,
    opaqueToken: data["opaqueToken"] !== undefined ? encodeBase64(data["opaqueToken"]) : undefined,
    postTime: data["postTime"] !== undefined ? String(data["postTime"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesMessageNotification(data: any): AssistantApiCoreTypesMessageNotification {
  return {
    ...data,
    notificationEntries: data["notificationEntries"] !== undefined ? data["notificationEntries"].map((item: any) => (deserializeAssistantApiCoreTypesMessageNotificationNotificationEntry(item))) : undefined,
    opaqueToken: data["opaqueToken"] !== undefined ? decodeBase64(data["opaqueToken"] as string) : undefined,
    postTime: data["postTime"] !== undefined ? BigInt(data["postTime"]) : undefined,
  };
}

/**
 * Structure of each notification in the MessageNotification Bundle. Attribute
 * sender_name could be different in case of group messages. Next Id: 6
 */
export interface AssistantApiCoreTypesMessageNotificationNotificationEntry {
  /**
   * Uri for the attachment (image, audio, video etc.).
   */
  dataUri?: string;
  /**
   * Content of the message body in the notification.
   */
  messageBody?: string;
  /**
   * Mime type of the data_uri. e.g. 'audio/wav', 'video/mp4', 'image/png'.
   */
  mimeType?: string;
  /**
   * Timestamp of the notification's post time.
   */
  postTime?: Date;
  /**
   * Sender of the message notification.
   */
  sender?: AssistantApiCoreTypesMessageNotificationPerson;
}

function serializeAssistantApiCoreTypesMessageNotificationNotificationEntry(data: any): AssistantApiCoreTypesMessageNotificationNotificationEntry {
  return {
    ...data,
    postTime: data["postTime"] !== undefined ? data["postTime"].toISOString() : undefined,
  };
}

function deserializeAssistantApiCoreTypesMessageNotificationNotificationEntry(data: any): AssistantApiCoreTypesMessageNotificationNotificationEntry {
  return {
    ...data,
    postTime: data["postTime"] !== undefined ? new Date(data["postTime"]) : undefined,
  };
}

/**
 * Mirrors part of https://developer.android.com/reference/android/app/Person
 * Next Id: 4
 */
export interface AssistantApiCoreTypesMessageNotificationPerson {
  isImportant?: boolean;
  key?: string;
  name?: string;
}

/**
 * Provider. Like, Spotify or iHeartRadio. Next ID: 13
 */
export interface AssistantApiCoreTypesProvider {
  /**
   * The android app information of the provider.
   */
  androidAppInfo?: AssistantApiCoreTypesAndroidAppInfo;
  /**
   * The cast app information of the provider.
   */
  castAppInfo?: AssistantApiCoreTypesCastAppInfo;
  /**
   * The ChromeOS app information of the provider.
   */
  chromeosAppInfo?: AssistantApiCoreTypesChromeOsAppInfo;
  /**
   * The third party provider information.
   */
  cloudProviderInfo?: AssistantApiCoreTypesCloudProviderInfo;
  /**
   * A URL to fallback to if app can not be opened.
   */
  fallbackUrl?: string;
  homeAppInfo?: AssistantApiCoreTypesHomeAppInfo;
  /**
   * Public URL pointing to an icon image for the provider. e.g.
   * https://lh3.googleusercontent.com/UrY7BAZ-XfXGpfkeWg0zCCeo-7ras4DCoRalC_WXXWTK9q5b0Iw7B0YQMsVxZaNB7DM
   */
  iconImageUrl?: string;
  /**
   * The internal assistant provider information.
   */
  internalProviderInfo?: AssistantApiCoreTypesInternalProviderInfo;
  /**
   * The iOS app information of the provider.
   */
  iosAppInfo?: AssistantApiCoreTypesIosAppInfo;
  /**
   * The KaiOS app information of the provider.
   */
  kaiosAppInfo?: AssistantApiCoreTypesKaiOsAppInfo;
  /**
   * The sip information of the provider.
   */
  sipProviderInfo?: AssistantApiCoreTypesSipProviderInfo;
  /**
   * The web provider information.
   */
  webProviderInfo?: AssistantApiCoreTypesWebProviderInfo;
}

function serializeAssistantApiCoreTypesProvider(data: any): AssistantApiCoreTypesProvider {
  return {
    ...data,
    androidAppInfo: data["androidAppInfo"] !== undefined ? serializeAssistantApiCoreTypesAndroidAppInfo(data["androidAppInfo"]) : undefined,
    webProviderInfo: data["webProviderInfo"] !== undefined ? serializeAssistantApiCoreTypesWebProviderInfo(data["webProviderInfo"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesProvider(data: any): AssistantApiCoreTypesProvider {
  return {
    ...data,
    androidAppInfo: data["androidAppInfo"] !== undefined ? deserializeAssistantApiCoreTypesAndroidAppInfo(data["androidAppInfo"]) : undefined,
    webProviderInfo: data["webProviderInfo"] !== undefined ? deserializeAssistantApiCoreTypesWebProviderInfo(data["webProviderInfo"]) : undefined,
  };
}

/**
 * ProviderDelta. The incremental change, e.g. installation or deletion for
 * Spotify or iHeartRadio. Currently it is for Android only. A few
 * considerations for edge cases: - If the app being deleted is not found from
 * Footprints, it is ignored. - For Footprint upload through Geller, the gPRC
 * response is available for client to retry in the next upload if the upload
 * fails. - For Assistant Request, there is no upload status similar to the
 * current AppCapabilities. Next ID: 4
 */
export interface AssistantApiCoreTypesProviderDelta {
  /**
   * The android app information of the provider.
   */
  androidAppInfoDelta?: AssistantApiCoreTypesAndroidAppInfoDelta;
  /**
   * A URL to fallback to if app can not be opened.
   */
  fallbackUrl?: string;
  /**
   * Public URL pointing to an icon image for the provider. e.g.
   * https://lh3.googleusercontent.com/UrY7BAZ-XfXGpfkeWg0zCCeo-7ras4DCoRalC_WXXWTK9q5b0Iw7B0YQMsVxZaNB7DM
   */
  iconImageUrl?: string;
}

function serializeAssistantApiCoreTypesProviderDelta(data: any): AssistantApiCoreTypesProviderDelta {
  return {
    ...data,
    androidAppInfoDelta: data["androidAppInfoDelta"] !== undefined ? serializeAssistantApiCoreTypesAndroidAppInfoDelta(data["androidAppInfoDelta"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesProviderDelta(data: any): AssistantApiCoreTypesProviderDelta {
  return {
    ...data,
    androidAppInfoDelta: data["androidAppInfoDelta"] !== undefined ? deserializeAssistantApiCoreTypesAndroidAppInfoDelta(data["androidAppInfoDelta"]) : undefined,
  };
}

/**
 * Session Initiation Protocol (SIP) information for providers that use SIP to
 * initiate multimedia communication sessions, like Google Voice and Fi.
 * https://en.wikipedia.org/wiki/Session_Initiation_Protocol
 */
export interface AssistantApiCoreTypesSipProviderInfo {
  /**
   * The providers id (MID) which is the primary identifier for a call provider
   * within the Assistant. A MID, or machine identifier, is a unique identifier
   * issued by Knowledge Graph for all entities contained in it's graph.
   */
  providerId?: string;
  /**
   * Calling realm to be use for each call. i.e. For anonymous, this would be
   * set to anonymous.chirp.google.com
   */
  realm?: string;
  /**
   * If true, client should use the Birdsong TaCL API for this call. Uses the
   * VoiceCallManager API by default. For more details:
   * go/birdsong-migration-google-home
   */
  useBirdsongTacl?: boolean;
}

/**
 * The set of information that helps the server identify the surface. This
 * replaces the User-Agent string within the Assistant Server. Note: The
 * SurfaceIdentity proto should only be used to derive the capabilities of a
 * surface. It should not be accessed outside of the CapabilityBuilder or
 * CapabilityChecker. NEXT ID: 5 IMPORTANT: The definitions of the
 * SurfaceIdentity and SurfaceVersion protos are being moved to
 * //assistant/api/core_types/governed/surface_identity.proto All existing
 * references will be updated to point to the new location. If you are adding a
 * reference, use the new SurfaceIdentity and SurfaceVersion protos instead of
 * the protos defined here. LINT.IfChange
 */
export interface AssistantApiCoreTypesSurfaceIdentity {
  /**
   * The identifier of the device.
   */
  deviceId?: AssistantApiCoreTypesDeviceId;
  /**
   * The device's surface type. The types are defined at
   * google3/assistant/api/core_types/surfaces.gcl. NOTE: This is the new field
   * that is going to replace the `surface_type_string` field above. For more
   * details please refer to go/ontologicalize-surface-type.
   */
  surfaceType?:  | "UNKNOWN_TYPE" | "ACCL" | "AGSA" | "ANDROID" | "ANDROID_AUTO" | "ANDROID_LITE" | "ANDROID_PHONE" | "ANDROID_SCREENLESS" | "ANDROID_SMART_DISPLAY" | "ANDROID_TABLET" | "ANDROID_THINGS" | "ANDROID_THINGS_CUBE" | "ANDROID_THINGS_JASPER" | "ANDROID_TV" | "ANDROID_WEAR" | "ASSISTANT_KIT" | "ASSISTANT_SDK" | "AUTO" | "CAST_OS" | "CHROME_OS" | "CHROMECAST_MANHATTAN" | "CLOUD_DEVICE" | "CROS" | "FITBIT_OS_WATCH" | "FITBIT_OS_WATCH_ANDROID" | "FITBIT_OS_WATCH_IOS" | "GOOGLE_HOME" | "HEADPHONE" | "HEADPHONE_ANDROID" | "HEADPHONE_IOS" | "IOPA" | "IOS" | "IOS_SCREENLESS" | "IPAD" | "IPHONE" | "KAI_OS" | "KAI_OS_AMA" | "LIBASSISTANT" | "PHONE" | "PIXEL" | "PIXEL5" | "PIXEL6" | "PIXEL7" | "PIXEL_BUDS" | "PIXEL_TABLET" | "PIXEL_TABLET_HUB_MODE" | "PIXEL_TABLET_PERSONAL_MODE" | "PIXEL_WATCH" | "SCREENLESS" | "SMART_DISPLAY" | "SPEAKER" | "TABLET" | "TELEPHONE" | "THING" | "WATCH" | "WEAR_OS" | "WEAR_OS_WATCH";
  /**
   * The device's surface type. This is the string version of the
   * assistant.api.core_types.SurfaceType enum. The server should not use this
   * field, rather it should use the SurfaceType value derived from this string.
   */
  surfaceTypeString?: string;
  /**
   * The version of the surface/client. This is different from the Conversation
   * protocol version.
   */
  surfaceVersion?: AssistantApiCoreTypesSurfaceVersion;
}

/**
 * Specifies the types of device surfaces. LINT.IfChange When adding new
 * surface types make sure that My Activity
 * (https://myactivity.google.com/product/assistant) will correctly render by
 * adding your enum to http://cs/symbol:GetAssistSurfaceName%20f:%5C.cc$ If your
 * type doesn't fit in to any of the existing surfaces messages, add a new
 * message in
 * http://google3/personalization/footprints/boq/uservisible/events/intl/smh_frontend_messages.h.
 */
export interface AssistantApiCoreTypesSurfaceType {
  type?:  | "UNKNOWN" | "ANDROID_ALLO" | "ANDROID_AUTO" | "ANDROID_THINGS_CUBE" | "ANDROID_THINGS_JASPER" | "ANDROID_TV" | "ANDROID_TV_KIDS" | "ANDROID_WEAR" | "AR_GLASSES" | "ASSISTANT_SDK" | "AUDIOWEAR" | "BUBBLE_CHARACTERS_IOS" | "CAPABILITY_BASED_SURFACE" | "CHROMECAST_ASSISTANT" | "CHROMECAST_MANHATTAN" | "CHROMECAST_SEARCH" | "CLOUD_DEVICE" | "COMPANION_SCREEN" | "DYNAMITE_WEB" | "ENSEMBLE" | "EYESFREE_AGSA" | "EYESFREE_GMM" | "GBOARD" | "GLASS" | "GOOGLE_HOME" | "HANGOUTS_CHATBOT" | "IOS_ALLO" | "IOS_GSA" | "IOS_WEAR" | "LIBASSISTANT" | "LINE_CHATBOT" | "MULTIMODAL_AGSA" | "NON_ASSISTANT_SURFACE" | "OPA_AGSA" | "OPA_AGSA_CHROME_OS" | "OPA_ANDROID_AUTO" | "OPA_ANDROID_LITE" | "OPA_ANDROID_SCREENLESS" | "OPA_ANDROID_SMART_DISPLAY" | "OPA_ANDROID_TABLET" | "OPA_CROS" | "OPA_GACS" | "OPA_IOS" | "OPA_IOS_SCREENLESS" | "OPA_KAIOS" | "OPA_MOBILE_WEB" | "RTOS_PHONE" | "SMS_CHATBOT" | "TELEGRAM_CHATBOT" | "TELEPHONE_ASSISTANT" | "VERILY_ONDUO" | "YOUTUBE_APP" | "AGSA_BISTO_FOR_EVAL" | "COGSWORTH_FOR_EVAL" | "LOCKHART_MIC_FOR_EVAL" | "OPA_ANDROID_AUTO_EMBEDDED_FAKE" | "SPARK" | "WALLE" | "UNIT_TESTING";
}

/**
 * The version of the surface/client. New surfaces are encouraged to only use
 * the “major” field to keep track of version number. The “minor” field may be
 * used for surfaces that rely on both the “major” and “minor” fields to define
 * their version.
 */
export interface AssistantApiCoreTypesSurfaceVersion {
  major?: number;
  minor?: number;
}

/**
 * The web information of the provider. Next ID: 5
 */
export interface AssistantApiCoreTypesWebProviderInfo {
  /**
   * Serialized storage (context) persisted and retrieved for the app and home.
   */
  homeStorage?: string;
  /**
   * The localized app name.
   */
  localizedAppName?: string;
  /**
   * A URL to open the provider's app.
   */
  openAppUrl?: string;
  /**
   * Info about 3P Custom NLU used in this web provider. TODO(b/321644453)
   * remove when QRewrite is able to call SERoot.
   */
  thirdPartyCustomNluInfo?: AssistantApiCoreTypesWebProviderInfoThirdPartyCustomNluInfo;
}

function serializeAssistantApiCoreTypesWebProviderInfo(data: any): AssistantApiCoreTypesWebProviderInfo {
  return {
    ...data,
    thirdPartyCustomNluInfo: data["thirdPartyCustomNluInfo"] !== undefined ? serializeAssistantApiCoreTypesWebProviderInfoThirdPartyCustomNluInfo(data["thirdPartyCustomNluInfo"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesWebProviderInfo(data: any): AssistantApiCoreTypesWebProviderInfo {
  return {
    ...data,
    thirdPartyCustomNluInfo: data["thirdPartyCustomNluInfo"] !== undefined ? deserializeAssistantApiCoreTypesWebProviderInfoThirdPartyCustomNluInfo(data["thirdPartyCustomNluInfo"]) : undefined,
  };
}

export interface AssistantApiCoreTypesWebProviderInfoThirdPartyCustomNluInfo {
  /**
   * The locale of this agent version, represented by BCP-47 language strings,
   * such as "en", "en-US", "fr", "fr-CA", "sr-Latn", "zh-Hans-CN", etc.
   */
  locale?: string;
  /**
   * Unique internal identifier of 3P Custom NLU agent. UUID.
   */
  nluAgentId?: string;
  /**
   * Identifies the 3P Custom NLU agent version.
   */
  nluAgentVersion?: bigint;
}

function serializeAssistantApiCoreTypesWebProviderInfoThirdPartyCustomNluInfo(data: any): AssistantApiCoreTypesWebProviderInfoThirdPartyCustomNluInfo {
  return {
    ...data,
    nluAgentVersion: data["nluAgentVersion"] !== undefined ? String(data["nluAgentVersion"]) : undefined,
  };
}

function deserializeAssistantApiCoreTypesWebProviderInfoThirdPartyCustomNluInfo(data: any): AssistantApiCoreTypesWebProviderInfoThirdPartyCustomNluInfo {
  return {
    ...data,
    nluAgentVersion: data["nluAgentVersion"] !== undefined ? BigInt(data["nluAgentVersion"]) : undefined,
  };
}

export interface AssistantApiCrossDeviceExecutionCapability {
  /**
   * Whether the device has torus/usonia capabililities enabled or not.
   */
  localConnectivityEnabled?: boolean;
  /**
   * Whether the device supports cast media originated from a remote device to
   * be executed through local execution and can upload results asynchronously.
   * Needs to be checked before sending remote media initiation through local
   * channel since it needs an async result upload path.
   */
  remoteCastMediaEnabled?: boolean;
}

/**
 * A Gregorian calendar date. IMPORTANT: The definition of Date proto is being
 * moved to //assistant/api/core_types/governed/datetime_type.proto. All
 * existing references will be updated to point to the new location. If you are
 * adding a reference, use the new one instead.
 */
export interface AssistantApiDate {
  /**
   * The day, in 1...31.
   */
  day?: number;
  /**
   * The month, in 1...12.
   */
  month?: number;
  /**
   * The year, e.g. 2016.
   */
  year?: number;
}

/**
 * A date-time specification, combining a date and civil time (relative to a
 * given timezone). IMPORTANT: The definition of DateTime proto is being moved
 * to //assistant/api/core_types/governed/datetime_type.proto. All existing
 * references will be updated to point to the new location. If you are adding a
 * reference, use the new one instead.
 */
export interface AssistantApiDateTime {
  /**
   * A Gregorian calendar date.
   */
  date?: AssistantApiDate;
  /**
   * A civil time relative to a timezone.
   */
  timeOfDay?: AssistantApiTimeOfDay;
  /**
   * A time zone in IANA format.
   */
  timeZone?: AssistantApiTimeZone;
}

/**
 * This message describes roughly what a surface is capable of doing and
 * metadata around those capabilities. These capabilities are determined based
 * on: - device hardware - software - status (e.g. volume level, battery
 * percentage) These capabilities refer to the surface and not the physical
 * device. The list of supported surfaces can be found in the
 * assistant.api.core_types.SurfaceType enum. A surface's capabilities can
 * differ from the device's. An example would be ANDROID_ALLO running on Pixel.
 * Allo does not support AudioInput while the Pixel does. In this case,
 * audio_input will be set to false for Assistant Allo requests while it might
 * be set to true for OPA_NEXUS requests. Next ID: 35
 */
export interface AssistantApiDeviceCapabilities {
  /**
   * Capabilites related to Android intent support.
   */
  androidIntentCapabilities?: AssistantApiAndroidIntentCapabilities;
  /**
   * These capabilities are scoped to the ability to gather audio. It includes
   * information like the type of audio that can be gathered (e.g. public,
   * private).
   */
  audioInput?: AssistantApiAudioInput;
  /**
   * These capabilities are scoped to the ability to play audio. It includes
   * information like the type of audio that can be played (e.g. public,
   * private).
   */
  audioOutput?: AssistantApiAudioOutput;
  /**
   * Bluetooth capabilities related to usage of a feature.
   */
  bluetoothCapabilities?: AssistantApiBluetoothCapabilities;
  /**
   * The call capabilities of this device. go/call-capabilities
   */
  callCapabilities?: AssistantApiCallCapabilities;
  /**
   * These capabilities are scoped to the camera abilities of this device.
   */
  camera?: AssistantApiCameraCapabilities;
  /**
   * UX restrictions for Auto.
   */
  carUxRestrictions?:  | "UX_RESTRICTIONS_UNSPECIFIED" | "UX_RESTRICTIONS_BASELINE" | "UX_RESTRICTIONS_FULLY_RESTRICTED" | "UX_RESTRICTIONS_NO_KEYBOARD" | "UX_RESTRICTIONS_NO_VIDEO"[];
  /**
   * These capabilities are scoped to the cast abilities of this device.
   */
  cast?: AssistantApiCastCapabilities;
  communicationUiCapabilities?: AssistantApiCommunicationUiCapabilities;
  contactLookupCapabilities?: AssistantApiContactLookupCapabilities;
  /**
   * This is the same device id that is specified in the conversation protocol
   * and should be unique to each device/user/model combination. For example, if
   * a request is coming from a watch through AGSA the watch and AGSA should
   * have different device_ids. Note: this field should only be used to
   * determine which device the capabilities belong to and not to access the id
   * of the device. Instead DeviceProperties should be used and accessed through
   * ParamsAccessor.
   */
  deviceId?: AssistantApiCoreTypesDeviceId;
  /**
   * Capabilities related to Android tablet UX experience.
   */
  deviceUxMode?:  | "DEVICE_UX_MODE_DEFAULT" | "DEVICE_UX_MODE_SUPPORT_LIMITED_SHARED_LOCKSCREEN";
  /**
   * Indicates that the device has connection to cellular network that allows
   * it to make voice calls. This is distinct from device just being capable of
   * voice telephony, because the device can be capable yet miss the suitable
   * SIM card (for example, it could miss SIM card altogether, or have data-only
   * SIM card).
   */
  hasVoiceTelephony?: boolean;
  /**
   * Indicates if the client supports Javascript Whatsnext (go/jwn). Also
   * contains the Jwn libraries present on the client along with their versions.
   */
  jwnCapabilities?: AssistantApiJwnCapabilities;
  /**
   * Capabilities related to Lens Perception, i.e. image understanding. See
   * go/lens-perception-sdk.
   */
  lensPerceptionCapabilities?: AssistantApiLensPerceptionCapabilities;
  /**
   * These capabilities are scoped to the location abilities of this device.
   */
  location?: AssistantApiLocationCapabilities;
  /**
   * Data which is produced for logging and debugging. Servers MUST NOT use
   * this for any other purposes, such as branching on it.
   */
  loggingOnlyData?: AssistantApiLoggingOnlyData;
  messageCapabilities?: AssistantApiMessageCapabilities;
  /**
   * These capabilities are scoped to abilities of the device to move around.
   */
  movement?: AssistantApiMovementCapabilities;
  /**
   * DEPRECATED: Use SystemNotificationRestrictions instead. Specifies whether
   * the surface is able to display notifications. This field is superficially
   * similar to ProactiveNotificationOutput, but unlike that field which tracks
   * a per-user preference on the OPA side, this field captures whether the
   * surface is capable of displaying notifications.
   */
  notificationCapabilities?:  | "NO_NOTIFICATION_CAPABILITY" | "NOTIFICATIONS_DISABLED" | "NOTIFICATIONS_ENABLED";
  /**
   * Settings, that reflect whether a specific notification type is allowed for
   * current device, e.g. if the user opted out from notification category or
   * category group. This settings are server-side stored and evaluated unlike
   * SystemNotificationRestrictions field.
   */
  notificationOutputRestrictions?: AssistantApiNotificationOutputRestrictions;
  /**
   * These are user configured restrictions indicating what the device is
   * allowed to output from the privacy point of view.
   */
  outputRestrictions?: AssistantApiOutputRestrictions;
  /**
   * Capability to support Pop on lockscreen.
   */
  popOnLockscreenCapability?:  | "POP_ON_LOCKSCREEN_DEFAULT" | "POP_ON_LOCKSCREEN_ENABLED" | "POP_ON_LOCKSCREEN_DISABLED";
  /**
   * Indicates if the client has safety related restriction.
   */
  safetyRestrictions?:  | "DEFAULT_NO_SAFETY_RESTRICTION" | "DISTRACTION_SAFETY_RESTRICTION";
  /**
   * These capabilities are scoped to the ability to see and interact with the
   * Assistant through a screen. If the device has no screen it should send an
   * empty ScreenCapabilities. Sending no ScreenCapabilities will cause this to
   * be overridden with the surface default.
   */
  screen?: AssistantApiScreenCapabilities;
  /**
   * Capabilities related to SODA (Speech On-Device API).
   */
  sodaCapabilities?: AssistantApiSodaCapabilities;
  /**
   * These capabilities are scoped to the software available on the device as
   * well as the set of supported Assistant features.
   */
  software?: AssistantApiSoftwareCapabilities;
  /**
   * DEPRECATED Capabilities related to speech detection on devices.
   */
  speechCapabilities?: AssistantApiSpeechCapabilities;
  /**
   * Locales supported by assistant settings for speaking and display. This is
   * independent from device language that is defined in device setting. New
   * locales are added based on rollout, whitelist and app version releases
   * because older versions does not have model support. Currently supported
   * locale list differs by surface type.
   */
  supportedLocale?: string[];
  /**
   * The set of information that helps the server identify the surface.
   */
  surfaceIdentity?: AssistantApiCoreTypesSurfaceIdentity;
  /**
   * The device's surface type. This is the string version of the
   * assistant.api.core_types.SurfaceType enum. The server should not use this
   * field, rather it should use the SurfaceType value derived from this string.
   */
  surfaceTypeString?: string;
  /**
   * Restrictions related to system-level notifications. This field is
   * superficially similar to ProactiveNotificationOutput, but unlike that field
   * which tracks a per-user preference on the OPA side, this field captures
   * system level notifications restrictions. This field is not stored and is
   * merged to capablities from conversation params. It exists mostly for
   * logging purposes of android channel state and global app-level notification
   * opt out.
   */
  systemNotificationRestrictions?: AssistantApiSystemNotificationRestrictions;
  /**
   * Capabilities related to third party integration.
   */
  thirdPartyCapabilities?: AssistantApiThirdPartyCapabilities;
}

function serializeAssistantApiDeviceCapabilities(data: any): AssistantApiDeviceCapabilities {
  return {
    ...data,
    loggingOnlyData: data["loggingOnlyData"] !== undefined ? serializeAssistantApiLoggingOnlyData(data["loggingOnlyData"]) : undefined,
    software: data["software"] !== undefined ? serializeAssistantApiSoftwareCapabilities(data["software"]) : undefined,
  };
}

function deserializeAssistantApiDeviceCapabilities(data: any): AssistantApiDeviceCapabilities {
  return {
    ...data,
    loggingOnlyData: data["loggingOnlyData"] !== undefined ? deserializeAssistantApiLoggingOnlyData(data["loggingOnlyData"]) : undefined,
    software: data["software"] !== undefined ? deserializeAssistantApiSoftwareCapabilities(data["software"]) : undefined,
  };
}

/**
 * A Duration represents a signed, fixed-length span of time represented as a
 * count of seconds and fractions of seconds at nanosecond resolution. It is
 * independent of any calendar and concepts like "day" or "month". It is related
 * to Timestamp in that the difference between two Timestamp values is a
 * Duration and it can be added or subtracted from a Timestamp. Range is
 * approximately +-10,000 years.
 */
export interface AssistantApiDuration {
  /**
   * Signed fractions of a second at nanosecond resolution of the span of time.
   * Durations less than one second are represented with a 0 `seconds` field and
   * a positive or negative `nanos` field. For durations of one second or more,
   * a non-zero value for the `nanos` field must be of the same sign as the
   * `seconds` field. Must be from -999,999,999 to +999,999,999 inclusive.
   */
  nanos?: number;
  /**
   * Signed seconds of the span of time. Must be from -315,576,000,000 to
   * +315,576,000,000 inclusive.
   */
  seconds?: bigint;
}

function serializeAssistantApiDuration(data: any): AssistantApiDuration {
  return {
    ...data,
    seconds: data["seconds"] !== undefined ? String(data["seconds"]) : undefined,
  };
}

function deserializeAssistantApiDuration(data: any): AssistantApiDuration {
  return {
    ...data,
    seconds: data["seconds"] !== undefined ? BigInt(data["seconds"]) : undefined,
  };
}

export interface AssistantApiFeatureSpecificActionSupport {
  /**
   * Whether client supports clarification suggestion chip to be displayed see
   * |assistant.suggestions.ClarificationData|
   */
  clarificationDataSupported?: boolean;
}

export interface AssistantApiFitnessFeatureSupport {
  /**
   * A list of fitness activity types supported by this client.
   */
  supportedActivities?:  | "TYPE_UNSPECIFIED" | "WALK" | "RUN" | "ELLIPTICAL" | "SWIM" | "WEIGHTS" | "TREADMILL" | "BIKE" | "YOGA" | "WORKOUT" | "BOOT_CAMP" | "CIRCUIT_TRAINING" | "GOLF" | "HIKING" | "INTERVAL_TRAINING" | "KICKBOXING" | "MARTIAL_ARTS" | "PILATES" | "SPINNING" | "STAIR_CLIMBING" | "TENNIS" | "AEROBICS" | "CORE_TRAINING" | "DANCING" | "HIGH_INTENSITY_INTERVAL_TRAINING" | "KAYAKING" | "ROWING" | "SKIING" | "STANDUP_PADDLEBOARDING" | "STRENGTH_TRAINING" | "SNOWBOARDING"[];
}

export interface AssistantApiFluidActionsSupport {
  /**
   * Specifies the params proto that Fluid Actions uses to sync state with
   * server.
   */
  stateSyncMethod?:  | "STATE_SYNC_METHOD_UNSPECIFIED" | "DIALOG_STATE_PARAMS";
}

/**
 * Capabilities of Google assistant conversation service(GACS) devices. These
 * capabilites including supported GACS actions and response size limitations.
 */
export interface AssistantApiGacsCapabilities {
  /**
   * DeviceId of the accessory device (eg. watch) Commonly the go/dusi (eg.
   * client_instance_id) is provided.
   */
  deviceId?: AssistantApiCoreTypesDeviceId;
  /**
   * Configuration sent by device.
   */
  responseConfig?: GoogleAssistantAccessoryV1ResponseConfig;
  /**
   * DEPRECATED: Format of TTS audio requested by the device.
   */
  ttsEncoding?:  | "LINEAR_16BIT" | "MULAW" | "ALAW" | "MP3" | "MP3_64KBPS" | "SPEEX" | "SPEEX_WITH_HEADER_BYTE" | "SPEEX_IN_OGG" | "OPUS_IN_OGG" | "OPUS_24KBPS_IN_OGG" | "OPUS_16KBPS_IN_OGG" | "OPUS_12KBPS_IN_OGG" | "OPUS_16KBPS_CONTAINERLESS" | "OPUS_24KBPS_CONTAINERLESS" | "OPUS_32KBPS_CONTAINERLESS";
}

function serializeAssistantApiGacsCapabilities(data: any): AssistantApiGacsCapabilities {
  return {
    ...data,
    responseConfig: data["responseConfig"] !== undefined ? serializeGoogleAssistantAccessoryV1ResponseConfig(data["responseConfig"]) : undefined,
  };
}

function deserializeAssistantApiGacsCapabilities(data: any): AssistantApiGacsCapabilities {
  return {
    ...data,
    responseConfig: data["responseConfig"] !== undefined ? deserializeGoogleAssistantAccessoryV1ResponseConfig(data["responseConfig"]) : undefined,
  };
}

/**
 * Capabilities related to GCM.
 */
export interface AssistantApiGcmCapabilities {
  /**
   * GCM registration id for the device. Used to pass messages to the device.
   */
  gcmRegistrationId?: string;
  /**
   * Assistant supports GCM on the device. ClientOps can be sent to it over GCM
   * and will be executed.
   */
  supportsAssistantGcm?: boolean;
  /**
   * If it is set to true, then it indicates to server that device is capable
   * of receiving a GCM payload with serialized client input. The client input
   * will be sent back to Assistant Server over conversation protocol.
   */
  supportsClientInputOverGcm?: boolean;
}

/**
 * The gesture capabilities related to Selina. Next ID: 4
 */
export interface AssistantApiGestureCapabilities {
  /**
   * Whether Gesture is supported. When false, override the value for tap and
   * omniswipe.
   */
  gestureSensing?: boolean;
  /**
   * Whether omniswipe is supported
   */
  omniswipeGestureCapable?: boolean;
  /**
   * Whether tap is supported
   */
  tapGestureCapable?: boolean;
}

/**
 * DEPRECATED: Use AccessControlOutput instead. Access settings for guests.
 */
export interface AssistantApiGuestAccessOutput {
  guestAccessOnYoutube?:  | "UNKNOWN_GUEST_ACCESS" | "USE_DEFAULT_ACCOUNT_FOR_GUEST" | "DISABLED_FOR_GUEST";
}

export interface AssistantApiImmersiveCanvasSupport {
  /**
   * Whether the client supports confirmation messages in Immersive Canvas
   * actions.
   */
  confirmationMessageSupported?: boolean;
  /**
   * Whether the client support canvas pause signal. If true, the Assistant
   * Server will send a signal when canvas transitioning to pause mode.
   */
  pauseSignalSupported?: boolean;
}

/**
 * These capabilities are used to determine the jwn libraries and their
 * versions that are present on the client.
 */
export interface AssistantApiJwnCapabilities {
  /**
   * The name and version of the jwn libraries currently stored on the client.
   * These are the same that the server communicated when the library was first
   * sent down.
   */
  librariesVersionMap?: {
    [key: string]: string
  };
  /**
   * Compression algorithms supported on the client. Server can choose one of
   * these to compress WhatsNext Javascript programs and libraries.
   */
  supportedCompressionMode?:  | "NONE" | "BROTLI" | "FLATE"[];
  /**
   * Whether the client supports running jwn code.
   */
  supportsJwn?: boolean;
}

/**
 * Capabilities related to Lens Perception, i.e. image understanding. See
 * go/loa-lens-device-capabilities. Next ID: 6
 */
export interface AssistantApiLensPerceptionCapabilities {
  /**
   * Whether the device supports Lens Perception.
   */
  hasLensPerception?: boolean;
  /**
   * Indicates whether Lens supports Lens Direct Intent (go/lensdirectintent).
   */
  isLensDirectIntentAvailable?: boolean;
  /**
   * Indicates whether Lens supports Live view-finder experience.
   */
  isLensLiveViewfinderAvailable?: boolean;
  /**
   * Indicates whether Lens supports Post-capture experience with an image
   * payload.
   */
  isLensPostCaptureAvailable?: boolean;
  /**
   * Contains the capabilities that Lens can support.
   */
  lensCapabilities?: AssistantApiLensPerceptionCapabilitiesLensCapabilities;
}

/**
 * The set of capabilities that Lens can support. This is the Assistant proto
 * representation of Lens capabilities defined at
 * j/c/g/android/apps/gsa/search/shared/service/proto/lens_service_event.proto
 * Next ID: 7
 */
export interface AssistantApiLensPerceptionCapabilitiesLensCapabilities {
  /**
   * The presence of this message means that Dining is supported.
   */
  dining?: AssistantApiLensPerceptionCapabilitiesLensCapabilitiesDining;
  /**
   * The presence of this message means that Education is supported.
   */
  education?: AssistantApiLensPerceptionCapabilitiesLensCapabilitiesEducation;
  /**
   * The presence of this message means that Outdoor is supported.
   */
  outdoor?: AssistantApiLensPerceptionCapabilitiesLensCapabilitiesOutdoor;
  /**
   * The presence of this message means that Shopping is supported.
   */
  shopping?: AssistantApiLensPerceptionCapabilitiesLensCapabilitiesShopping;
  /**
   * The presence of this message means that intenting directly into the text
   * filter is supported.
   */
  text?: AssistantApiLensPerceptionCapabilitiesLensCapabilitiesText;
  /**
   * The presence of this message means that Translation is supported.
   */
  translate?: AssistantApiLensPerceptionCapabilitiesLensCapabilitiesTranslate;
}

/**
 * Dining recognition capability. For example popular dishes on a given
 * restaurant menu image.
 */
export interface AssistantApiLensPerceptionCapabilitiesLensCapabilitiesDining {
}

/**
 * Education recognition capability.
 */
export interface AssistantApiLensPerceptionCapabilitiesLensCapabilitiesEducation {
}

/**
 * Outdoor place recognition capability. For example recognizing storefronts.
 */
export interface AssistantApiLensPerceptionCapabilitiesLensCapabilitiesOutdoor {
}

/**
 * Shopping recognition capability.
 */
export interface AssistantApiLensPerceptionCapabilitiesLensCapabilitiesShopping {
}

/**
 * Text recognition capability.
 */
export interface AssistantApiLensPerceptionCapabilitiesLensCapabilitiesText {
  /**
   * Indicates whether text-to-speech is supported.
   */
  isTextToSpeechSupported?: boolean;
}

/**
 * Translation capability.
 */
export interface AssistantApiLensPerceptionCapabilitiesLensCapabilitiesTranslate {
  /**
   * The list of language IETF BCP 47 tags that are supported. See the full
   * details in the comment on the equivalent field in:
   * http://google3/java/com/google/android/apps/gsa/search/shared/service/proto/lens_service_event.proto;l=55;rcl=355512559
   */
  supportedLanguageTags?: string[];
}

export interface AssistantApiLiveTvChannelCapabilities {
  /**
   * A list of channel providers each of which provides a list of its channels.
   */
  channelsByProvider?: AssistantApiLiveTvChannelCapabilitiesChannelsByProvider[];
}

export interface AssistantApiLiveTvChannelCapabilitiesChannelsByProvider {
  /**
   * A list of channels provided by this input. Keep the performance impact in
   * mind when the number/size of the channels is large. When there are too many
   * channels, consider stripping out some data.
   */
  channels?: AssistantApiLiveTvChannelCapabilitiesLiveTvChannel[];
  /**
   * An identifier to identify the input source. For example for TIF based
   * channels, this will be the TIF input ID to differentiate different tuner
   * apps. See https://source.android.com/devices/tv
   */
  inputId?: string;
  /**
   * Type of provider who provides this channel input.
   */
  providerType?:  | "UNKNOWN_PROVIDER_TYPE" | "OTT_PROVIDER" | "TUNER";
}

export interface AssistantApiLiveTvChannelCapabilitiesLiveTvChannel {
  /**
   * Unique channel identifier.
   */
  channelId?: string;
  /**
   * A list of channel names and synonyms.
   */
  channelName?: string[];
  /**
   * Channel number displayed to user. Optional.
   */
  channelNumber?: string;
  /**
   * A deep link into the Live player app that tunes to this channel.
   */
  deeplink?: string;
  /**
   * KG mid of the channel if it exists in KG.
   */
  mid?: string;
  /**
   * Network KG mid of the channel if it exists in KG
   */
  networkMid?: string;
}

export interface AssistantApiLiveTvProvider {
  /**
   * Contains detailed provider information such as android app package name.
   */
  providerInfo?: AssistantApiCoreTypesProvider;
  /**
   * An provider enum string for OTT providers. The available key can be found
   * in go/ump-provider-enum For Tuner provider, the provider key would be an ID
   * the tuner app uploaded from TIF. See https://source.android.com/devices/tv
   */
  providerKey?: string;
  providerType?:  | "UNKNOWN_PROVIDER_TYPE" | "OTT_PROVIDER" | "TUNER";
}

function serializeAssistantApiLiveTvProvider(data: any): AssistantApiLiveTvProvider {
  return {
    ...data,
    providerInfo: data["providerInfo"] !== undefined ? serializeAssistantApiCoreTypesProvider(data["providerInfo"]) : undefined,
  };
}

function deserializeAssistantApiLiveTvProvider(data: any): AssistantApiLiveTvProvider {
  return {
    ...data,
    providerInfo: data["providerInfo"] !== undefined ? deserializeAssistantApiCoreTypesProvider(data["providerInfo"]) : undefined,
  };
}

export interface AssistantApiLocationCapabilities {
  gpsAvailable?: boolean;
}

/**
 * Data which is produced for logging and debugging. Servers MUST NOT use this
 * for any other purposes, such as branching on it. Next ID: 15
 */
export interface AssistantApiLoggingOnlyData {
  /**
   * The index of the account on the device. Useful when there are multiple
   * accounts on a device such as distinguishing primary user data from
   * secondary users. There is no guarantee that this is a stable number but is
   * relatively stable in practice.
   */
  accountIndex?: number;
  /**
   * A user-readable string describing the ACP version (go/acp-version) of the
   * client app used by the user to originate the conversation.
   */
  acpVersion?: string;
  /**
   * Random identifier assigned to Android mobile devices. Older logs may have
   * previously stored other kinds of android IDs in this field, but all current
   * logs should use the GServices Id. See go/androidids.
   */
  androidId?: bigint;
  /**
   * A user-readable string describing the version of the client app used by
   * the user to originate the conversation.
   */
  appVersion?: string;
  /**
   * An enum specifying when was this ATV AssistantSettings entry initially
   * created.
   */
  assistantSettingsSource?:  | "NOT_SET" | "FIRST_SCREEN_DEVICE_OOBE" | "FIRST_SCREEN_KATNISS_OOBE" | "FIRST_SCREEN_DELEGATION_OOBE" | "FIRST_SCREEN_FIXER_JOB" | "FIRST_SCREEN_FCM_JOB" | "FIRST_SCREEN_HOME_GRAPH_JOB" | "FIRST_SCREEN_PERSONAL_BIT" | "FIRST_SCREEN_VOICE_INPUT_BIT" | "FIRST_SCREEN_OTHER" | "SECOND_SCREEN_AGSA" | "SECOND_SCREEN_GHA_IOS" | "SECOND_SCREEN_GHA_ANDROID";
  /**
   * The type of board used by manufacturer for this device
   */
  boardName?: string;
  /**
   * The revision of board used
   */
  boardRevision?: string;
  /**
   * This field records the linking status between Assistant setting entry and
   * Cast setting entry. Currently only ATV surface populates this field for
   * profiling purpose.
   */
  castAssistantSettingLinkingResult?: AssistantApiCastAssistantSettingLinkingResult;
  /**
   * A user-readable string describing the device's hardware platform.
   */
  deviceModel?: string;
  /**
   * Any relevant info concerning the build options of the embedder (that is
   * the software which runs as the 'driver' of an Assistant library, such as
   * libassistant. the embedder is typically built by a third party)
   */
  embedderBuildInfo?: string;
  /**
   * A string recording the app version that is initially used to created this
   * settings entry.
   */
  initialAppVersion?: string;
  /**
   * default display name of device over mdns. This is specified at the
   * factory, not specified by the user.
   */
  mdnsDisplayName?: string;
  /**
   * A user-readable string describing the device's software platform.
   */
  platformBuild?: string;
  /**
   * A string describing device's release channel. For cast devices, the string
   * will look like "qa-beta-channel", "eng-no-update", etc.
   */
  virtualReleaseChannel?: string;
}

function serializeAssistantApiLoggingOnlyData(data: any): AssistantApiLoggingOnlyData {
  return {
    ...data,
    androidId: data["androidId"] !== undefined ? String(data["androidId"]) : undefined,
  };
}

function deserializeAssistantApiLoggingOnlyData(data: any): AssistantApiLoggingOnlyData {
  return {
    ...data,
    androidId: data["androidId"] !== undefined ? BigInt(data["androidId"]) : undefined,
  };
}

export interface AssistantApiMediaControlSupport {
  /**
   * Whether to prevent confirmations (text, tts) for media control actions
   * while media is playing so that the media session is not interrupted.
   */
  skipConfirmationsWhilePlaying?: boolean;
}

export interface AssistantApiMessageCapabilities {
  /**
   * If true, APP_ID queries initiated by this device should fall back to
   * execution on the tethered device if it's available and if the primary
   * device cannot perform the action (e.g. due to the app not being installed).
   */
  fallbackToTetheredDeviceAppCapabilities?: boolean;
  /**
   * Should only be checked if nonempty.
   */
  supportedRecipientTypes?:  | "UNSPECIFIED_ENDPOINT" | "PHONE_NUMBER" | "EMAIL_ADDRESS" | "APP_UNIQUE_ID" | "EMERGENCY_PHONE_NUMBER" | "VOICEMAIL"[];
}

export interface AssistantApiMovementCapabilities {
  /**
   * Indicates how much the device moves around. E.g., TV has a low mobility
   * level, while Auto has a very high level.
   */
  mobility?:  | "UNSPECIFIED" | "LOW" | "MEDIUM" | "HIGH" | "VERY_HIGH";
}

export interface AssistantApiNotificationOutputRestrictions {
  optOutState?: AssistantApiNotificationOutputRestrictionsOptOutState;
}

/**
 * Per category/category group notification opt out settings.
 */
export interface AssistantApiNotificationOutputRestrictionsOptOutState {
  categoryGroupState?: AssistantApiNotificationOutputRestrictionsOptOutStateCategoryGroupState[];
  categoryState?: AssistantApiNotificationOutputRestrictionsOptOutStateCategoryState[];
}

export interface AssistantApiNotificationOutputRestrictionsOptOutStateCategoryGroupState {
  categoryGroup?:  | "UNSPECIFIED" | "SYSTEM" | "PROMOTIONAL" | "SUBSCRIPTIONS" | "PROACTIVE" | "REMINDERS" | "EXTENDED_ANSWERS" | "FEEDBACK" | "ACTIONS_ON_GOOGLE" | "DUO_MISSED_CALLS" | "HOME_AUTOMATION" | "GETTING_AROUND" | "UNIT_TESTING";
  state?:  | "OPTED_IN" | "OPTED_OUT";
}

export interface AssistantApiNotificationOutputRestrictionsOptOutStateCategoryState {
  category?:  | "UNSPECIFIED" | "SYSTEM_REQUIRED_LOW_PRIORITY" | "SYSTEM_REQUIRED_HIGH_PRIORITY" | "DISCOVERY" | "REALTIME_PROMOTIONAL" | "SUBSCRIPTIONS" | "FLIGHT_UPDATES" | "TRANSPORT_UPDATES" | "BILL_UPDATES" | "PACKAGE_DELIVERY_UPDATES" | "EVENT_UPDATES" | "DUE_DATE_UPDATES" | "CELEBRATION_UPDATES" | "ROUTINE_UPDATES" | "TASK_SUGGESTIONS" | "AT_A_PLACE" | "APP_RECOMMENDATIONS" | "TRAVEL_UPDATES" | "REMINDER_DUE" | "NEW_REMINDER_ASSIGNMENT" | "ASSIGNED_REMINDER_DUE" | "ROUTINE_SETTINGS_UPDATES" | "MAPS_OR_DIRECTIONS" | "MOVIE_SHOWTIMES" | "SPORTS_UPDATES" | "NEWS_UPDATES" | "SONGS_AND_ARTISTS" | "TRANSLATIONS" | "ANSWERS_TO_QUESTIONS" | "SETTINGS_LINKS" | "RESERVATION_UPDATES" | "DEPRECATED_FEEDBACK_REQUESTS" | "FEEDBACK_REQUESTS" | "ACTIONS_ON_GOOGLE" | "DUO_MISSED_CALLS" | "HOME_AUTOMATION" | "TIME_TO_LEAVE" | "COMMUTE" | "OCCASIONALLY_REPEATED_ACTIONS" | "FREQUENTLY_REPEATED_ACTIONS" | "ASPIRE" | "ASSISTANT_DRIVING_MODE" | "DISCOVERY_DEFAULT_PRIORITY" | "HOLIDAY_REMINDERS" | "CROSS_DEVICE_TIMER" | "LIVE_CARD" | "ASYNC_ACTION" | "UNIT_TESTING";
  state?:  | "OPTED_IN" | "OPTED_OUT";
}

/**
 * Encapsulates the action capabilities of the OEM device. This data is merged
 * from Device Model lookup, per-device registration, and per-request context.
 * This data is sent to NLU layer for query understanding.
 */
export interface AssistantApiOemCapabilities {
  /**
   * The OEM Cloud execution capability of this device, containing routing
   * details for cloud fulfillment.
   */
  cloudCapability?: AssistantDevicesPlatformProtoCloudCapability;
  /**
   * If fulfillment is done via 3P cloud and 3P supports device capabilities,
   * this field will be set.
   */
  cloudDeviceCapabilities?: {
    [key: string]: any
  };
  /**
   * Device Model Id from DeviceModelPackage.
   */
  deviceModelId?: string;
  /**
   * Device Model Revision Id from DeviceModelPackage.
   */
  deviceModelRevisionId?: bigint;
  /**
   * Opaque supported action data related to a specific domain of devices, for
   * example for car. go/car-talk-registration-model
   */
  deviceSpecificData?: string;
  /**
   * Internal-only config containing metadata about the Device Model, for
   * example to control the ranking behavior.
   */
  internalCapability?: AssistantDevicesPlatformProtoInternalCapability;
  /**
   * 3P Action Metadata, populated from the Device Model lookup and the client
   * request parameters. For example, an Assistant SDK request would have the
   * billed project id of the Assistant request added here in order to enable
   * any Device Actions developed using the same Google Cloud project. This data
   * is sent to Service Engine to mask triggering for Device Actions.
   */
  thirdPartyActionConfig?: AssistantApiThirdPartyActionConfig;
}

function serializeAssistantApiOemCapabilities(data: any): AssistantApiOemCapabilities {
  return {
    ...data,
    deviceModelRevisionId: data["deviceModelRevisionId"] !== undefined ? String(data["deviceModelRevisionId"]) : undefined,
    thirdPartyActionConfig: data["thirdPartyActionConfig"] !== undefined ? serializeAssistantApiThirdPartyActionConfig(data["thirdPartyActionConfig"]) : undefined,
  };
}

function deserializeAssistantApiOemCapabilities(data: any): AssistantApiOemCapabilities {
  return {
    ...data,
    deviceModelRevisionId: data["deviceModelRevisionId"] !== undefined ? BigInt(data["deviceModelRevisionId"]) : undefined,
    thirdPartyActionConfig: data["thirdPartyActionConfig"] !== undefined ? deserializeAssistantApiThirdPartyActionConfig(data["thirdPartyActionConfig"]) : undefined,
  };
}

/**
 * Definitions of on-device assistant capabilities.
 */
export interface AssistantApiOnDeviceAssistantCapabilities {
  /**
   * Capabilities related to local network arbitration
   * (go/local-network-arbitration). Indicates if the device is capable of being
   * a host device in the LAN whiling doing local network arbitration.
   */
  isLocalNetworkArbitrationSupported?: boolean;
  /**
   * Capabilities related to on-device arbitration(go/arbitration-on-device).
   */
  isOnDeviceArbitrationSupported?: boolean;
  /**
   * Indicates if on-device assistant is enabled on this device. Example
   * usecases: NGA (go/nga) or Marble (go/marble).
   */
  isOnDeviceAssistantSupported?: boolean;
  /**
   * This may be used by NGA. E.g. if understanding happens on device, we can
   * have more aggressive logic when fulfilling some features on the server
   * side, like teleport.
   */
  isOnDeviceUnderstandingSupported?: boolean;
}

/**
 * Definitions of on-device Smart Home capabilities. Next ID: 2
 */
export interface AssistantApiOnDeviceSmartHomeCapabilities {
  /**
   * Master bit for on-device Smart Home features.
   */
  isOnDeviceSmartHomeSupported?: boolean;
}

/**
 * The on-device storage capabilities found on the device.
 */
export interface AssistantApiOnDeviceStorageCapabilities {
  /**
   * Determines if an on-device storage is supported.
   */
  isSupported?: boolean;
}

/**
 * These are user configurable permissions representing what the device is
 * allowed to output. Next ID: 11
 */
export interface AssistantApiOutputRestrictions {
  /**
   * Access settings for all providers.
   */
  accessControlOutput?: AssistantApiAccessControlOutput;
  /**
   * The type of Google Photo content which the device can output.
   */
  googlePhotoContent?:  | "ALL_PHOTO_CONTENT" | "NO_RESTRICTED_PHOTO_CONTENT";
  /**
   * DEPRECATED: Use access_control_output instead. Access settings for guests.
   */
  guestAccessOutput?: AssistantApiGuestAccessOutput;
  /**
   * The level of personal data which the device can output. See
   * go/personal-readout for detail.
   */
  personalData?:  | "PERSONAL_DATA_OUTPUT_UNKNOWN" | "ALL_PERSONAL_DATA_WITH_PROACTIVE" | "ALL_PERSONAL_DATA" | "NO_PERSONAL_DATA";
  /**
   * This controls if the server can proactively send notification to users,
   * and it does not affect scenarios that users ask for information. The
   * notification may include TTS and lights. It could be only lights for chirp.
   */
  proactiveNotificationOutput?:  | "UNKNOWN_PROACTIVE_NOTIFICATION" | "NO_PROACTIVE_NOTIFICATION" | "ALL_PROACTIVE_NOTIFICATIONS";
  /**
   * Restrictions on displaying and interacting with content on proactive
   * surfaces (e.g. Dragonglass home screen). Note: NEVER access this field of
   * OutputRestrictions directly, use the code in
   * assistant/assistant_server/settings/device/device_settings_util.h instead.
   */
  proactiveOutput?: AssistantApiProactiveOutput;
  /**
   * Whether YouTube autoplay is allowed for queries from the user to this
   * device. See go/assistant-youtube-settings for details.
   */
  youtubeAutoplayRestriction?:  | "AUTOPLAY_RESTRICTION_UNSPECIFIED" | "AUTOPLAY_ALLOWED" | "AUTOPLAY_DISABLED";
  /**
   * The type of YouTube content which the device can output.
   */
  youtubeContent?:  | "ALL_YOUTUBE_CONTENT" | "NO_RESTRICTED_CONTENT";
  /**
   * The type of YouTube TV content which the device can output.
   */
  youtubeTvContent?:  | "ALL_YOUTUBE_TV_CONTENT" | "NO_RESTRICTED_YOUTUBE_TV_CONTENT";
}

/**
 * Next ID: 7
 */
export interface AssistantApiProactiveOutput {
  /**
   * Allows displaying all personal data on proactive surfaces with no face
   * match capability.
   */
  allowAllPersonalData?: boolean;
  /**
   * For ANDROID_TV devices, the location that this setting was last changed
   * from. Note: this structure allows to extend to more per-vertical bits in
   * the future.
   */
  androidTvAssistantSettingsSource?:  | "NOT_SET" | "FIRST_SCREEN_DEVICE_OOBE" | "FIRST_SCREEN_KATNISS_OOBE" | "FIRST_SCREEN_DELEGATION_OOBE" | "FIRST_SCREEN_FIXER_JOB" | "FIRST_SCREEN_FCM_JOB" | "FIRST_SCREEN_HOME_GRAPH_JOB" | "FIRST_SCREEN_PERSONAL_BIT" | "FIRST_SCREEN_VOICE_INPUT_BIT" | "FIRST_SCREEN_OTHER" | "SECOND_SCREEN_AGSA" | "SECOND_SCREEN_GHA_IOS" | "SECOND_SCREEN_GHA_ANDROID";
  /**
   * Allows displaying Health and Fitness content on proactive surfaces. This
   * is a sub bit of the device-wide PR bit - the device-wide PR bit must be
   * enabled AND this vertical sub bit must be enabled for H&F content to be
   * shown. This bit will be available on all surfaces that have the
   * proactive-bit enabled. If the proactive-bit is not enabled, then we do not
   * show health and fitness content at all (or even allow access to this
   * setting).
   */
  healthAndFitnessProactive?:  | "NO_HEALTH_AND_FITNESS_PROACTIVE_OUTPUT" | "ALL_HEALTH_AND_FITNESS_PROACTIVE_OUTPUT";
  /**
   * Allows displaying photos content on Dragonglass proactive surfaces. This
   * is a sub bit of the device-wide PR bit - the device-wide PR bit must be
   * enabled AND this vertical sub bit must be enabled for photos content to be
   * shown on Dragonglass surfaces. This bit will be available on all
   * Dragonglass surfaces that have the proactive-bit enabled. If the
   * proactive-bit is not enabled or it's not a Dragonglass surface, then we do
   * not show proactive photos content at all, nor allow access to this setting.
   * See go/opa-photos-sg-settings for more details.
   */
  photosProactive?:  | "UNKNOWN_PHOTOS_PROACTIVE_OUTPUT" | "NO_PHOTOS_PROACTIVE_OUTPUT" | "ALL_PHOTOS_PROACTIVE_OUTPUT";
  /**
   * Whether a device supports proactive output. Note that this is assumed to
   * be true for all Smart Display devices, but surfaces that newly start
   * supporting proactive_output should set this bit.
   */
  supportsProactiveOutput?: boolean;
  /**
   * Settings for displaying personal data on proactive surfaces with face
   * match capability.
   */
  userMatchProactive?:  | "UNKNOWN_USER_MATCH_PROACTIVE" | "NEVER_SHOW" | "ONLY_SHOW_ON_USER_MATCH" | "ALWAYS_SHOW";
}

/**
 * Also known as "Extensions Without Extensions" or "The Poor Man's Any", this
 * simple proto is used to transmit arbitrary protocol buffers over the wire.
 * Unlike extensions: - It does not require the proto type to be compiled into
 * the binary. (Useful so that the proto declaration can be inside the
 * conversation package) - It is compatible with all versions of proto,
 * including proto3 and the wack-tastic version used on ChromecastOS. Server
 * libraries for dealing with it live in
 * google3/assistant/protocol/protobuf_lib.h.
 */
export interface AssistantApiProtobuf {
  /**
   * The serialized protocol buffer.
   */
  protobufData?: Uint8Array;
  /**
   * The type of the protocol buffer to use. This must be a resolvable name
   * (Namespace.ProtoName) and refer to a proto which is either compiled in to
   * both client and server (e.g. a base proto type) or to one which is part of
   * the conversation package.
   */
  protobufType?: string;
}

function serializeAssistantApiProtobuf(data: any): AssistantApiProtobuf {
  return {
    ...data,
    protobufData: data["protobufData"] !== undefined ? encodeBase64(data["protobufData"]) : undefined,
  };
}

function deserializeAssistantApiProtobuf(data: any): AssistantApiProtobuf {
  return {
    ...data,
    protobufData: data["protobufData"] !== undefined ? decodeBase64(data["protobufData"] as string) : undefined,
  };
}

/**
 * Date-based recurrences specify repeating events. Conceptually, a recurrence
 * is a (possibly unbounded) sequence of dates on which an event falls,
 * described by a list of constraints. A date is in a recurrence if and only if
 * it satisfies all of the constraints. Note that devices may support some
 * constraints, but not all. IMPORTANT: The definition of Recurrence proto is
 * being moved to //assistant/api/core_types/governed/datetime_type.proto. All
 * existing references will be updated to point to the new location. If you are
 * adding a reference, use the new one instead.
 */
export interface AssistantApiRecurrence {
  /**
   * The first day of the recurrence. If begin is not set, then the reminder
   * will start infinitely in the past.
   */
  begin?: AssistantApiDate;
  /**
   * A list of blacklisted dates to skip the alarm on.
   */
  blacklistedRanges?: AssistantApiRecurrenceDatetimeRange[];
  /**
   * Specifies the date in a month. For example, if day_of_month is 15, then it
   * represent the 15th day of the specified month.
   */
  dayOfMonth?: number[];
  /**
   * Specifies a weekly or daily recurrence. Constraint: The date falls on one
   * of these days of the week, in 0...6 (Sunday...Saturday).
   */
  dayOfWeek?: number[];
  /**
   * The last day of the recurrence.
   */
  end?: AssistantApiDate;
  /**
   * Multiplier on the frequency of the recurrence. Use this to specify
   * patterns that recur every X days, months, years, etc. Example: [remind me
   * to call mom every 2nd week]. Default is 1 (every day, every month, every
   * year).
   */
  every?: number;
  /**
   * Specifies the month in a year. Constrain: the month falls on one of these
   * months, in 1, 2, ... 12 (January...December).
   */
  monthOfYear?: number[];
  /**
   * The number of occurrences after which the recurrence should end.
   */
  numOccurrences?: number;
  /**
   * Specifies the index of week in a month. For example, the second Tuesday
   * every month, in this case, week_of_month should be 2.
   */
  weekOfMonth?: number[];
}

/**
 * A representation of a range of time with start and end datetime specified.
 */
export interface AssistantApiRecurrenceDatetimeRange {
  /**
   * End date of the range.
   */
  endDate?: AssistantApiDateTime;
  /**
   * Start date of the range.
   */
  startDate?: AssistantApiDateTime;
}

/**
 * These capabilities represent the tactile features associated with the
 * device. This includes, for example, whether the device has a screen, how big
 * the screen is, and privacy of the screen. Next ID: 11
 */
export interface AssistantApiScreenCapabilities {
  /**
   * The scale factor used to convert Scalable Pixel (SP) units to
   * Density-independent Pixel (DP) units (DP = SP * scale factor). Fonts are
   * measured in units of SP, and on some platforms such as Android the SP to DP
   * scale factor can be affected by the font size a user selects in
   * accessibility settings.
   */
  fontScaleFactor?: number;
  /**
   * The types of input that this screen supports. Note that this can be empty
   * in which case the screen's input type is unknown.
   */
  inputType?:  | "TOUCHSCREEN"[];
  /**
   * Mask defined for this device, if any.
   */
  mask?: AssistantApiScreenCapabilitiesMask;
  /**
   * The targeted schema version for ProtoLayout requests.
   */
  protoLayoutTargetedSchema?: AssistantApiScreenCapabilitiesProtoLayoutVersion;
  /**
   * If this field is absent, the resolution of the screen is unknown.
   */
  resolution?: AssistantApiScreenCapabilitiesResolution;
  /**
   * If screen is turned off.
   */
  screenOff?: boolean;
  /**
   * The ability of the client to correctly report screen state.
   */
  screenStateDetection?:  | "UNKNOWN_SCREEN_STATE_DETECTION" | "UNRELIABLE_SCREEN_STATE_DETECTION" | "RELIABLE_SCREEN_STATE_DETECTION";
  /**
   * The primary supported rendering format for display on the device's screen.
   * This may be used to determine what format of card to be returned when
   * rendering cards.
   */
  supportedRenderingFormat?:  | "UNKNOWN_RENDERING_FORMAT" | "CONCISE_TEXT" | "PROTO_LAYOUT" | "ELEMENTS";
  /**
   * The screen states that the client supports. The current screen state is
   * specified in DeviceProperties.screen.
   */
  supportedScreenStates?:  | "UNKNOWN_SCREEN_STATE" | "ON" | "OFF"[];
  /**
   * Whether the device enabled vision help features in accessiblity settings.
   * The settings is config in Assistant App and on-device settings, and stored
   * in footprints. When enabled, font, color and TTS will be adjusted.
   */
  visionHelpEnabled?: boolean;
}

/**
 * A mask applied to the screen's pixel space to determine regions not visible
 * on the physical device.
 */
export interface AssistantApiScreenCapabilitiesMask {
  type?:  | "UNKNOWN_MASK" | "NO_MASK" | "ROUND_MASK";
}

/**
 * Version info for ProtoLayout requests.
 */
export interface AssistantApiScreenCapabilitiesProtoLayoutVersion {
  major?: number;
  minor?: number;
}

/**
 * A Resolution proto indicates the size of the application window. All fields
 * are required.
 */
export interface AssistantApiScreenCapabilitiesResolution {
  /**
   * Dots (pixels) per inch of the screen.
   */
  dpi?: number;
  heightPx?: number;
  /**
   * m_size is the smallest square box size to display a capital letter M so
   * that the user can still easily understand it.
   */
  mSize?: number;
  /**
   * neng_size is the smallest square box size to display a letter 螚 (Neng,
   * U+879A) so that the user can easily understand it. (Neng is a visually
   * dense Chinese letter, and so may require a larger box than an M.)
   */
  nengSize?: number;
  /**
   * The dimensions of the application window, in pixels.
   */
  widthPx?: number;
}

/**
 * The Soli capabilities on Elaine, including gestures and sleep sensing.
 * go/dingo-dc-software Next ID: 4
 */
export interface AssistantApiSelinaCapabilites {
  /**
   * A list of gestures that selina supports
   */
  gestureCapabilities?: AssistantApiGestureCapabilities;
  /**
   * Whether the client supports selina.
   */
  selinaSupported?: boolean;
  /**
   * Whether the client can monitor sleep. This allows us to show sleep CUJ
   * related information: go/TwilightDesign
   */
  sleepSensingSupported?: boolean;
}

export interface AssistantApiSettingsAmbientSettings {
  /**
   * Whether any user sets personal photos on this device. See
   * go/ambient-setting-in-assistant-design.
   */
  anyUserHasSetPersonalPhotos?: boolean;
  /**
   * Whether or not the user's current selection for their ambient photo frame
   * includes the auto-generated "Recent Highlights" album. This is used to
   * determine which users to display the go/opa-photos-memories-tile. See
   * go/opa-photo-memories-imax-optin for more discussion on why this bit was
   * created.
   */
  recentHighlightsEnabled?: boolean;
  /**
   * Whether to enable the personal photo data in the ambient settings:
   * https://screenshot.googleplex.com/Wd4OFkQfOyF See
   * go/opa-photos-ambient-location-date-dd#heading=h.5x4iaouuiett for
   * explanation.
   */
  showPersonalPhotoData?: boolean;
  /**
   * Whether current user sets personal photos on this device. See
   * go/ambient-setting-in-assistant-design.
   */
  showPersonalPhotos?: boolean;
}

/**
 * These capabilties are associated with Assistant Settings on devices.
 */
export interface AssistantApiSettingsAppCapabilities {
  /**
   * Capabilities that are associated with Assistant Settings on auto surfaces.
   */
  carSettingsCapabilities?: AssistantApiCarSettingsCapabilities;
  /**
   * Whether the client supports reissuing query after setting up in Music
   * Settings.
   */
  reissueQueryAfterMusicSetup?: boolean;
  /**
   * Whether the client supports updating payments setting.
   */
  supportsPaymentsSettingsUpdate?: boolean;
}

/**
 * Settings pertaining to auto framing. See go/auto-framing-presentation.
 */
export interface AssistantApiSettingsAutoFramingSettings {
  isAutoFramingEnabled?: boolean;
}

/**
 * Carrier related call settings on the device.
 */
export interface AssistantApiSettingsCarrierCallDeviceSettings {
  /**
   * Whether this device is allowed to receive incoming PSTN calls.
   */
  allowIncomingCalls?: boolean;
}

/**
 * Specification of which communication features can be used.
 */
export interface AssistantApiSettingsCommunicationsFilter {
  state?:  | "UNKNOWN_STATE" | "ALLOW_ALL" | "BLOCK_CALLS_AND_MESSAGES";
}

/**
 * Specification of times when most features on a device are disabled for
 * certain users. During these periods, the device will respond to most
 * interactions with something like "sorry, I'm sleeping right now". Design:
 * go/home-ft-settings-storage PRD: go/home-family-tools-prd
 */
export interface AssistantApiSettingsDeviceDowntimeSettings {
  schedules?: AssistantApiSettingsLabeledDowntimeSchedule[];
  /**
   * The set of users of this device that will have these downtime settings
   * applied. Must have at least one element.
   */
  targets?:  | "UNKNOWN_DEVICE_SUPERVISION_TARGET" | "EVERYONE" | "KID_ACCOUNTS" | "GUESTS"[];
}

/**
 * Defines a set of restrictions on particular device features for a certain
 * set of users. Design: go/home-ft-settings-storage PRD:
 * go/home-family-tools-prd
 */
export interface AssistantApiSettingsDeviceFeatureFilters {
  /**
   * Enables/disables all the filters at the same time. For new devices or
   * non-Cast devices this is always false.
   */
  enabled?: boolean;
  /**
   * The filters (feature restrictions) to apply when `enabled` is true.
   */
  featureFilters?: AssistantApiSettingsFeatureFilters;
  /**
   * The set of users of this device that will have these settings applied.
   * Must have at least one element.
   */
  targets?:  | "UNKNOWN_DEVICE_SUPERVISION_TARGET" | "EVERYONE" | "KID_ACCOUNTS" | "GUESTS"[];
}

export interface AssistantApiSettingsDeviceLogsOptIn {
  /**
   * Indicates whether the crash logs can be uploaded and the device logs can
   * be enabled
   */
  optInEnabled?: boolean;
}

/**
 * Next ID: 73
 */
export interface AssistantApiSettingsDeviceSettings {
  /**
   * 
   * LINT.ThenChange(//depot/google3/assistant/ui/assistant_device_settings_ui.proto)
   */
  ackStatus?:  | "ACK_COMPLETED" | "ACK_PENDING";
  /**
   * A human-readable address string for the location; generally a one-line
   * address such as "34 Masonic Ave, San Francisco CA 94117, United States".
   * Set this field to empty string for deletion, in which case the rest of the
   * location related fields below will be cleared as well.
   */
  address?: string;
  /**
   * The alias names of the device, e.g. my living room tv, tv, living room and
   * etc., which user will usually use to refer to the device in addition to
   * human_friendly_name. It can help speech biasing and query understanding.
   * This field is set by the user and already localized.
   */
  aliasName?: string[];
  /**
   * Whether this device is allowed to receive incoming calls.
   */
  allowIncomingCalls?: boolean;
  /**
   * Ambient settings contains the configuration of Photo Frame on DG device.
   * This field relies on IMAX service to do the update, sync happenes after
   * user updates IMAX device settings or a device registers in CloudCastDevice.
   * So it's more like a cached version instead of definitive source-of-truth.
   * More details at go/ambient-setting-in-assistant-design.
   */
  ambientSettings?: AssistantApiSettingsAmbientSettings;
  /**
   * The additional device ids. Currently used only for ATV.
   * go/project-yellowstone Note: This field is for internal (Within settings)
   * use only.
   */
  ancillaryDeviceId?: AssistantApiSettingsInternalAncillaryDeviceId;
  /**
   * Auto framing settings associated with a device. See
   * go/auto-framing-presentation.
   */
  autoFramingSettings?: AssistantApiSettingsAutoFramingSettings;
  /**
   * Indicates whether the user has enabled Blue Steel. See go/blue-steel for
   * more info on this project.
   */
  blueSteelEnabled?: boolean;
  /**
   * Describes roughly what a device is capable of doing and metadata around
   * those capabilities. Note: this includes device limitations as well as user
   * configurable settings.
   */
  capabilities?: AssistantApiDeviceCapabilities;
  /**
   * city and postal_code are sent to third party AoG Apps as location when
   * permission is granted for precise or coarse location.
   * https://developers.google.com/actions/reference/rest/Shared.Types/Permission
   * city and postal_code have the same description as in Proto Postal Address:
   * https://cs.corp.google.com/piper///depot/google3/location/country/postaladdress.proto
   * city corresponds to locality_name, postal_code corresponds to
   * postal_code_number. These two fields are set in assistant_settings_service
   * by AddressConverter.
   * https://cs.corp.google.com/piper///depot/google3/location/addressformatter/public/addressconverter.h
   * See go/aog-i18n-address-parse for more information
   */
  city?: string;
  /**
   * Status of colocation. go/co-location-work-v2 Note: this is a cache at the
   * Assistant level. The source of truth is inside CastAuthenticationServer,
   * which is only used for Home devices.
   */
  colocationStatus?:  | "COLOCATION_UNKNOWN" | "COLOCATION_ESTABLISHED" | "COLOCATION_NOT_ESTABLISHED" | "COLOCATION_NOT_SUPPORTED";
  /**
   * The timestamp that the device is linked with the user in milliseconds.
   */
  creationTimestampMs?: bigint;
  /**
   * Availability of this device for Assistant Cross-surface handoffs.
   * (go/assistant-cross-surface)
   */
  crossSurfaceAvailability?: AssistantApiSettingsDeviceSettingsCrossSurfaceAvailability;
  /**
   * The identification of the default device which user want to output audio.
   * See go/default-media-output-design for more info.
   */
  defaultAudioDeviceId?: AssistantApiCoreTypesDeviceId;
  /**
   * The identification of the default device which user want to output video.
   * Note that, we don't fallback to this for audio playback when
   * default_audio_device_id is not set. See go/default-media-output-design for
   * more info.
   */
  defaultVideoDeviceId?: AssistantApiCoreTypesDeviceId;
  /**
   * The brand of the device, populated from DeviceOemParams. Examples:
   * "google", "samsung".
   */
  deviceBrand?: string;
  /**
   * The identification of the device.
   */
  deviceId?: AssistantApiCoreTypesDeviceId;
  /**
   * The model ID of the device. This should be globally unique across
   * manufactures/OEMs. Examples: "nest_cam_iq_2017", "comcast_voice_box_2017".
   */
  deviceModelId?: string;
  /**
   * The Device Platform Service lookup revision. (go/device-model-revision)
   * For 1p devices, and most 3p devices with no custom feature, this should be
   * always 0, which means no lookup needed. For 3p devices with custom
   * assistant feature, this is provided directly by OEM as incremental (e.g. 1,
   * 2, 3, ...)
   */
  deviceModelRevision?: number;
  /**
   * Only valid for ATV. Stores the android DUSI for the corresponding user.
   * More details: go/auto-logout-on-unlink.
   */
  dusi?: string;
  /**
   * List of errors that happened during the face enrollment process if it
   * failed. See go/face-match-enrollment-error for more info.
   */
  faceEnrollmentErrors?:  | "UNKNOWN_FACE_ENROLLMENT_ERROR" | "MISSING_FRONTAL_POSE" | "FACE_NOT_DETECTED" | "MULTIPLE_FACE_DETECTED" | "FACE_WITHOUT_SIGNATURE" | "FACE_DETECTION_LOW_CONFIDENCE" | "FACE_LANDMARK_LOW_CONFIDENCE" | "FACE_WITHOUT_CONFIDENCE" | "FACE_TOO_SMALL" | "FAILED_TO_READ_IMAGE" | "FAILED_TO_DECODE_IMAGE" | "FACE_DETECTION_ERROR" | "FACE_WITHOUT_EMBEDDING_CONFIDENCE"[];
  /**
   * Indicates whether the user's face has been successfully enrolled on this
   * device. See go/face-match-server-design for more info.
   */
  faceEnrollmentStatus?:  | "UNKNOWN_STATUS" | "SUCCESS" | "FAILURE" | "PENDING";
  /**
   * Indicates whether the user has enabled Face Match for this device. See
   * go/face-match-server-design for more info on this project.
   */
  faceMatchEnabled?: boolean;
  /**
   * When true, allow data collection of audio on this device for Federated
   * Learning.
   */
  flAudioCacheEnabled?: boolean;
  /**
   * When true, allow data collection of frames on this device.
   */
  flVisualFramesCacheEnabled?: boolean;
  /**
   * Stores GCM info associated with a device. See go/quartz-design-doc for
   * more info.
   */
  gcmSettings?: AssistantApiSettingsGcmSettings;
  /**
   * Holds the data that should be written to HomeGraph. Note: this field is
   * not persisted in Assistant Settings storage. It is simply used for
   * transporting data when client calls UpdateSettings.
   */
  homeGraphData?: AssistantApiSettingsHomeGraphData;
  /**
   * The home graph ID that can be used to lookup the corresponding entry in
   * HomeGraph. go/home-graph. Note: when this field is empty, it doesn't
   * necessarily mean that the device is not in home graph. It just means that
   * Assistant doesn't know about the mapping.
   */
  homeGraphId?: string;
  /**
   * Indicates whether the device is currently in Hospitality mode.
   * go/hospitality-mode-design. This is moved to a per user setting in
   * assistant settings. ref. go/hospitality-settings-v2
   */
  hospitalityModeStatus?: AssistantApiSettingsHospitalityMode;
  /**
   * The level of hotword sensitivity. go/hotword-sensitivity-prd
   */
  hotwordSensitivity?:  | "UNKNOWN_HOTWORD_SENSITIVITY" | "HOTWORD_SENSITIVITY_LOW" | "HOTWORD_SENSITIVITY_NORMAL" | "HOTWORD_SENSITIVITY_HIGH" | "HOTWORD_SENSITIVITY_LOW_2" | "HOTWORD_SENSITIVITY_HIGH_2";
  /**
   * HotwordThresholdAdjustmentFactor contains threshold_adjustment_factor, and
   * it's validity. TAF is a measure of adjustment applied to the hotword
   * threshold as a result of go/autotune. Currently, this is updated from
   * query_settings_frame, but if we move to updating it from the client, this
   * could also contain TAFs as a result of Hotword Sensitivity, in addition to
   * Autotune.
   */
  hotwordThresholdAdjustmentFactor?: AssistantApiSettingsHotwordThresholdAdjustmentFactor;
  /**
   * The human-friendly name of the cast device, e.g., my living room tv. This
   * field is set by the user and already localized.
   */
  humanFriendlyName?: string;
  /**
   * Internal version of the DeviceSettings for measurement of the
   * DeviceSettings mutation race conditions. See
   * go/consistent-assistant-settings-update.
   */
  internalVersion?: AssistantApiSettingsInternalVersion;
  /**
   * Indicates whether the device is also managed through HA cloud sync.
   * go/ha-dev-guide
   */
  isCloudSyncDevice?: boolean;
  /**
   * When true, the user has explicitly allowed audio and visual data
   * collection on this device
   */
  isDeviceActivationCacheEnabled?: boolean;
  /**
   * Specifies if kids-mode is enabled for the device. See
   * go/aff-parentalsupervision-dd.
   */
  kidsMode?: AssistantApiSettingsKidsMode;
  /**
   * Device's latest registration timestamp provided by Cast side. This field
   * is not necessarily up to date. The update frequency is defined in
   * last_registration_update_frequency_in_days field of AssistantConfig in
   * java/com/google/chrome/dongle/common/proto/home_assistant_config.proto.
   * go/cast-last-registration-time
   */
  lastCastRegistrationTimestamp?: Date;
  /**
   * Coarsened hourly timestamp of when the device was last used.
   */
  lastUsedCoarseTimestamp?: Date;
  /**
   * Stores pairing between different devices. See go/quartz-design-doc for
   * more info.
   */
  linkedDeviceId?: AssistantApiCoreTypesDeviceId[];
  /**
   * Please do NOT use this field without prior approval from PWG. Users who
   * have signed in onto this device, go/linked-users-in-pkg.
   */
  linkedUsers?: AssistantApiSettingsLinkedUser[];
  /**
   * The locale for the device: language + region, i.e., en-US, ja-JP.
   */
  locale?: string;
  /**
   * Coordinate information of the device location.
   */
  locationCoordinates?: AssistantApiCoreTypesLocationCoordinates;
  /**
   * The feature proto of the location of the device. Note: client does not
   * need to populate this. It will be auto-populated based on "address" field
   * on server side. Currently, only "bound" and "type" are persisted, since the
   * entire FeatureProto is too big.
   */
  locationFeature?: GeostoreFeatureProto;
  /**
   * See go/marketplace-disclosure for more info.
   */
  marketplaceDisclosure?: AssistantApiSettingsMarketplaceDisclosure;
  masqueradeMode?: AssistantApiSettingsMasqueradeMode;
  /**
   * Information about how to send the user a notification. This won't be
   * populated for fb-conv users (allo group chat users).
   */
  notificationProfile?: AssistantApiSettingsNotificationProfile;
  /**
   * OAuth client id for the device. This field is available for Assistant SDK
   * devices. It is written when the device is registered to the user
   * (AssistantSettingsUiService.LinkAssistantDeviceUi). When user revokes grant
   * on the Assistant device, Assistant Devices Platform Service will receive
   * Pubsub notification with OAuth client id for the revoked device, and we
   * will compare that with this stored id to identity device to remove.
   */
  oauthClientId?: string;
  /**
   * Device specific app related settings.
   */
  onDeviceAppSettings?: AssistantApiSettingsOnDeviceAppSettings;
  /**
   * Specifies if device logs and crashes can be captured during SendFeedback
   */
  optInStatus?: AssistantApiSettingsDeviceLogsOptIn;
  /**
   * DEPRECATED: Use DeviceCapabilities.OutputRestrictions.personal_data
   * instead. Whether the user has enabled payments for this device.
   */
  paymentsEnabled?: boolean;
  /**
   * Metadata about how personalization settings were configured.
   */
  personalizationMetadata?: AssistantApiSettingsPersonalizationMetadata;
  /**
   * Specify whether polite mode is enabled for this device. See
   * go/pretty-please-dd.
   */
  politeMode?: AssistantApiSettingsPoliteMode;
  postalCode?: string;
  /**
   * Trusted device preferences Assistant reauth.
   * go/assistant-reauth-verify-skip.
   */
  reauthTrustedDeviceSettings?: AssistantApiSettingsReauthTrustedDeviceSettings;
  /**
   * A human-readable shortened address. This is usually the street address.
   * Note: client does not need to populate this. It will be auto-populated
   * based on "address" field on server side. Developers can use this field to
   * avoid reading out the full address everytime.
   */
  shortenedAddress?: string;
  /**
   * Indicates whether the user has enabled speaker-id for this device. See
   * go/google-assistant-multi-user for more info on this project.
   */
  speakerIdEnabled?: boolean;
  /**
   * Settings related to TTS output.
   */
  speechOutputSettings?: AssistantApiSettingsSpeechOutputSettings;
  /**
   * Speech/hotword detection related settings.
   */
  speechSettings?: AssistantApiSettingsSpeechSettings;
  /**
   * Restrictions on how and when certain users can use a device. See
   * go/home-ft-prd.
   */
  supervisionSettings?: AssistantApiSettingsDeviceSupervisionSettings;
  /**
   * The type of assistant surface. Only use this field when device type is
   * ASSISTANT.
   */
  surfaceType?: AssistantApiCoreTypesSurfaceType;
  /**
   * Presence indicates a tethered wearable. go/wearable-device-ids.
   */
  tetheredInfo?: AssistantApiSettingsTetheredInfo;
  /**
   * Device time zone. It's mainly used for a one-time notification for new
   * users when they just bought and activated their devices. They may not have
   * used Search or Assistant before, so their timezone info may not available
   * elsewhere when we want to send a notification. This should be used as a
   * fallback only when other timezone sources such as
   * assistant_settings:user_attribute#inferred_user_timezone are not available.
   * Also, when both |time_zone| and |location| are set, the |location| should
   * be preferred to derive the most up to date timezone. This info directly
   * comes from the device through early device setting recording mechanism. See
   * more details at go/early-device-setting-recording.
   */
  timeZone?: AssistantApiTimeZone;
  /**
   * Local network ID of the device (truncated to obfuscate devices and
   * households globally). This is a temporary signal to determine proximity of
   * Assistant devices in a house (HGS place).
   */
  truncatedLocalNetworkId?: string;
  /**
   * DEPRECATED: Use speech_settings instead. Indicates whether the user has
   * enabled trusted voice for this device. See go/hotword-settings-on-cloud for
   * more info on this project.
   */
  trustedVoiceEnabled?: boolean;
  /**
   * The type of the device. Note: this should only be used for grouping
   * devices for UI presentation purpose. Use |capabilities| to decide what the
   * device can do.
   */
  type?:  | "UNKNOWN_DEVICE_TYPE" | "ASSISTANT" | "HOME_AUTOMATION" | "CAST" | "CAST_GROUP" | "QUARTZ" | "QUARTZ_IOS" | "CLOUD_AUTO";
  /**
   * Indicates whether to play verbose tts for Elementary on chirp. See:
   * go/opa-cast-a11y-impl-design fore more info on this project. Note: this
   * should probably be in SpeechOutputSetting below.
   */
  verboseTtsForChromecastEnabled?: boolean;
  /**
   * Coarsened hourly timestamp of when the user was last verified by
   * VoiceMatch on this device. This is used for enforcing VoiceMatch model TTL.
   * go/voicematch-pdd-ttl
   */
  vmLastUsedCoarseTimestamp?: Date;
  /**
   * Indicates whether the user's voice has been successfully enrolled on this
   * device.
   */
  voiceEnrollmentStatus?:  | "VOICE_ENROLLMENT_UNKNOWN_STATUS" | "VOICE_ENROLLMENT_SUCCESS" | "VOICE_ENROLLMENT_FAILURE" | "VOICE_ENROLLMENT_PENDING";
  /**
   * A boolean indicates whether voice input (mic-button, hotword, etc) is
   * enabled.
   */
  voiceInputEnabled?: boolean;
}

function serializeAssistantApiSettingsDeviceSettings(data: any): AssistantApiSettingsDeviceSettings {
  return {
    ...data,
    capabilities: data["capabilities"] !== undefined ? serializeAssistantApiDeviceCapabilities(data["capabilities"]) : undefined,
    creationTimestampMs: data["creationTimestampMs"] !== undefined ? String(data["creationTimestampMs"]) : undefined,
    crossSurfaceAvailability: data["crossSurfaceAvailability"] !== undefined ? serializeAssistantApiSettingsDeviceSettingsCrossSurfaceAvailability(data["crossSurfaceAvailability"]) : undefined,
    hospitalityModeStatus: data["hospitalityModeStatus"] !== undefined ? serializeAssistantApiSettingsHospitalityMode(data["hospitalityModeStatus"]) : undefined,
    internalVersion: data["internalVersion"] !== undefined ? serializeAssistantApiSettingsInternalVersion(data["internalVersion"]) : undefined,
    lastCastRegistrationTimestamp: data["lastCastRegistrationTimestamp"] !== undefined ? data["lastCastRegistrationTimestamp"].toISOString() : undefined,
    lastUsedCoarseTimestamp: data["lastUsedCoarseTimestamp"] !== undefined ? data["lastUsedCoarseTimestamp"].toISOString() : undefined,
    linkedUsers: data["linkedUsers"] !== undefined ? data["linkedUsers"].map((item: any) => (serializeAssistantApiSettingsLinkedUser(item))) : undefined,
    locationFeature: data["locationFeature"] !== undefined ? serializeGeostoreFeatureProto(data["locationFeature"]) : undefined,
    marketplaceDisclosure: data["marketplaceDisclosure"] !== undefined ? serializeAssistantApiSettingsMarketplaceDisclosure(data["marketplaceDisclosure"]) : undefined,
    masqueradeMode: data["masqueradeMode"] !== undefined ? serializeAssistantApiSettingsMasqueradeMode(data["masqueradeMode"]) : undefined,
    notificationProfile: data["notificationProfile"] !== undefined ? serializeAssistantApiSettingsNotificationProfile(data["notificationProfile"]) : undefined,
    reauthTrustedDeviceSettings: data["reauthTrustedDeviceSettings"] !== undefined ? serializeAssistantApiSettingsReauthTrustedDeviceSettings(data["reauthTrustedDeviceSettings"]) : undefined,
    vmLastUsedCoarseTimestamp: data["vmLastUsedCoarseTimestamp"] !== undefined ? data["vmLastUsedCoarseTimestamp"].toISOString() : undefined,
  };
}

function deserializeAssistantApiSettingsDeviceSettings(data: any): AssistantApiSettingsDeviceSettings {
  return {
    ...data,
    capabilities: data["capabilities"] !== undefined ? deserializeAssistantApiDeviceCapabilities(data["capabilities"]) : undefined,
    creationTimestampMs: data["creationTimestampMs"] !== undefined ? BigInt(data["creationTimestampMs"]) : undefined,
    crossSurfaceAvailability: data["crossSurfaceAvailability"] !== undefined ? deserializeAssistantApiSettingsDeviceSettingsCrossSurfaceAvailability(data["crossSurfaceAvailability"]) : undefined,
    hospitalityModeStatus: data["hospitalityModeStatus"] !== undefined ? deserializeAssistantApiSettingsHospitalityMode(data["hospitalityModeStatus"]) : undefined,
    internalVersion: data["internalVersion"] !== undefined ? deserializeAssistantApiSettingsInternalVersion(data["internalVersion"]) : undefined,
    lastCastRegistrationTimestamp: data["lastCastRegistrationTimestamp"] !== undefined ? new Date(data["lastCastRegistrationTimestamp"]) : undefined,
    lastUsedCoarseTimestamp: data["lastUsedCoarseTimestamp"] !== undefined ? new Date(data["lastUsedCoarseTimestamp"]) : undefined,
    linkedUsers: data["linkedUsers"] !== undefined ? data["linkedUsers"].map((item: any) => (deserializeAssistantApiSettingsLinkedUser(item))) : undefined,
    locationFeature: data["locationFeature"] !== undefined ? deserializeGeostoreFeatureProto(data["locationFeature"]) : undefined,
    marketplaceDisclosure: data["marketplaceDisclosure"] !== undefined ? deserializeAssistantApiSettingsMarketplaceDisclosure(data["marketplaceDisclosure"]) : undefined,
    masqueradeMode: data["masqueradeMode"] !== undefined ? deserializeAssistantApiSettingsMasqueradeMode(data["masqueradeMode"]) : undefined,
    notificationProfile: data["notificationProfile"] !== undefined ? deserializeAssistantApiSettingsNotificationProfile(data["notificationProfile"]) : undefined,
    reauthTrustedDeviceSettings: data["reauthTrustedDeviceSettings"] !== undefined ? deserializeAssistantApiSettingsReauthTrustedDeviceSettings(data["reauthTrustedDeviceSettings"]) : undefined,
    vmLastUsedCoarseTimestamp: data["vmLastUsedCoarseTimestamp"] !== undefined ? new Date(data["vmLastUsedCoarseTimestamp"]) : undefined,
  };
}

export interface AssistantApiSettingsDeviceSettingsCrossSurfaceAvailability {
  /**
   * Last known locale of the client.
   */
  lastKnownClientLocale?: string;
  /**
   * This is the timestamp when the AssistantRequestParams (in
   * ASSISTANT_SNAPSHOT corpus) were last written for this device.
   */
  lastParamsWriteTimestamp?: Date;
}

function serializeAssistantApiSettingsDeviceSettingsCrossSurfaceAvailability(data: any): AssistantApiSettingsDeviceSettingsCrossSurfaceAvailability {
  return {
    ...data,
    lastParamsWriteTimestamp: data["lastParamsWriteTimestamp"] !== undefined ? data["lastParamsWriteTimestamp"].toISOString() : undefined,
  };
}

function deserializeAssistantApiSettingsDeviceSettingsCrossSurfaceAvailability(data: any): AssistantApiSettingsDeviceSettingsCrossSurfaceAvailability {
  return {
    ...data,
    lastParamsWriteTimestamp: data["lastParamsWriteTimestamp"] !== undefined ? new Date(data["lastParamsWriteTimestamp"]) : undefined,
  };
}

export interface AssistantApiSettingsDeviceSupervisionSettings {
  /**
   * Specification of times that a device shouldn't respond to certain users.
   * See go/home-ft-prd.
   */
  downtimeSettings?: AssistantApiSettingsDeviceDowntimeSettings;
  /**
   * Restrictions on features that certain users can access on a device. See
   * go/home-ft-prd.
   */
  featureFilters?: AssistantApiSettingsDeviceFeatureFilters;
}

/**
 * Specifies a period of up to 24 hours when downtime should be enabled,
 * starting at certain time on a certain day of the week, and ending at a later
 * time on either that day or the following day.
 */
export interface AssistantApiSettingsDowntimePeriod {
  /**
   * True if downtime should be enabled during this period.
   */
  enabled?: boolean;
  /**
   * Time of day that this downtime period should end. Required. If end_time >
   * start_time, end_time is relative to start_day. Otherwise, end_time is
   * relative to the day after start_day. For example, start_day: MONDAY,
   * start_time: 9 p.m., end_time: 6 a.m. means that the downtime period starts
   * at 9 p.m. on Monday and ends at 6 a.m. on Tuesday.
   */
  endTime?: GoogleTypeTimeOfDay;
  /**
   * The day of the week when this downtime period starts. Required.
   */
  startDay?:  | "DAY_OF_WEEK_UNSPECIFIED" | "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY" | "SUNDAY";
  /**
   * Time of day that this downtime period should start. Required.
   */
  startTime?: GoogleTypeTimeOfDay;
}

/**
 * Specification of when downtime is enabled on different days of the week.
 * Contains up to 7 DowntimePeriod messages, up to one per day of the week.
 */
export interface AssistantApiSettingsDowntimeSchedule {
  /**
   * True if this downtime schedule should be enabled.
   */
  enabled?: boolean;
  /**
   * Downtime entries for the days of the week, in no particular order. There
   * can be at most one period defined for each day of the week. Days of the
   * week with no explicit period defined are treated as disabled, so the device
   * is available all day (modulo an end time that may spill over from the
   * previous day).
   */
  periods?: AssistantApiSettingsDowntimePeriod[];
}

/**
 * Duo related call settings on the device. Next ID: 5
 */
export interface AssistantApiSettingsDuoCallDeviceSettings {
  /**
   * True if Duo Knock Kncok feature is enabled on the device.
   */
  allowKnockKnock?: boolean;
  /**
   * Boolean indicating if user has explicitly marked this device to be linked
   * or not. This bit is used in case where unexpected errors occur and we have
   * to check for account/device status and mark the device linked after
   * verification.
   */
  shouldBeLinked?: boolean;
  /**
   * The call state of the device (i.e. whether an Duo call account has been
   * setup on the device).
   */
  state?:  | "UNKNOWN_LINK_STATE" | "NOT_LINKED" | "LINKED" | "LINKED_WAITING" | "LINK_ERROR";
  /**
   * Client device settings: settings which are populated by client to give to
   * duocore. TalkBack is an accessibility service that helps blind and
   * vision-impaired users interact with their devices. Indicates whether
   * talkback is enabled for the device. Note: this is per device settings
   * currently filled by client for all users.
   */
  talkbackEnabled?: boolean;
}

/**
 * Specification of which assistant features are allowed for a particular
 * device or user account.
 */
export interface AssistantApiSettingsFeatureFilters {
  communicationsFilter?: AssistantApiSettingsCommunicationsFilter;
  musicFilter?: AssistantApiSettingsMusicFilter;
  newsFilter?: AssistantApiSettingsNewsFilter;
  podcastFilter?: AssistantApiSettingsPodcastFilter;
  searchFilter?: AssistantApiSettingsSearchFilter;
  thirdPartyAppsFilter?: AssistantApiSettingsThirdPartyAppsFilter;
  videoFilter?: AssistantApiSettingsVideoFilter;
  webviewFilter?: AssistantApiSettingsWebviewFilter;
}

export interface AssistantApiSettingsGcmSettings {
  gcmId?: string;
  gcmPackage?: string;
}

/**
 * Next ID: 8
 */
export interface AssistantApiSettingsHomeGraphData {
  /**
   * Agent ID, aka project ID. Used as the AgentDeviceId.agent_id of device
   * when calling Home Graph Service.
   */
  agentId?: string;
  /**
   * See go/ha-dev-guide and HomeGraphItem.attribute in
   * //assistant/verticals/homeautomation/proto/home_graph.proto
   */
  attributes?: {
    [key: string]: any
  };
  /**
   * Device ID, used as AgentDeviceId.device_id of device when calling Home
   * Graph Service.
   */
  deviceId?: string;
  /**
   * HGS device type. See
   * java/com/google/home/graph/service/config/protoconf.pi for the exhaustive
   * list of type strings.
   */
  deviceType?: string;
  /**
   * Whether device data should be written to Home Graph via Assistant
   * device_settings. Assistant SDK and Google Home write their devices into
   * Home Graph through AssistantSettingsService, while Home Automation Partner
   * devices (e.g. SmartThings, Philips Hue, Nest, TP-Link, etc.) don't need to
   * be written to Home Graph through AssistantSettingsService. This field
   * decides whether AssistantSettingsService writes devices to Home Graph or
   * not.
   */
  shouldWriteToHomeGraph?: boolean;
  /**
   * Supported traits of the device. See
   * java/com/google/home/graph/service/config/protoconf.pi for the exhaustive
   * list of trait-strings.
   */
  supportedTraits?: string[];
  /**
   * Whether the device supports direct response. See
   * HomeGraphItem.supports_direct_response in
   * //assistant/verticals/homeautomation/proto/home_graph.proto
   */
  supportsDirectResponse?: boolean;
}

export interface AssistantApiSettingsHospitalityCardSettings {
  /**
   * Config for Hospitality UI modules.
   */
  cardConfig?: AssistantApiSettingsHospitalityCardSettingsCardConfig[];
  /**
   * Toggle media tap gesture tutorial card.
   */
  showMediaTapGestureTutorial?: boolean;
  /**
   * Toggle photo swipe gesture tutorial card.
   */
  showPhotoSwipeGestureTutorial?: boolean;
  /**
   * Config for YouTube video cards.
   */
  youtubeCardConfig?: AssistantApiSettingsHospitalityCardSettingsYouTubeCardConfig[];
}

function serializeAssistantApiSettingsHospitalityCardSettings(data: any): AssistantApiSettingsHospitalityCardSettings {
  return {
    ...data,
    cardConfig: data["cardConfig"] !== undefined ? data["cardConfig"].map((item: any) => (serializeAssistantApiSettingsHospitalityCardSettingsCardConfig(item))) : undefined,
  };
}

function deserializeAssistantApiSettingsHospitalityCardSettings(data: any): AssistantApiSettingsHospitalityCardSettings {
  return {
    ...data,
    cardConfig: data["cardConfig"] !== undefined ? data["cardConfig"].map((item: any) => (deserializeAssistantApiSettingsHospitalityCardSettingsCardConfig(item))) : undefined,
  };
}

/**
 * Configuration for hospitality card.
 */
export interface AssistantApiSettingsHospitalityCardSettingsCardConfig {
  /**
   * Whether the UI module requires user action. If true, the UI module can
   * peek on to the top of Ambient. See
   * SmartDisplayModuleState::ACTIVE_ACTION_REQUIRED.
   */
  activeActionRequired?: boolean;
  /**
   * Whether the UI module is dismissable.
   */
  dismissable?: boolean;
  /**
   * The time that the module is effective and visible to the user. If not set,
   * the module is effective immediately.
   */
  effectiveTime?: AssistantApiTimestamp;
  /**
   * The time that the module is expired and invisible to the user. If not set,
   * the module never expires.
   */
  expiryTime?: AssistantApiTimestamp;
  /**
   * The image URL for the UI module.
   */
  imageUrl?: string;
  /**
   * Module ID.
   */
  moduleId?:  | "UNKNOWN" | "MID_STAY_SURVEY" | "CHECK_OUT" | "CHECK_IN" | "RESET";
  /**
   * Payload query to the partner AoG action when user responds to UI Module,
   * e.g. “Tell the hotel how my stay is going”.
   */
  payloadQuery?: string;
  /**
   * Title of the message to be shown to user at the top of the UI Module.
   */
  title?: string;
}

function serializeAssistantApiSettingsHospitalityCardSettingsCardConfig(data: any): AssistantApiSettingsHospitalityCardSettingsCardConfig {
  return {
    ...data,
    effectiveTime: data["effectiveTime"] !== undefined ? serializeAssistantApiTimestamp(data["effectiveTime"]) : undefined,
    expiryTime: data["expiryTime"] !== undefined ? serializeAssistantApiTimestamp(data["expiryTime"]) : undefined,
  };
}

function deserializeAssistantApiSettingsHospitalityCardSettingsCardConfig(data: any): AssistantApiSettingsHospitalityCardSettingsCardConfig {
  return {
    ...data,
    effectiveTime: data["effectiveTime"] !== undefined ? deserializeAssistantApiTimestamp(data["effectiveTime"]) : undefined,
    expiryTime: data["expiryTime"] !== undefined ? deserializeAssistantApiTimestamp(data["expiryTime"]) : undefined,
  };
}

/**
 * Configuration for YouTube video card (Stargazer tile).
 */
export interface AssistantApiSettingsHospitalityCardSettingsYouTubeCardConfig {
  /**
   * URL of image to go on card. The URL must be a public link accessible from
   * ZeroState.
   */
  imageUrl?: string;
  /**
   * ID of YouTube playlist to play on card tap. A playlist is used instead of
   * a single video id to avoid autoplaying related videos. The playlist and the
   * videos it contains must be public or unlisted to be accessible from
   * ZeroState.
   */
  playlistId?: string;
  /**
   * Text on card (i.e., video title).
   */
  text?: string;
}

/**
 * Hospitality mode config for the current device. go/hospitality-mode-design.
 * Next ID: 17
 */
export interface AssistantApiSettingsHospitalityMode {
  /**
   * List of AOG app context ids that are linked to this device. These apps
   * will have access to the structure information for the device.
   */
  aogContextId?: string[];
  /**
   * Invocation phrase for hotel's AoG action. Used for ZS promotion card and
   * "talk to my hotel" rewrites. Setting this to an empty value will mark it
   * unset.
   */
  aogInvocationPhrase?: string;
  branding?: AssistantApiSettingsHospitalityModeBranding;
  cardSettings?: AssistantApiSettingsHospitalityCardSettings;
  /**
   * The time when we received a request to reset the device.
   */
  deviceClearRequest?: AssistantApiTimestamp;
  /**
   * Should the dialog have a shorter ttl. See
   * go/ipp-consumer-prd#heading=h.ibu9b1ysdl4t and
   * go/interpreter-device-clear#bookmark=id.hw8ey1bzjadn for context.
   */
  dialogTtlOverrideMicros?: bigint;
  /**
   * Identifier for the enterprise which owns the device. Setting this to an
   * empty value will mark it unset.
   */
  enterpriseId?: string;
  /**
   * Indicates whether this device is in the hospitality mode.
   */
  hospitalityModeEnabled?: boolean;
  /**
   * Last time the device was cleared and placed in hospitality mode. Will be
   * set when the switch is toggled on and reset when a guest checks out. On the
   * device this triggers removing alarms, timers, etc.
   */
  lastDeviceClear?: AssistantApiTimestamp;
  /**
   * Indicates when hospitality settings were last updated.
   */
  lastModifiedTimestamp?: AssistantApiTimestamp;
  /**
   * Last time the welcome message was played for the guest. If last_welcomed <
   * welcome_request, the message should be replayed and this time set.
   */
  lastWelcomed?: AssistantApiTimestamp;
  /**
   * Indicates whether or not the device must be reset manually (by voice or
   * touch), as opposed to being automatically reset.
   * go/hospitality-manual-reset
   */
  manualResetRequired?: boolean;
  /**
   * In order promoted languages for interpreter devices. This represents
   * languages by BCP-47 language strings, such as "en", "en-US", "fr", "fr-CA",
   * "sr-Latn", "zh-Hans-CN", "zh-Hant-HK",etc.
   */
  promotedLanguages?: string[];
  type?:  | "UNKNOWN_TYPE" | "HOTEL_ROOM" | "INTERPRETER" | "SENIOR_LIVING_ROOM" | "RETAIL_DEMO";
  /**
   * Whether we allow users to initiate clearing the device verbally. We
   * generally allow this for private devices and not for public ones.
   */
  verbalResetSupported?: boolean;
  /**
   * The time when we received a request to welcome the user.
   */
  welcomeRequest?: AssistantApiTimestamp;
}

function serializeAssistantApiSettingsHospitalityMode(data: any): AssistantApiSettingsHospitalityMode {
  return {
    ...data,
    cardSettings: data["cardSettings"] !== undefined ? serializeAssistantApiSettingsHospitalityCardSettings(data["cardSettings"]) : undefined,
    deviceClearRequest: data["deviceClearRequest"] !== undefined ? serializeAssistantApiTimestamp(data["deviceClearRequest"]) : undefined,
    dialogTtlOverrideMicros: data["dialogTtlOverrideMicros"] !== undefined ? String(data["dialogTtlOverrideMicros"]) : undefined,
    lastDeviceClear: data["lastDeviceClear"] !== undefined ? serializeAssistantApiTimestamp(data["lastDeviceClear"]) : undefined,
    lastModifiedTimestamp: data["lastModifiedTimestamp"] !== undefined ? serializeAssistantApiTimestamp(data["lastModifiedTimestamp"]) : undefined,
    lastWelcomed: data["lastWelcomed"] !== undefined ? serializeAssistantApiTimestamp(data["lastWelcomed"]) : undefined,
    welcomeRequest: data["welcomeRequest"] !== undefined ? serializeAssistantApiTimestamp(data["welcomeRequest"]) : undefined,
  };
}

function deserializeAssistantApiSettingsHospitalityMode(data: any): AssistantApiSettingsHospitalityMode {
  return {
    ...data,
    cardSettings: data["cardSettings"] !== undefined ? deserializeAssistantApiSettingsHospitalityCardSettings(data["cardSettings"]) : undefined,
    deviceClearRequest: data["deviceClearRequest"] !== undefined ? deserializeAssistantApiTimestamp(data["deviceClearRequest"]) : undefined,
    dialogTtlOverrideMicros: data["dialogTtlOverrideMicros"] !== undefined ? BigInt(data["dialogTtlOverrideMicros"]) : undefined,
    lastDeviceClear: data["lastDeviceClear"] !== undefined ? deserializeAssistantApiTimestamp(data["lastDeviceClear"]) : undefined,
    lastModifiedTimestamp: data["lastModifiedTimestamp"] !== undefined ? deserializeAssistantApiTimestamp(data["lastModifiedTimestamp"]) : undefined,
    lastWelcomed: data["lastWelcomed"] !== undefined ? deserializeAssistantApiTimestamp(data["lastWelcomed"]) : undefined,
    welcomeRequest: data["welcomeRequest"] !== undefined ? deserializeAssistantApiTimestamp(data["welcomeRequest"]) : undefined,
  };
}

/**
 * TODO(b/169423976) Consider moving Branding out of user level settings into
 * enterprise level settings. Partner branding fields used to customize the ui.
 * Next ID: 7
 */
export interface AssistantApiSettingsHospitalityModeBranding {
  /**
   * Brand display in the UI
   */
  displayName?: string;
  /**
   * Brand display in the UI for languages that the enterprise has a localized
   * name that is different from its global branding name. For example, Hilton
   * is 'ヒルトン' in Japanese and '希爾頓' in Chinese. The keys are hospitality
   * supported display locales, e.g. en, ja-JP, etc, defined in experiment
   * parameter Hospitality__hospitality_display_supported_locales.
   */
  displayNameForLanguage?: {
    [key: string]: string
  };
  largeLogoUrl?: string;
  smallLogoUrl?: string;
}

/**
 * HotwordThresholdAdjustmentFactor contains threshold_adjustment_factor, and
 * it's validity. value should only be considered when is_valid = true.
 */
export interface AssistantApiSettingsHotwordThresholdAdjustmentFactor {
  /**
   * Currently, is_valid is set to false whenever the TAF is not an Autotune
   * aware value. This includes hotword sensitivity users, or devices not
   * eligible for autotune.
   */
  isValid?: boolean;
  value?: number;
}

/**
 * Represents supporting device ids.
 */
export interface AssistantApiSettingsInternalAncillaryDeviceId {
  /**
   * Contains device ids known to devices. eg. For ATV, it contains
   * client_instance_id and cast_id.
   */
  deviceId?: AssistantApiCoreTypesDeviceId;
}

/**
 * Represents a version of a specifit setting, e.g. DeviceSettings.
 */
export interface AssistantApiSettingsInternalVersion {
  /**
   * Contains the timestamp when this version was generated.
   */
  generationTime?: Date;
  /**
   * Integer value of the version, it is a monotonically increasing number and
   * starts at 0. On every update it is incremented by 1.
   */
  id?: bigint;
}

function serializeAssistantApiSettingsInternalVersion(data: any): AssistantApiSettingsInternalVersion {
  return {
    ...data,
    generationTime: data["generationTime"] !== undefined ? data["generationTime"].toISOString() : undefined,
    id: data["id"] !== undefined ? String(data["id"]) : undefined,
  };
}

function deserializeAssistantApiSettingsInternalVersion(data: any): AssistantApiSettingsInternalVersion {
  return {
    ...data,
    generationTime: data["generationTime"] !== undefined ? new Date(data["generationTime"]) : undefined,
    id: data["id"] !== undefined ? BigInt(data["id"]) : undefined,
  };
}

/**
 * Kids mode config for the current device. go/aff-parentalsupervision-dd
 */
export interface AssistantApiSettingsKidsMode {
  kidsModeEnabled?: boolean;
  /**
   * Identifier of the account currently specified to be used with kids mode.
   */
  obfuscatedGaiaId?: string;
}

export interface AssistantApiSettingsLabeledDowntimeSchedule {
  /**
   * User-provided name for this schedule.
   */
  displayName?: string;
  schedule?: AssistantApiSettingsDowntimeSchedule;
}

/**
 * Represents the profile of the user who has signed in onto this device. Next
 * id: 5
 */
export interface AssistantApiSettingsLinkedUser {
  /**
   * Time of linking of the device with the user provided by Cast.
   */
  castLinkingTime?: Date;
  /**
   * Primary email address of the user.
   */
  email?: string;
  gaiaId?: bigint;
  /**
   * Supports features which depend on profile name, when no matching contact
   * is found.
   */
  names?: AppsPeopleOzExternalMergedpeopleapiName[];
}

function serializeAssistantApiSettingsLinkedUser(data: any): AssistantApiSettingsLinkedUser {
  return {
    ...data,
    castLinkingTime: data["castLinkingTime"] !== undefined ? data["castLinkingTime"].toISOString() : undefined,
    gaiaId: data["gaiaId"] !== undefined ? String(data["gaiaId"]) : undefined,
    names: data["names"] !== undefined ? data["names"].map((item: any) => (serializeAppsPeopleOzExternalMergedpeopleapiName(item))) : undefined,
  };
}

function deserializeAssistantApiSettingsLinkedUser(data: any): AssistantApiSettingsLinkedUser {
  return {
    ...data,
    castLinkingTime: data["castLinkingTime"] !== undefined ? new Date(data["castLinkingTime"]) : undefined,
    gaiaId: data["gaiaId"] !== undefined ? BigInt(data["gaiaId"]) : undefined,
    names: data["names"] !== undefined ? data["names"].map((item: any) => (deserializeAppsPeopleOzExternalMergedpeopleapiName(item))) : undefined,
  };
}

export interface AssistantApiSettingsMarketplaceDisclosure {
  /**
   * True if the user has confirmed the marketplace disclosure.
   */
  confirmed?: boolean;
  /**
   * The time user confirmed the marketplace disclosure.
   */
  timestampMs?: bigint;
}

function serializeAssistantApiSettingsMarketplaceDisclosure(data: any): AssistantApiSettingsMarketplaceDisclosure {
  return {
    ...data,
    timestampMs: data["timestampMs"] !== undefined ? String(data["timestampMs"]) : undefined,
  };
}

function deserializeAssistantApiSettingsMarketplaceDisclosure(data: any): AssistantApiSettingsMarketplaceDisclosure {
  return {
    ...data,
    timestampMs: data["timestampMs"] !== undefined ? BigInt(data["timestampMs"]) : undefined,
  };
}

/**
 * Guest mode for the current device. go/assistant-guest-mode-summary
 */
export interface AssistantApiSettingsMasqueradeMode {
  lastEnterGuestModeTimestamp?: AssistantApiTimestamp;
  lastExitGuestModeTimestamp?: AssistantApiTimestamp;
  masqueradeModeEnabled?: boolean;
}

function serializeAssistantApiSettingsMasqueradeMode(data: any): AssistantApiSettingsMasqueradeMode {
  return {
    ...data,
    lastEnterGuestModeTimestamp: data["lastEnterGuestModeTimestamp"] !== undefined ? serializeAssistantApiTimestamp(data["lastEnterGuestModeTimestamp"]) : undefined,
    lastExitGuestModeTimestamp: data["lastExitGuestModeTimestamp"] !== undefined ? serializeAssistantApiTimestamp(data["lastExitGuestModeTimestamp"]) : undefined,
  };
}

function deserializeAssistantApiSettingsMasqueradeMode(data: any): AssistantApiSettingsMasqueradeMode {
  return {
    ...data,
    lastEnterGuestModeTimestamp: data["lastEnterGuestModeTimestamp"] !== undefined ? deserializeAssistantApiTimestamp(data["lastEnterGuestModeTimestamp"]) : undefined,
    lastExitGuestModeTimestamp: data["lastExitGuestModeTimestamp"] !== undefined ? deserializeAssistantApiTimestamp(data["lastExitGuestModeTimestamp"]) : undefined,
  };
}

/**
 * Specification of which music features can be used.
 */
export interface AssistantApiSettingsMusicFilter {
  /**
   * Providers available at the time user updated settings.
   */
  availableProviders?:  | "UNKNOWN_MUSIC_PROVIDER" | "YOUTUBE_MUSIC" | "GOOGLE_PLAY_MUSIC" | "SPOTIFY" | "APPLE_MUSIC" | "PANDORA"[];
  /**
   * Represents the state for the music provider filter.
   */
  providerFilterState?:  | "UNKNOWN_STATE" | "ALLOW_ALL_PROVIDERS" | "ALLOW_WHITELISTED_PROVIDERS";
  state?:  | "UNKNOWN_STATE" | "ALLOW_ALL" | "BLOCK_EXPLICIT" | "BLOCK_ALL";
  /**
   * Contains the list of whitelisted music providers.
   */
  whitelistedProviders?:  | "UNKNOWN_MUSIC_PROVIDER" | "YOUTUBE_MUSIC" | "GOOGLE_PLAY_MUSIC" | "SPOTIFY" | "APPLE_MUSIC" | "PANDORA"[];
}

/**
 * Specification of which news features can be used.
 */
export interface AssistantApiSettingsNewsFilter {
  state?:  | "UNKNOWN_STATE" | "ALLOW_ALL_NEWS" | "BLOCK_ALL_NEWS";
}

export interface AssistantApiSettingsNotificationProfile {
  /**
   * Each device can have only one type of notification profile.
   */
  alloNotificationProfile?: AssistantApiSettingsNotificationProfileAlloNotificationProfile;
}

function serializeAssistantApiSettingsNotificationProfile(data: any): AssistantApiSettingsNotificationProfile {
  return {
    ...data,
    alloNotificationProfile: data["alloNotificationProfile"] !== undefined ? serializeAssistantApiSettingsNotificationProfileAlloNotificationProfile(data["alloNotificationProfile"]) : undefined,
  };
}

function deserializeAssistantApiSettingsNotificationProfile(data: any): AssistantApiSettingsNotificationProfile {
  return {
    ...data,
    alloNotificationProfile: data["alloNotificationProfile"] !== undefined ? deserializeAssistantApiSettingsNotificationProfileAlloNotificationProfile(data["alloNotificationProfile"]) : undefined,
  };
}

export interface AssistantApiSettingsNotificationProfileAlloNotificationProfile {
  /**
   * The send token of the conversation with the user.
   */
  botSendToken?: ChatBotPlatformBotSendToken;
  /**
   * The fireball id of this user.
   */
  id?: ChatBotPlatformFireballId;
}

function serializeAssistantApiSettingsNotificationProfileAlloNotificationProfile(data: any): AssistantApiSettingsNotificationProfileAlloNotificationProfile {
  return {
    ...data,
    botSendToken: data["botSendToken"] !== undefined ? serializeChatBotPlatformBotSendToken(data["botSendToken"]) : undefined,
    id: data["id"] !== undefined ? serializeChatBotPlatformFireballId(data["id"]) : undefined,
  };
}

function deserializeAssistantApiSettingsNotificationProfileAlloNotificationProfile(data: any): AssistantApiSettingsNotificationProfileAlloNotificationProfile {
  return {
    ...data,
    botSendToken: data["botSendToken"] !== undefined ? deserializeChatBotPlatformBotSendToken(data["botSendToken"]) : undefined,
    id: data["id"] !== undefined ? deserializeChatBotPlatformFireballId(data["id"]) : undefined,
  };
}

export interface AssistantApiSettingsOnDeviceAppSettings {
  /**
   * On device carrier call related settings.
   */
  carrierCallDeviceSettings?: AssistantApiSettingsCarrierCallDeviceSettings;
  /**
   * On device duo call related settings.
   */
  duoCallDeviceSettings?: AssistantApiSettingsDuoCallDeviceSettings;
}

export interface AssistantApiSettingsPersonalizationMetadata {
  faceMatch?:  | "PERSONALIZATION_FLOW_UNKNOWN" | "PERSONALIZATION_FLOW_DEVICE" | "PERSONALIZATION_FLOW_TWOOBE" | "PERSONALIZATION_FLOW_SLA" | "PERSONALIZATION_FLOW_DEVICE_DELEGATED_CUSTODIO";
  personalResults?:  | "PERSONALIZATION_FLOW_UNKNOWN" | "PERSONALIZATION_FLOW_DEVICE" | "PERSONALIZATION_FLOW_TWOOBE" | "PERSONALIZATION_FLOW_SLA" | "PERSONALIZATION_FLOW_DEVICE_DELEGATED_CUSTODIO";
  voiceMatch?:  | "PERSONALIZATION_FLOW_UNKNOWN" | "PERSONALIZATION_FLOW_DEVICE" | "PERSONALIZATION_FLOW_TWOOBE" | "PERSONALIZATION_FLOW_SLA" | "PERSONALIZATION_FLOW_DEVICE_DELEGATED_CUSTODIO";
}

/**
 * Specification of which podcast features can be used.
 */
export interface AssistantApiSettingsPodcastFilter {
  state?:  | "UNKNOWN_STATE" | "ALLOW_ALL_PODCASTS" | "BLOCK_ALL_PODCASTS";
}

/**
 * Polite mode config for the current device. go/polite-mode-dd
 */
export interface AssistantApiSettingsPoliteMode {
  politeModeEnabled?: boolean;
}

/**
 * Settings related to Assistant reauth. go/assistant-reauth-verify-skip Next
 * id: 2
 */
export interface AssistantApiSettingsReauthTrustedDeviceSettings {
  /**
   * Mapping from integrator client id to device's trust settings. Id from
   * assistant/agent_platform/transactions/reauth/reauth_client.proto.
   */
  trustSettingsForClient?: {
    [key: string]: AssistantApiSettingsReauthTrustedDeviceSettingsTrustSettings
  };
}

function serializeAssistantApiSettingsReauthTrustedDeviceSettings(data: any): AssistantApiSettingsReauthTrustedDeviceSettings {
  return {
    ...data,
    trustSettingsForClient: data["trustSettingsForClient"] !== undefined ? Object.fromEntries(Object.entries(data["trustSettingsForClient"]).map(([k, v]: [string, any]) => ([k, serializeAssistantApiSettingsReauthTrustedDeviceSettingsTrustSettings(v)]))) : undefined,
  };
}

function deserializeAssistantApiSettingsReauthTrustedDeviceSettings(data: any): AssistantApiSettingsReauthTrustedDeviceSettings {
  return {
    ...data,
    trustSettingsForClient: data["trustSettingsForClient"] !== undefined ? Object.fromEntries(Object.entries(data["trustSettingsForClient"]).map(([k, v]: [string, any]) => ([k, deserializeAssistantApiSettingsReauthTrustedDeviceSettingsTrustSettings(v)]))) : undefined,
  };
}

/**
 * Next id: 6
 */
export interface AssistantApiSettingsReauthTrustedDeviceSettingsTrustSettings {
  /**
   * If true, don't ask user to trust this device again.
   */
  neverAskAgain?: boolean;
  /**
   * DEPRECATED: Use never_ask_again instead. Expiration timestamp of "never
   * ask again" status. If this field is set and is later than current
   * timestamp, we should NOT ask the user whether they'd like to trust this
   * device.
   */
  neverAskExpirationTimestamp?: Date;
  /**
   * Expiration timestamp of "trusted" status. If this field is set and is
   * later than current timestamp, we can consider this device to be trusted.
   */
  trustDeviceExpirationTimestamp?: Date;
}

function serializeAssistantApiSettingsReauthTrustedDeviceSettingsTrustSettings(data: any): AssistantApiSettingsReauthTrustedDeviceSettingsTrustSettings {
  return {
    ...data,
    neverAskExpirationTimestamp: data["neverAskExpirationTimestamp"] !== undefined ? data["neverAskExpirationTimestamp"].toISOString() : undefined,
    trustDeviceExpirationTimestamp: data["trustDeviceExpirationTimestamp"] !== undefined ? data["trustDeviceExpirationTimestamp"].toISOString() : undefined,
  };
}

function deserializeAssistantApiSettingsReauthTrustedDeviceSettingsTrustSettings(data: any): AssistantApiSettingsReauthTrustedDeviceSettingsTrustSettings {
  return {
    ...data,
    neverAskExpirationTimestamp: data["neverAskExpirationTimestamp"] !== undefined ? new Date(data["neverAskExpirationTimestamp"]) : undefined,
    trustDeviceExpirationTimestamp: data["trustDeviceExpirationTimestamp"] !== undefined ? new Date(data["trustDeviceExpirationTimestamp"]) : undefined,
  };
}

/**
 * Specification of which search features can be used.
 */
export interface AssistantApiSettingsSearchFilter {
  state?:  | "UNKNOWN_STATE" | "ALLOW_SAFE_SEARCH" | "BLOCK_SEARCH";
}

/**
 * Settings related to TTS output.
 */
export interface AssistantApiSettingsSpeechOutputSettings {
  speechOutput?:  | "UNSPECIFIED" | "VERBOSE" | "MIN_VERBOSITY" | "HANDS_FREE_ONLY";
}

/**
 * Settings related to speech detection. See go/hotword-settings-on-cloud for
 * more info. Next ID: 16
 */
export interface AssistantApiSettingsSpeechSettings {
  /**
   * Indicates whether Continued Conversation is enabled for this device.
   */
  continuedConversationEnabled?: boolean;
  /**
   * Stores the device model type e.g Pixel.
   */
  deviceModelType?: string;
  /**
   * Whether the device has DSP chip to enable always on hotword detection.
   */
  dspAvailable?: boolean;
  /**
   * Whether hotword has been enabled by the user during navigation.
   */
  hotwordInNavigationEnabled?:  | "UNAVAILABLE" | "ENABLED" | "DISABLED" | "UNDECIDED" | "OPA_DISABLED" | "UNSUPPORTED_LOCALE" | "INCOMPLETE" | "ENABLED_WITHOUT_OPA_AVAILABILITY";
  /**
   * Stores hotword setting status for the locales which don't support voice
   * match.
   */
  hotwordSetting?:  | "UNAVAILABLE" | "ENABLED" | "DISABLED" | "UNDECIDED" | "OPA_DISABLED" | "UNSUPPORTED_LOCALE" | "INCOMPLETE" | "ENABLED_WITHOUT_OPA_AVAILABILITY";
  /**
   * Whether pin/pattern lockscreen has been enabled by the user.
   */
  lockscreenEnabled?: boolean;
  /**
   * Stores if Assistant is available for the user's device/locale, where
   * Enabled means it is available and disabled means it is not.
   */
  opaEligibilityState?:  | "UNAVAILABLE" | "ENABLED" | "DISABLED" | "UNDECIDED" | "OPA_DISABLED" | "UNSUPPORTED_LOCALE" | "INCOMPLETE" | "ENABLED_WITHOUT_OPA_AVAILABILITY";
  /**
   * Stores if Assistant is available for the user's device/locale. Deprecated
   * as bools do not give accurate true/false ratios due to old clients
   * reporting the default value.
   */
  opaEligible?: boolean;
  /**
   * Stores the Android SDK version. This comes from
   * android.os.Build.VERSION.SDK_INT.
   */
  sdkVersion?: number;
  /**
   * Whether speaker ID model is present for the user.
   */
  speakerIdModelPresent?: boolean;
  /**
   * Indicates whether the user has enabled speaker-id (fromAnyScreen/alwaysOn)
   * for this device. Deprecated - use voice_match_setting instead
   */
  speakerIdRecognitionEnabled?: boolean;
  /**
   * Indicates whether the user has enabled trusted voice for this device.
   */
  trustedVoiceEnabled?: boolean;
  /**
   * A bool indicating whether device supports unlocking device with hotword.
   */
  unlockWithHotwordAvailable?: boolean;
  /**
   * Stores if user was migrated from undecided to declined as apart of Mariko
   * project. Used for potential growth targeting.
   */
  userMigratedToDeclined?: boolean;
  /**
   * Stores the hotword/voice match setting status for the locales which
   * support voice match.
   */
  voiceMatchSetting?:  | "UNAVAILABLE" | "ENABLED" | "DISABLED" | "UNDECIDED" | "OPA_DISABLED" | "UNSUPPORTED_LOCALE" | "INCOMPLETE" | "ENABLED_WITHOUT_OPA_AVAILABILITY";
}

export interface AssistantApiSettingsTetheredInfo {
  /**
   * The host this wearable is tethered to (e.g. phone). When host is AGSA then
   * this is agsa_client_instance_id. When host is IOPA then this is
   * opa_ios_device_id.
   */
  primaryHostDeviceId?: string;
}

/**
 * Specification of which third party apps can be used.
 */
export interface AssistantApiSettingsThirdPartyAppsFilter {
  state?:  | "UNKNOWN_STATE" | "ALLOW_ALL" | "ALLOW_CERTIFIED_FOR_FAMILIES" | "BLOCK_ALL";
}

/**
 * Specification of which video features can be used.
 */
export interface AssistantApiSettingsVideoFilter {
  /**
   * State that indicates whether autoplay is enabled for youtube videos.
   */
  autoplayToggleState?:  | "UNKNOWN_STATE" | "ENABLED" | "DISABLED";
  /**
   * Providers available at the time user updated settings.
   */
  availableProviders?:  | "UNKNOWN_VIDEO_PROVIDER" | "YOUTUBE" | "YOUTUBE_TV" | "YOUTUBE_KIDS"[];
  /**
   * Represents the state for the video provider filter.
   */
  providerFilterState?:  | "UNKNOWN_STATE" | "ALLOW_ALL_PROVIDERS" | "ALLOW_WHITELISTED_PROVIDERS";
  state?:  | "UNKNOWN_STATE" | "ALLOW_ALL" | "BLOCK_MATURE_CONTENT" | "BLOCK_ALL";
  /**
   * Contains the list of whitelisted video providers.
   */
  whitelistedProviders?:  | "UNKNOWN_VIDEO_PROVIDER" | "YOUTUBE" | "YOUTUBE_TV" | "YOUTUBE_KIDS"[];
}

/**
 * Specification of which webview features can be used.
 */
export interface AssistantApiSettingsWebviewFilter {
  /**
   * Indicates if user has consented Jasper warning message.
   */
  jasperWebviewConsent?: boolean;
  state?:  | "UNKNOWN_STATE" | "ALLOW_ALL_WEBSITES" | "BLOCK_ALL_WEBSITES";
}

/**
 * The method of sign in which the client supports.
 */
export interface AssistantApiSignInMethod {
  method?:  | "UNSPECIFIED" | "NOT_ALLOWED" | "PHONE_APP" | "ON_DEVICE_MENU" | "WEB_APP";
  /**
   * Make Google sign-in mandatory for using Google Assistant on the device.
   */
  signInRequired?: boolean;
}

/**
 * Capabilities related to SODA (Speech On-Device API). Next ID: 5
 */
export interface AssistantApiSodaCapabilities {
  /**
   * Whether the device supports different levels of hotword sensitivity.
   * go/hotword-sensitivity-prd
   */
  supportsHotwordSensitivity?: boolean;
  /**
   * Whether Simple Stop (go/simple-stop) is enabled on the device. Simple stop
   * allows users to stop firing alarms and timers by just saying "stop" without
   * first saying the hotword.
   */
  supportsSimpleStop?: boolean;
  /**
   * Whether the device supports speaker-id (speaker identification based on
   * hotword and/or spoken query - go/speaker-id). Note: there are existing
   * devices that support speaker-id but does not have this capability set. Not
   * having this field populated doesn't necessarily mean the device doesn't
   * support speaker-id.
   */
  supportsSpeakerId?: boolean;
  /**
   * Whether the device supports WarmWords (go/warm-words-framework).
   */
  supportsWarmWords?: boolean;
}

/**
 * These capabilities represent what software features the client supports.
 * This should be determined based on the client's various software versions
 * (OS, GSA version, etc). Next ID: 27
 */
export interface AssistantApiSoftwareCapabilities {
  /**
   * IMPORTANT: Only one of AppCapabilities and AppCapabilitiesDelta should be
   * in the SoftwareCapabilities. In the edge case if the client sends up both
   * AppCapabilities and AppCapabilitiesDelta, AppCapabilitiesDelta is ignored.
   * Complete list of app capabilities.
   */
  appCapabilities?: AssistantApiAppCapabilities[];
  /**
   * Incremental update for app capabilities.
   */
  appCapabilitiesDelta?: AssistantApiAppCapabilitiesDelta[];
  /**
   * App integrations settings for each packge name.
   */
  appIntegrationsSettings?: {
    [key: string]: AssistantApiAppIntegrationsSettings
  };
  /**
   * Capabilities related to Assistant on Auto surfaces.
   */
  carAssistantCapabilities?: AssistantApiCarAssistantCapabilities;
  /**
   * Capabilities related to clock functionality, like alarms, timers, etc.
   */
  clockCapabilities?: AssistantApiClockCapabilities;
  /**
   * A top-level version of Conversation protocol where the versions are
   * explicitly defined at go/conversation-versions.
   */
  conversationVersion?: AssistantApiSupportedConversationVersion;
  /**
   * For torus x-device execution support
   */
  crossDeviceExecutionCapabilities?: AssistantApiCrossDeviceExecutionCapability;
  gacsCapabilities?: AssistantApiGacsCapabilities;
  gcmCapabilities?: AssistantApiGcmCapabilities;
  /**
   * Google Home app features.
   */
  homeAppCapabilities?: AssistantApiCapabilitiesHomeAppCapabilities;
  /**
   * Capabilities related to live TV channels.
   */
  liveTvChannelCapabilities?: AssistantApiLiveTvChannelCapabilities;
  /**
   * List of actions OEM supports. This includes built-in actions and custom
   * actions.
   */
  oemCapabilities?: AssistantApiOemCapabilities;
  /**
   * on-device Assistant capabilities
   */
  onDeviceAssistantCapabilities?: AssistantApiOnDeviceAssistantCapabilities;
  /**
   * Capability bits for on-device Smart Home. go/framework-for-local-semex
   */
  onDeviceSmartHomeCapabilities?: AssistantApiOnDeviceSmartHomeCapabilities;
  /**
   * Reflects the storage capabilities on the device.
   */
  onDeviceStorageCapabilities?: AssistantApiOnDeviceStorageCapabilities;
  /**
   * The operating system of the device.
   */
  operatingSystem?:  | "OS_TYPE_UNKNOWN" | "OS_TYPE_ANDROID" | "OS_TYPE_CAST" | "OS_TYPE_FUCHSIA" | "OS_TYPE_LINUX";
  /**
   * An ordered list containing the live tv providers available in the client.
   * The order of the providers reflects the ranking in the client and will be
   * respected by server as well.
   */
  orderedLiveTvProviders?: AssistantApiLiveTvProvider[];
  /**
   * The Soli capabilities on Elaine. go/dingo-dc-software
   */
  selinaCapabilities?: AssistantApiSelinaCapabilites;
  settingsAppCapabilities?: AssistantApiSettingsAppCapabilities;
  supportedClientOp?: AssistantApiSupportedClientOp[];
  supportedFeatures?: AssistantApiSupportedFeatures;
  supportedMsgVersion?: AssistantApiSupportedProtocolVersion;
  supportedProviderTypes?: AssistantApiSupportedProviderTypes;
  surfaceProperties?: AssistantApiSurfaceProperties;
}

function serializeAssistantApiSoftwareCapabilities(data: any): AssistantApiSoftwareCapabilities {
  return {
    ...data,
    appCapabilities: data["appCapabilities"] !== undefined ? data["appCapabilities"].map((item: any) => (serializeAssistantApiAppCapabilities(item))) : undefined,
    appCapabilitiesDelta: data["appCapabilitiesDelta"] !== undefined ? data["appCapabilitiesDelta"].map((item: any) => (serializeAssistantApiAppCapabilitiesDelta(item))) : undefined,
    clockCapabilities: data["clockCapabilities"] !== undefined ? serializeAssistantApiClockCapabilities(data["clockCapabilities"]) : undefined,
    gacsCapabilities: data["gacsCapabilities"] !== undefined ? serializeAssistantApiGacsCapabilities(data["gacsCapabilities"]) : undefined,
    oemCapabilities: data["oemCapabilities"] !== undefined ? serializeAssistantApiOemCapabilities(data["oemCapabilities"]) : undefined,
    orderedLiveTvProviders: data["orderedLiveTvProviders"] !== undefined ? data["orderedLiveTvProviders"].map((item: any) => (serializeAssistantApiLiveTvProvider(item))) : undefined,
    supportedClientOp: data["supportedClientOp"] !== undefined ? data["supportedClientOp"].map((item: any) => (serializeAssistantApiSupportedClientOp(item))) : undefined,
    supportedFeatures: data["supportedFeatures"] !== undefined ? serializeAssistantApiSupportedFeatures(data["supportedFeatures"]) : undefined,
  };
}

function deserializeAssistantApiSoftwareCapabilities(data: any): AssistantApiSoftwareCapabilities {
  return {
    ...data,
    appCapabilities: data["appCapabilities"] !== undefined ? data["appCapabilities"].map((item: any) => (deserializeAssistantApiAppCapabilities(item))) : undefined,
    appCapabilitiesDelta: data["appCapabilitiesDelta"] !== undefined ? data["appCapabilitiesDelta"].map((item: any) => (deserializeAssistantApiAppCapabilitiesDelta(item))) : undefined,
    clockCapabilities: data["clockCapabilities"] !== undefined ? deserializeAssistantApiClockCapabilities(data["clockCapabilities"]) : undefined,
    gacsCapabilities: data["gacsCapabilities"] !== undefined ? deserializeAssistantApiGacsCapabilities(data["gacsCapabilities"]) : undefined,
    oemCapabilities: data["oemCapabilities"] !== undefined ? deserializeAssistantApiOemCapabilities(data["oemCapabilities"]) : undefined,
    orderedLiveTvProviders: data["orderedLiveTvProviders"] !== undefined ? data["orderedLiveTvProviders"].map((item: any) => (deserializeAssistantApiLiveTvProvider(item))) : undefined,
    supportedClientOp: data["supportedClientOp"] !== undefined ? data["supportedClientOp"].map((item: any) => (deserializeAssistantApiSupportedClientOp(item))) : undefined,
    supportedFeatures: data["supportedFeatures"] !== undefined ? deserializeAssistantApiSupportedFeatures(data["supportedFeatures"]) : undefined,
  };
}

/**
 * DEPRECATED These capabilties are associated with speech detection on
 * devices.
 */
export interface AssistantApiSpeechCapabilities {
  /**
   * A bool indicating whether device supports dsp based hotword detection.
   */
  dspAvailable?: boolean;
  /**
   * A bool indicating whether device supports unlocking device with hotword.
   */
  unlockWithHotwordAvailable?: boolean;
}

/**
 * Next ID: 18
 */
export interface AssistantApiSuggestionsSupport {
  /**
   * Whether client supports user impersonation on suggestion chip click.
   * go/suggestion-click-impersonation
   */
  clickImpersonationSupported?: boolean;
  /**
   * Whether client supports suggestions debug data to be displayed.
   */
  debugDataSupported?: boolean;
  /**
   * Whether DRL history chip is supported. Related bug: http://b/241837879,
   * http://b/171854732 Design doc: http://go/panthera-history-chip-dd DRL
   * history chip was originally rolled out to Panthera in
   * http://google3/googledata/experiments/mobile/agsa/studies/agsa_nga/opa_panthera_one_input_ui_launch.gcl?l=55&rcl=384682900.
   * We plan to roll it out to NGA and TNG. drl_history_chip_supported bit
   * specifies whether the client support (and should have) DRL history chip.
   */
  drlHistoryChipSupported?: boolean;
  /**
   * Whether client supports escape hatches aka post execution suggestions
   * go/nga-escape-hatch-prd
   */
  escapeHatchSupported?:  | "UNSUPPORTED" | "NGA_ESCAPE_HATCH";
  /**
   * Whether the client can rewrite suggestion query text into executed text,
   * if the latter is present. If this feature is disabled, the rewrite happens
   * in Assistant Server.
   */
  executedTextSupported?: boolean;
  /**
   * Whether the client supports passing back `execution_context` from
   * |assistant.api.client_op.SuggestionProcessingParams| when the suggestion is
   * clicked or spoken.
   */
  executionContextSupported?: boolean;
  /**
   * Whether the client supports features in |SuggestionFeatureSpecificAction|.
   */
  featureSpecificActionSupport?: AssistantApiFeatureSpecificActionSupport;
  /**
   * Whether the client supports handling App Actions' notification when the
   * suggestion is clicked. This will allow the server to populate the
   * `app_actions_notification_data` extension field from
   * |SuggestionFeatureSpecificAction| proto message.
   */
  featureSpecificAppActionsNotificationSupported?: boolean;
  /**
   * Whether the multi-step try saying suggestion feature is supported. dd:
   * go/tng-multi-step-simplified
   */
  multiStepTrySayingSupported?: boolean;
  /**
   * Whether the rule_id field in the execution_context is supported. This is a
   * temporary workaround to be able to identify clicks on Person entity
   * suggestions on Sabrina and is expected to be eventually deprecated.
   * TODO(b/185517153) : Deprecate (but do not delete) once click tracking is
   * correctly sent up from the Katniss client.
   */
  ruleIdInExecutionContextSupported?: boolean;
  /**
   * Whether the client can show executed_text after the click on the
   * suggestion chip. Must be set to false on TNG. TNG disregards
   * |SuggestionProcessingParams.show_executed_text| field and always treats it
   * as if |show_executed_text=true|.
   */
  showExecutedTextSupported?: boolean;
  /**
   * Whether the client can show chip as (text | translation).
   * go/lang-partner-doc
   */
  showTranslationSupported?: boolean;
  /**
   * A list of suggestions display targets supported by this client. If unset
   * only DEFAULT SuggestionDisplayTarget is supported.
   */
  supportedDisplayTargets?: AssistantApiSuggestionsSupportDisplayTargetSupport[];
  /**
   * Whether client supports widget suggestion chip to be displayed.
   */
  widgetDataSupported?: boolean;
}

export interface AssistantApiSuggestionsSupportDisplayTargetSupport {
  /**
   * Whether the client can rewrite suggestion query text into executed text,
   * if the latter is present for the display target.
   */
  executedTextSupported?: boolean;
  /**
   * Whether PresentationParams.header_text is supported for the display
   * target.
   */
  headerTextSupported?: boolean;
  /**
   * Whether Suggestion.repress_impression is supported. If not repressed
   * suggestions are not returned.
   */
  repressImpressionSupported?: boolean;
  /**
   * Display target that is supported.
   */
  target?:  | "DEFAULT" | "NGA_INPUT_PLATE" | "CONVERSATION_STARTERS" | "QUICK_ACTIONS" | "TACTILE_ASSISTANT_SUGGESTS" | "TACTILE_MY_ACTIONS" | "TRY_SAYING" | "RICH_SUGGESTIONS";
}

export interface AssistantApiSunriseFeaturesSupport {
  /**
   * If true, the device can slowly brighten the screen and simulate sunrise
   * experience. Alarms with sunrise field enabled can be set on this device.
   */
  sunriseSimulationSupported?: boolean;
}

/**
 * These are the set of ClientOps that are supported by the device.
 */
export interface AssistantApiSupportedClientOp {
  /**
   * This should be the same as the name of the SemanticClientOp that is
   * supported.
   */
  clientOpName?: string;
  /**
   * The properties associated with the ClientOp. This proto should be
   * associated with the client_op_name.
   */
  clientOpProperties?: AssistantApiProtobuf;
  supportedExecution?: AssistantApiSupportedClientOpSupportedExecution;
  /**
   * A version of 0 is the equivalent to not having support for that client_op
   * type. Note that a client_op is also unsupported if it is not included at
   * all in the list of supported client_ops.
   */
  version?: number;
}

function serializeAssistantApiSupportedClientOp(data: any): AssistantApiSupportedClientOp {
  return {
    ...data,
    clientOpProperties: data["clientOpProperties"] !== undefined ? serializeAssistantApiProtobuf(data["clientOpProperties"]) : undefined,
  };
}

function deserializeAssistantApiSupportedClientOp(data: any): AssistantApiSupportedClientOp {
  return {
    ...data,
    clientOpProperties: data["clientOpProperties"] !== undefined ? deserializeAssistantApiProtobuf(data["clientOpProperties"]) : undefined,
  };
}

/**
 * Additional properties that client can support for executing the client op.
 * They are surface-specific execution properties and are unrelated to the
 * execution model.
 */
export interface AssistantApiSupportedClientOpSupportedExecution {
  /**
   * ClientOp execution supports special rendering behavior while the user is
   * in the middle of expressing their query. This behavior includes: 1) New
   * partial output always over-writes prior partial output. 2) Canceling the
   * interaction removes partial fulfilment from any user visible interaction
   * history. If this is true, whether to apply the special rendering behavior
   * will be determined by PartialFulfillmentRenderingParams. More details can
   * be found at go/ma-natcon-pf-api.
   */
  supportsPartialFulfillment?: boolean;
  /**
   * Client can support synchronous execution of the client op. For tts.OUTPUT
   * client op it means that client would honor |synchronous_playback_args|
   * argument. Please see more at go/synchronous-sounds-design.
   */
  supportsSynchronousExecution?: boolean;
}

/**
 * The overall Conversation Protocol version. As we make fundamental changes to
 * Conversation protocol that are non-backwards compatible, we will increment
 * the protocol version. By default, all clients will support version 0. All
 * versions are documented at go/conversation-versions.
 */
export interface AssistantApiSupportedConversationVersion {
  /**
   * Whether conversation protocol is supported explicitly. If true,
   * SingleDeviceCapabilityChecker::SupportsConversationProtocol will always
   * return true.
   */
  supportsConversationProtocol?: boolean;
  /**
   * The supported version number.
   */
  version?: number;
}

/**
 * These are the set of features that are supported by the device. It's a part
 * of the SoftwareCapabilities of the device. Next ID: 63
 */
export interface AssistantApiSupportedFeatures {
  /**
   * Whether the client supports the alternative message notification sources
   * on AAE, in which case notification-related operations can access it.
   */
  aaeNotificationSourceSupported?: boolean;
  /**
   * In what way is assistant continued presence supported. (go/opa-acp-prd)
   */
  acpSupport?: AssistantApiAssistantContinuedPresenceSupport;
  actionV2SupportedFeatures?: AssistantApiActionV2SupportedFeatures;
  /**
   * Whether the client supports AlarmTimerManager API
   * (go/alarm-timer-manager-api).
   */
  alarmTimerManagerApiSupported?: boolean;
  /**
   * The client information for app control support. More details in: go/acaia.
   */
  appControlSupport?: AssistantApiAppControlSupport;
  /**
   * Whether the client supports the assistant explore section. This field will
   * be active only when the Explore section is available to the user. This
   * means that the user is (a) signed-in, (b) a IOPA / AGSA user, and (c) in a
   * locale where explore is available.
   */
  assistantExploreSupported?: boolean;
  /**
   * Whether Assistant for Kids (a.k.a. Designed for Family) features are
   * supported.
   */
  assistantForKidsSupported?: boolean;
  /**
   * Whether communications flows for the client can bypass the DI/DC check.
   * The client will enforce some other equivalent permission as necessary
   * concerning access to device contacts and apps.
   */
  bypassDiDcCheckForComms?: boolean;
  /**
   * Whether or not Assistant should enforce the dismissal of communication
   * notifications associated with messages.
   */
  bypassMsgNotificationDismissal?: boolean;
  /**
   * Whether the client supports 1m providers (go/1m-partner-expansion).
   */
  client1mProvidersSupported?: boolean;
  /**
   * Whether the client can batch client op results before sending them to the
   * server.
   */
  clientOpResultBatchingSupported?: boolean;
  /**
   * Whether the client supports confirmation flow before announcement of
   * multiple messages. If set to true the user will be prompted once and
   * confirmation will be taken before all the messages are announced.
   */
  confirmationBeforeReadingMultipleMessagesSupported?: boolean;
  /**
   * Whether the client supports cross-device broadcast (i.e. on Torus).
   */
  crossDeviceBroadcastSupported?: boolean;
  /**
   * The version of cross device broadcast (ie; broadcast on torus) which the
   * client supports.
   */
  crossDeviceBroadcastVersion?:  | "CROSS_DEVICE_BROADCAST_NOT_SUPPORTED" | "CROSS_DEVICE_BROADCAST_V1";
  /**
   * Whether the client supports csat visual overlay. (go/sd-od-csat)
   */
  csatVisualOverlaySupported?: boolean;
  /**
   * The features set which duo client on the device supports. This should be
   * serialized from proto {@code duo_client_api.DuoClientApiFeatures}.
   */
  duoClientApiFeatures?: Uint8Array;
  /**
   * Whether the client supports Duo group calling.
   */
  duoGroupCallingSupported?: boolean;
  /**
   * Information about what support this device has for fitness.
   */
  fitnessFeatureSupport?: AssistantApiFitnessFeatureSupport;
  /**
   * Fluid Actions features supported by the client. If this field is not set
   * in the incoming request, it could mean that the client does not support
   * Fluid Actions. Alternatively, it could mean that the client supports Fluid
   * Actions, but syncs state with server using the old protocol, namely
   * ConversationStateParams. When b/140733618 is resolved, Surface Adaptation
   * Layer will add this field for old clients that support Fluid Actions
   * framework.
   */
  fluidActionsSupport?: AssistantApiFluidActionsSupport;
  /**
   * Whether the surface client op performer supports Funtime alarms and
   * timers. go/funtime-engdesign
   */
  funtimeSupported?: boolean;
  /**
   * Whether account linking via Google Deep Integrations (GDI) is supported.
   * go/opa-gdi-design
   */
  gdiSupported?: boolean;
  /**
   * Whether the client supports the Gearhead message notification source, in
   * which case notification-related operations can access it.
   */
  gearheadNotificationSourceSupported?: boolean;
  /**
   * Whether the client has a physical radio installed.
   */
  hasPhysicalRadio?: boolean;
  /**
   * Whether the client supports confirmation messages in Immersive Canvas
   * actions. Deprecated: use the filed in immersive_canvas_support.
   */
  immersiveCanvasConfirmationMessageSupported?: boolean;
  immersiveCanvasSupport?: AssistantApiImmersiveCanvasSupport;
  /**
   * Whether the client supports account linking in-dialog (askForSignIn). This
   * is used before this feature is moved to conversation protocol. To support
   * this, the client needs to: - Integrate with Google Deep Integrations. -
   * Have logic to send the result of account linking back to AS.
   */
  inDialogAccountLinkingSupported?: boolean;
  /**
   * Whether paired-phone contact upload is needed for communications queries
   * to work (e.g. on AAE).
   */
  isPairedPhoneContactUploadNeededForComms?: boolean;
  /**
   * Whether a Bluetooth-paired phone is a core component of communications
   * flows on the client.
   */
  isPairedPhoneNeededForComms?: boolean;
  /**
   * Which way of launching the keyboard the client supports.
   */
  launchKeyboardSupported?:  | "LAUNCH_KEYBOARD_UNSUPPORTED" | "OPA_ANDROID_LAUNCH_KEYBOARD_URI";
  /**
   * Whether the client has Google Lens (Assistant Eyes).
   */
  lensSupported?: boolean;
  /**
   * Whether the surface supports LiveCards. In cases where the user intent
   * flow cannot be completed within the Assistant, LiveCards are used to take
   * the user to an external app or website. These cards will be pushed to the
   * Google Home app via the PushMessage ClientOp.
   */
  liveCardsSupported?: boolean;
  /**
   * Whether the client supports Assistant dialogs within Maps. This field will
   * be set only when the Maps on the surface supports Assistant dialogs
   * embedded within Maps. go/gsa-gmm.
   */
  mapsDialogsSupported?: boolean;
  /**
   * Whether the device supports masquerade mode (go/masquerade).
   */
  masqueradeModeSupported?: boolean;
  /**
   * Information about how client handles media controls (play, pause, skip
   * ...)
   */
  mediaControlSupport?: AssistantApiMediaControlSupport;
  /**
   * The ability of the client to detect media sessions on the device.
   */
  mediaSessionDetection?:  | "UNKNOWN_MEDIA_SESSION_DETECTION" | "RELIABLE_MEDIA_SESSION_DETECTION" | "UNRELIABLE_MEDIA_SESSION_DETECTION" | "NO_MEDIA_SESSION_DETECTION" | "MEDIA_SESSION_DETECTION_DISABLED_SCREEN_CONTEXT";
  /**
   * Whether the client supports joining a Google Meet meeting.
   */
  meetSupported?: boolean;
  /**
   * Whether the client can render no input response or just ignore it. No
   * input response is returned when client has a no speech input interaction,
   * eg. user tapped mic but didn't say anything.
   */
  noInputResponseSupported?: boolean;
  /**
   * When the entry source is search, whether the client supports rendering a
   * similar response as OPA one does. Entry source is defined at
   * http://cs/symbol:assistant.api.params.DeviceProperties.EntrySource
   */
  opaOnSearchSupported?: boolean;
  /**
   * Whether or not the client supports enabling parental controls. When a
   * device to supports parental controls, it has the software necessary to
   * store the relevant information required for parental controls to work. This
   * information includes a boolean "enabled bit" as well as the obfuscated gaia
   * ID of the kid account selected for use with parental controls. Devices
   * supportings kids mode send this information to S3 via S3ClientInfo in every
   * request. See go/aff-kidsproduct for details.
   */
  parentalControlsSupported?: boolean;
  /**
   * Whether the client supports persistent display. The new feature allows
   * Assistant devices with screen to display a continuously updating permanent
   * display, such as ambient weather, without the need for a user to ask the
   * Assistant. Design doc: go/assistant-persistent-display.
   */
  persistentDisplaySupported?: boolean;
  /**
   * Whether the client supports the privacy-aware lockscreen protocol
   * (go/assistant-lockscreen-spec).
   */
  privacyAwareLockscreenSupported?: boolean;
  /**
   * Whether the client has remote casting enabled. For ex: we want to disable
   * this for clients like Auto.
   */
  remoteCloudCastingEnabled?: boolean;
  /**
   * Whether the Assistant Server should generate feedback suggestion chips.
   */
  serverGeneratedFeedbackChipsEnabled?: boolean;
  /**
   * Whether the client supports SmartHome lock screen logic (i.e. on Tangor).
   */
  shLockScreenSupported?: boolean;
  /**
   * Which kind of sign in the client supports.
   */
  signInMethod?: AssistantApiSignInMethod;
  /**
   * Whether the client can monitor sleep. This allows us to show sleep CUJ
   * related information: go/TwilightDesign Use for development only, see the
   * same field in DeviceCapabilities.SoftwareCapabilities.SelinaCapabilities.
   */
  sleepSensingSupported?: boolean;
  /**
   * Whether the client supports smart space cross-device timers.
   * (go/ss-x-device-timer)
   */
  smartspaceCrossDeviceTimerSupported?: boolean;
  /**
   * Whether or not the client supports gesture detection via soli chips. The
   * reason to prepend the name with soli is to distinguish it from computer
   * vision based methods, e.g. Newman devices.
   */
  soliGestureDetectionSupported?: boolean;
  /**
   * Suggestion chips features, supported by the client.
   */
  suggestionsSupport?: AssistantApiSuggestionsSupport;
  /**
   * Whether the client supports the sunrise screen brightening feature before
   * the alarm fires. This is used to indicate whether sunrise alarms can be set
   * on the device.
   * http://cs/symbol:assistant.api.core_types.governed.RingtoneTaskMetadata.GentleWakeInfo
   */
  sunriseFeaturesSupport?: AssistantApiSunriseFeaturesSupport;
  /**
   * Whether the client supports faster optimization for tap_to_read feature.
   */
  tapToReadOptimizationSupported?: boolean;
  /**
   * Whether the device supports the 3p GUI framework, which allows third
   * parties to enter the conversation with the user, showing their logo next to
   * their chat bubbles, etc. go/3p-phone
   */
  thirdPartyGuiSupported?: boolean;
  /**
   * Transactions features, supported by the client. Transactions feature may
   * includes how Transactions team want to populate additional information from
   * the device to the server.
   */
  transactionFeaturesSupport?: AssistantApiTransactionFeaturesSupport;
  /**
   * The version of transactions which the client supports.
   */
  transactionsVersion?:  | "NO_TRANSACTIONS" | "TRANSACTIONS_INITIAL_LAUNCH" | "TRANSACTIONS_V2" | "TRANSACTIONS_V3";
  /**
   * If set, it indicates that the client can open a separate HTML
   * browser/webviewer (full viewer) to display certain visual results. These
   * visual results usually require more memory to render (e.g. high resolution
   * photos). Compared to the regular viewer that display all other Assistant
   * result, the full viewer does not have memory limit. The field is copied
   * from the device model. See
   * http://google3/assistant/devices_platform/proto/device_model_capabilities.proto?l=225&rcl=312576471
   * Also see go/webassistant-full-card-viewer.
   */
  usesSeparateFullViewer?: boolean;
  /**
   * Whether the client supports viewing of reminder hub page or not. Default
   * is supported. Set to true to disable returning reminder hub page url in
   * reminder responses.
   */
  viewReminderHubPageNotSupported?: boolean;
  /**
   * Whether the client supports the programmatic warm welcome tutorial. Design
   * doc: go/opal-pww-design.
   */
  warmWelcomeTutorialSupported?: boolean;
  /**
   * Whether the supports opening a URL in a web browser. For example, we want
   * to disable this for clients like Chirp.
   */
  webBrowserSupported?: boolean;
  /**
   * Whether or not the client supports WhatsNext in the protocol.
   */
  whatsNextSupported?: boolean;
  /**
   * Whether the client supports joining a Zoom meeting.
   */
  zoomSupported?: boolean;
}

function serializeAssistantApiSupportedFeatures(data: any): AssistantApiSupportedFeatures {
  return {
    ...data,
    duoClientApiFeatures: data["duoClientApiFeatures"] !== undefined ? encodeBase64(data["duoClientApiFeatures"]) : undefined,
  };
}

function deserializeAssistantApiSupportedFeatures(data: any): AssistantApiSupportedFeatures {
  return {
    ...data,
    duoClientApiFeatures: data["duoClientApiFeatures"] !== undefined ? decodeBase64(data["duoClientApiFeatures"] as string) : undefined,
  };
}

/**
 * Contains versions of protocol buffer messages. This is the equivalence of a
 * proto3 map, keyed by a protocol buffer message’s name, and the value is the
 * version of this message. e.g. {"assistant.api.core_types.Timer": 2,
 * "assistant.api.core_types.Alarm": 1} See go/assistant-protocol-versioning for
 * more details.
 */
export interface AssistantApiSupportedProtocolVersion {
  messageVersion?: AssistantApiSupportedProtocolVersionMessageVersionPair[];
}

export interface AssistantApiSupportedProtocolVersionMessageVersionPair {
  /**
   * The full path of a message which should start from the package name. e.g.
   * "assistant.api.core_types.Timer".
   */
  messageName?: string;
  /**
   * The supported version number.
   */
  version?: number;
}

/**
 * Types of providers that are supported by the client. For example, ChromeOS
 * support both web app and Android app (for eligible devices).
 */
export interface AssistantApiSupportedProviderTypes {
  supportedTypes?:  | "PROVIDER_TYPE_UNSPECIFIED" | "ANDROID_APP" | "CAST_APP" | "CLOUD_PROVIDER" | "SIP_PROVIDER" | "IOS_APP" | "INTERNAL_PROVIDER" | "WEB_PROVIDER" | "KAIOS_APP" | "HOME_APP" | "CHROMEOS_APP"[];
}

/**
 * Properties of the surface that are not hardware related or feature specific.
 */
export interface AssistantApiSurfaceProperties {
  executionCapabilities?: AssistantApiSurfacePropertiesExecutionCapabilities;
  /**
   * If this field is unset, the response format is unknown
   */
  responseDisplayFormat?:  | "SINGLE_ITEM" | "MULTIPLE_ITEMS" | "FULL_HISTORY";
  /**
   * If true, the client supports receiving multiple responses. See
   * go/multiple-response-in-media-use-cases for more details.
   */
  supportsMultiResponse?: boolean;
}

/**
 * Describes the capabilities that are related to the execution of client ops
 * on the device.
 */
export interface AssistantApiSurfacePropertiesExecutionCapabilities {
  /**
   * Completes the preloading ie., sets up the stage for the execution of
   * client ops on the device while the previous conv delta is being executed.
   * Refer to go/preload-convdelta for more information.
   */
  supportsClientOpPreloading?: boolean;
  /**
   * A value of true indicates that the client supports streaming of
   * non-finalized responses by use of ClientExecutionParams.response_stream_id.
   * and ClientExecutionParams.to_be_finalized.
   */
  supportsNonFinalizedResponses?: boolean;
  /**
   * If true, the client supports receiving non-materialized interactions
   * (go/as-streaming-protocol-nm).
   */
  supportsNonMaterializedInteractions?: boolean;
}

/**
 * Restrictions related to system-level notifications.
 */
export interface AssistantApiSystemNotificationRestrictions {
  categoryState?: AssistantApiSystemNotificationRestrictionsNotificationCategoryState[];
  channelState?: AssistantApiSystemNotificationRestrictionsNotificationChannelState[];
  /**
   * Specifies whether the surface is able to display notifications.
   */
  notificationCapabilities?:  | "NO_NOTIFICATION_CAPABILITY" | "NOTIFICATIONS_DISABLED" | "NOTIFICATIONS_ENABLED";
}

/**
 * Notification channels state for the new server driven channels.
 */
export interface AssistantApiSystemNotificationRestrictionsNotificationCategoryState {
  /**
   * Notification channel type.
   */
  categoryId?: number;
  /**
   * Weather the notifications on this channel are disabled.
   */
  disabled?: boolean;
  disabledReason?:  | "NONE" | "ASSISTANT_CATEGORY_SETTING" | "ASSISTANT_OVERALL_SETTING" | "OS_APP_DISABLED" | "OS_CHANNEL_GROUP_DISABLED" | "OS_CHANNEL_DISABLED";
}

/**
 * Notification channels state.
 */
export interface AssistantApiSystemNotificationRestrictionsNotificationChannelState {
  /**
   * Notification channel type.
   */
  channelType?:  | "TYPE_UNKNOWN" | "TYPE_OPA_PROACTIVE" | "TYPE_OPA_HANDOFF" | "TYPE_OPA_MISC" | "TYPE_OPA_RECOMMENDATIONS" | "TYPE_OPA_PRODUCT_UPDATES" | "TYPE_OPA_THIRD_PARTY";
  /**
   * Whether the notifications on this channel are enabled.
   */
  enabled?: boolean;
}

/**
 * 3P Action Metadata. Next ID: 3
 */
export interface AssistantApiThirdPartyActionConfig {
  /**
   * DeviceActionCapability from DeviceModelPackage.
   */
  deviceActionCapability?: AssistantDevicesPlatformProtoDeviceActionCapability;
  /**
   * List of Action project capabilities.
   */
  projectConfigs?: AssistantApiThirdPartyActionConfigProjectConfig[];
}

function serializeAssistantApiThirdPartyActionConfig(data: any): AssistantApiThirdPartyActionConfig {
  return {
    ...data,
    deviceActionCapability: data["deviceActionCapability"] !== undefined ? serializeAssistantDevicesPlatformProtoDeviceActionCapability(data["deviceActionCapability"]) : undefined,
  };
}

function deserializeAssistantApiThirdPartyActionConfig(data: any): AssistantApiThirdPartyActionConfig {
  return {
    ...data,
    deviceActionCapability: data["deviceActionCapability"] !== undefined ? deserializeAssistantDevicesPlatformProtoDeviceActionCapability(data["deviceActionCapability"]) : undefined,
  };
}

/**
 * Metadata for ActionPackage. Device Actions are disabled by default unless
 * explicitly enabled for the device here, see go/3p-device-actions-v2-design.
 */
export interface AssistantApiThirdPartyActionConfigProjectConfig {
  /**
   * Google cloud project id for which the Action Package or Device Model is
   * registered.
   */
  projectId?: string;
}

export interface AssistantApiThirdPartyCapabilities {
  /**
   * Restrictions for the device to share any data with third party apps. See
   * details in go/atv-dsc.
   */
  dataSharingRestrictions?:  | "DEFAULT_NO_DATA_SHARING_RESTRICTION" | "NO_SHARING_ALLOWED_WITH_THIRD_PARTY" | "SHARING_STATUS_NOT_SET" | "NO_SHARING_ALLOWED_WITH_THIRD_PARTY_FROM_OOBE";
}

/**
 * A civil time relative to a timezone. IMPORTANT: The definition of TimeOfDay
 * proto is being moved to
 * //assistant/api/core_types/governed/datetime_type.proto. All existing
 * references will be updated to point to the new location. If you are adding a
 * reference, use the new one instead.
 */
export interface AssistantApiTimeOfDay {
  /**
   * The hour, in 0...23.
   */
  hour?: number;
  /**
   * The minute, in 0...59.
   */
  minute?: number;
  /**
   * The fraction of seconds in nanoseconds, in 0..999999999.
   */
  nanosecond?: number;
  /**
   * The second, in 0...59. Leap seconds are not supported.
   */
  second?: number;
}

/**
 * An absolute point in time independent of timezone or calendar, based on the
 * proto3 Timestamp (//google/protobuf/timestamp.proto). IMPORTANT: The
 * definition of Timestamp proto is being moved to
 * //assistant/api/core_types/governed/datetime_type.proto. All existing
 * references will be updated to point to the new location. If you are adding a
 * reference, use the new one instead. NOTE: THIS IS NO LONGER RECOMMENDED TO BE
 * USED. It was originally defined separately from google.protobuf.Timestamp due
 * to incompatibility with proto2 syntax. The incompatibility issues have since
 * been resolved and so the Google-wide standard representation of
 * google.protobuf.Timestamp should be preferred. In fact, google.protobuf.*
 * protos in general are now recommended to be used in new APIs.
 */
export interface AssistantApiTimestamp {
  /**
   * Non-negative fractions of a second at nanosecond resolution.
   */
  nanos?: number;
  /**
   * Seconds of UTC time since the Unix epoch.
   */
  seconds?: bigint;
}

function serializeAssistantApiTimestamp(data: any): AssistantApiTimestamp {
  return {
    ...data,
    seconds: data["seconds"] !== undefined ? String(data["seconds"]) : undefined,
  };
}

function deserializeAssistantApiTimestamp(data: any): AssistantApiTimestamp {
  return {
    ...data,
    seconds: data["seconds"] !== undefined ? BigInt(data["seconds"]) : undefined,
  };
}

/**
 * A time zone. Conceptually, a time zone is a set of rules associated with a
 * location that describes a UTC offset and how it changes over time (e.g.
 * Daylight Saving Time). The offset is used to compute the local date and time.
 * IMPORTANT: The definition of TimeZone enum is being moved to
 * //assistant/api/core_types/governed/datetime_type.proto. All existing
 * references will be updated to point to the new location. If you are adding a
 * reference, use the new one instead.
 */
export interface AssistantApiTimeZone {
  /**
   * Time zone in IANA format, e.g. America/Los_Angeles for USA Pacific Time.
   */
  ianaId?: string;
}

export interface AssistantApiTransactionFeaturesSupport {
  /**
   * If true, setting this boolean means the device should not support voice
   * PIN. For example, although the phone supports both voice and PIN pad, but
   * we don't want users using voice.
   * https://docs.google.com/document/d/1M8iJQX3GuxGZGeidS8Gl4KJt3LuBWAIlolPlW10DkxU/edit#heading=h.8ovvdd3i2thv
   */
  voicePinSuppressed?: boolean;
}

export interface AssistantApiVolumeProperties {
  /**
   * The volume percentages for spelled out values.
   */
  defaultVolumePercentage?: number;
  highVolumePercentage?: number;
  /**
   * The number of levels to move for a step.
   */
  levelStepSize?: number;
  lowVolumePercentage?: number;
  /**
   * The max number of volume levels the client supports.
   */
  maximumVolumeLevel?: number;
  mediumVolumePercentage?: number;
  veryHighVolumePercentage?: number;
  veryLowVolumePercentage?: number;
}

/**
 * Capability with regard to support of alarms by the client.
 */
export interface AssistantDevicesPlatformProtoAlarmCapability {
  /**
   * Maximum number of alarms that can be created on the client. Zero or unset
   * indicates no maximum limit.
   */
  maxSupportedAlarms?: number;
  /**
   * Whether the client restricts alarms to ring within the next 24 hours.
   */
  restrictAlarmsToNextDay?: boolean;
  /**
   * Whether the client supports the STOP alarm action. If this is false, stop
   * actions will be represented by the MUTATE action, and the device may need
   * to check alarm state to determine if there's a firing alarm that needs to
   * be dismissed.
   */
  supportsStopAction?: boolean;
}

export interface AssistantDevicesPlatformProtoArgSpec {
  intValueSpec?: AssistantDevicesPlatformProtoIntValueSpec;
  optionValueSpec?: AssistantDevicesPlatformProtoOptionValueSpec;
  type?:  | "TYPE_UNSPECIFIED" | "BOOL" | "INTEGER" | "OPTION";
}

function serializeAssistantDevicesPlatformProtoArgSpec(data: any): AssistantDevicesPlatformProtoArgSpec {
  return {
    ...data,
    intValueSpec: data["intValueSpec"] !== undefined ? serializeAssistantDevicesPlatformProtoIntValueSpec(data["intValueSpec"]) : undefined,
  };
}

function deserializeAssistantDevicesPlatformProtoArgSpec(data: any): AssistantDevicesPlatformProtoArgSpec {
  return {
    ...data,
    intValueSpec: data["intValueSpec"] !== undefined ? deserializeAssistantDevicesPlatformProtoIntValueSpec(data["intValueSpec"]) : undefined,
  };
}

export interface AssistantDevicesPlatformProtoCallCallCapability {
}

export interface AssistantDevicesPlatformProtoClientReconnectCapability {
}

/**
 * States the cloud capabilities of the device, i.e. the endpoint(s) to use for
 * cloud execution of Actions or Registration.
 */
export interface AssistantDevicesPlatformProtoCloudCapability {
  /**
   * The list of CloudEndpoints supported by this Device Model. Note that each
   * should have a unique |name|. If any cloud endpoints are provided here, then
   * the first one in the list will be used by default for all Cloud Execution.
   * An Intent may override the default by providing an |execution_config|.
   */
  cloudEndpoints?: AssistantDevicesPlatformProtoCloudEndpoint[];
}

/**
 * A cloud endpoints associates with this device, it can be used for query
 * parsing, or cloud execution.
 */
export interface AssistantDevicesPlatformProtoCloudEndpoint {
  /**
   * The name for this cloud endpoint. It's unique per Locale. This is not an
   * API resource name. Ex: sample-nlu-endpoint
   */
  name?: string;
  /**
   * The list of scopes to be provided in the OAuth2 token. They must be a
   * subset of the scopes registered in the Account Linking flow, or the request
   * will fail. If the client itself provides the token, then this field is
   * ignored.
   */
  scopes?: string[];
  /**
   * The URL for this endpoint, it must start with https.
   */
  url?: string;
}

/**
 * This capability represents device action needed capability. Next ID: 10
 */
export interface AssistantDevicesPlatformProtoDeviceActionCapability {
  /**
   * Integrate your device with Google's Smart Home solution by putting your
   * device into Google's Home Graph, a database that stores and provides
   * contextual data about the home and its devices. For example, Home Graph can
   * store the concept of a living room that contains multiple types of devices,
   * when you say "turn on the light" to a device, if you have light in the
   * living room, that light will be turned on.
   */
  assistantDeviceInRoomOptOut?: boolean;
  /**
   * Specifies behavior for built-in device actions for this device model. If
   * not specified, defaults to ENABLE_CONFIGURED_INTENTS_ONLY.
   */
  builtInIntentMode?:  | "INTENT_MODE_UNSPECIFIED" | "ENABLE_ALL" | "ENABLE_ALL_AUTO_ACTIONS" | "ENABLE_CONFIGURED_INTENTS_ONLY" | "PUNT_FOR_UNCONFIGURED_INTENTS";
  /**
   * Specifies which custom device actions should be enabled for this device
   * model. This will only affect the behavior of intents corresponding to those
   * from the Action Package of this project. If not specified, defaults to
   * ENABLE_ALL.
   */
  customIntentMode?:  | "INTENT_MODE_UNSPECIFIED" | "ENABLE_ALL" | "ENABLE_ALL_AUTO_ACTIONS" | "ENABLE_CONFIGURED_INTENTS_ONLY" | "PUNT_FOR_UNCONFIGURED_INTENTS";
  /**
   * Default instructions for routing of any Intent. The data here could be
   * overridden for specific Intents if provided directly in the 'intents'
   * field.
   */
  defaultExecutionConfig?: AssistantDevicesPlatformProtoExecutionConfig;
  /**
   * Specifies capabilities for device actions that are inlined in the
   * google.assistant.embedded.v1.DeviceAction message.
   */
  inlinedActionCapability?: AssistantDevicesPlatformProtoInlinedActionCapability;
  /**
   * Intent configurations. Built-in and custom intents may be configured here.
   * Note that built-in intents will always behave with IntentMode of
   * ENABLE_CONFIGURED_INTENTS_ONLY. The IntentMode for custom intents can be
   * changed using the custom_intent_mode. To configure an intent, list it here
   * with its intent name, e.g. "MY_CUSTOM_INTENT",
   * "google.assistant.car.model.capabilities.AC_TEMPERATURE".
   */
  intents?: AssistantDevicesPlatformProtoIntent[];
  /**
   * Provided data which augments the device action capabilities. Some built-in
   * intents may require additional configuration to be provided. One example
   * could be the list of channels available for the
   * `action.intent.SelectChannel` intent.
   */
  providedData?: AssistantDevicesPlatformProtoProvidedData[];
  /**
   * List of built-in traits such as "action.devices.traits.OnOff" See
   * java/com/google/home/graph/service/config/protoconf.pi As of Nov. 2017, we
   * also support custom traits for EAP users. We'll eventually disable custom
   * traits once custom actions are in place.
   */
  traits?: string[];
  /**
   * Specifies the format how Google routes queries to 3P cloud. By default,
   * this field is unset, all partners should get shallow NLU. This is needed
   * *ONLY* for specific partners for strong business reasons.
   */
  understandingConfig?: AssistantDevicesPlatformProtoUnderstandingConfig;
}

function serializeAssistantDevicesPlatformProtoDeviceActionCapability(data: any): AssistantDevicesPlatformProtoDeviceActionCapability {
  return {
    ...data,
    inlinedActionCapability: data["inlinedActionCapability"] !== undefined ? serializeAssistantDevicesPlatformProtoInlinedActionCapability(data["inlinedActionCapability"]) : undefined,
    intents: data["intents"] !== undefined ? data["intents"].map((item: any) => (serializeAssistantDevicesPlatformProtoIntent(item))) : undefined,
  };
}

function deserializeAssistantDevicesPlatformProtoDeviceActionCapability(data: any): AssistantDevicesPlatformProtoDeviceActionCapability {
  return {
    ...data,
    inlinedActionCapability: data["inlinedActionCapability"] !== undefined ? deserializeAssistantDevicesPlatformProtoInlinedActionCapability(data["inlinedActionCapability"]) : undefined,
    intents: data["intents"] !== undefined ? data["intents"].map((item: any) => (deserializeAssistantDevicesPlatformProtoIntent(item))) : undefined,
  };
}

export interface AssistantDevicesPlatformProtoDeviceModifySettingCapability {
  clientOpProperty?: AssistantApiClientOpPropertiesDeviceModifySettingClientOpProperty;
}

export interface AssistantDevicesPlatformProtoDeviceTakePhotoCapability {
}

/**
 * Specifies the routing capabilities of the Intent. It will apply only when
 * the Intent is triggered. Next ID: 8
 */
export interface AssistantDevicesPlatformProtoExecutionConfig {
  /**
   * Instructions for performing a cloud execution request for the Intent when
   * the execution_type is set to CLOUD. If non-empty, then the device execution
   * would be routed to the CloudEndpoint specified by this name. The Account
   * Linking exchange may be performed to fetch the OAuth access token, and the
   * access token will be included in the HTTP header.
   */
  cloudEndpointName?: string;
  /**
   * If this field is set, then the Syndication cloud call will be disabled for
   * this intent. Note this only applies if any Syndication cloud endpoint is
   * associated with the Device Model, otherwise setting this field does
   * nothing. By default, all Intents that are enabled and supported by the
   * Syndication API will be routed through the Syndication cloud endpoint if
   * it's provided.
   */
  cloudIntentTranslationDisabled?: boolean;
  /**
   * Specifies the intent command format for this Action. For example, in order
   * to launch an Android intent instead of receiving the device action payload
   * on the client, then this field can be set with
   * "intent:/#Intent;...;my_extra={$.params.channels[0].channelCode};end" The
   * parameter "{$.params.channels[0].channelCode}" is in JSON path format, and
   * will be replaced with the content from the original device action payload.
   * Thus, with # JSON "execution": [ { "command":
   * "action.devices.commands.SelectChannel", "params": { "channels": [{
   * "channelName": "exampleChannel", "channelCode": "1-1" }] } } ] as the
   * original action result, then the final result would look like
   * "intent:/#Intent;...;my_extra=\"1-1\";end"
   */
  intentCommandFormat?: string;
  /**
   * If this field is set, then local execution capability is disabled for all
   * matching intents.
   */
  localDisabled?: boolean;
  /**
   * Specifies how to execute this Action when it is invoked locally (from the
   * same device.)
   */
  localExecutionType?:  | "DEFAULT" | "CLOUD";
  /**
   * If this field is set, then remote execution capability is disabled for all
   * matching intents.
   */
  remoteDisabled?: boolean;
  /**
   * Specifies how to execute this Action when it is invoked remotely (from a
   * different device.)
   */
  remoteExecutionType?:  | "DEFAULT" | "CLOUD";
}

export interface AssistantDevicesPlatformProtoInlinedActionCapability {
  /**
   * Specifies capabilities for handling on-device alarms. The presence of this
   * field, even if empty, implies that the device supports alarms.
   */
  alarm?: AssistantDevicesPlatformProtoAlarmCapability;
  /**
   * Specifies the size limits on responses. If message is not defined then no
   * limits exist.
   */
  responseLimits?: AssistantDevicesPlatformProtoResponseLimits;
  /**
   * Specifies capabilities for handling assistant.embedded.v1.DeviceOp.
   */
  supportedDeviceOps?: AssistantDevicesPlatformProtoSupportedDeviceOps;
  /**
   * Whether this device model package support sdk.EXECUTE client_op (a.k.a
   * action.devices.EXECUTE intent), which will be filled into
   * google.assistant.embedded.v1.DeviceAction.device_request_json. It is
   * default to true (and not public), since all 3P will depends on the
   * device_request_json. Only internal projects like Edoras will set this to
   * false.
   */
  supportSdkExecute?: boolean;
  /**
   * Specifies whether server can send a series of responses for a single
   * query. Example: Routines where multiple actions to be executed one after
   * another.
   */
  supportsMultiResponse?: boolean;
  /**
   * Specifies capabilities for handling on-device timers. The presence of this
   * field, even if empty, implies that the device supports timers.
   */
  timer?: AssistantDevicesPlatformProtoTimerCapability;
}

function serializeAssistantDevicesPlatformProtoInlinedActionCapability(data: any): AssistantDevicesPlatformProtoInlinedActionCapability {
  return {
    ...data,
    timer: data["timer"] !== undefined ? serializeAssistantDevicesPlatformProtoTimerCapability(data["timer"]) : undefined,
  };
}

function deserializeAssistantDevicesPlatformProtoInlinedActionCapability(data: any): AssistantDevicesPlatformProtoInlinedActionCapability {
  return {
    ...data,
    timer: data["timer"] !== undefined ? deserializeAssistantDevicesPlatformProtoTimerCapability(data["timer"]) : undefined,
  };
}

/**
 * An intent configures the behavior of a device action for this device. Next
 * ID: 7
 */
export interface AssistantDevicesPlatformProtoIntent {
  /**
   * List of arguments associated this intent. Each of which depends a template
   * for the expected argument.
   */
  argSpecs?: {
    [key: string]: AssistantDevicesPlatformProtoArgSpec
  };
  /**
   * Instructions for the routing of this Intent.
   */
  executionConfig?: AssistantDevicesPlatformProtoExecutionConfig;
  /**
   * The name of the intent.
   */
  name?: string;
  /**
   * List of provided data names used by this intent. Note that some built-in
   * intents will not function properly without provided data, such as
   * `action.intent.SwitchChannel` or `action.intent.AppSelector`.
   */
  providedDataNames?: string[];
  /**
   * Security configuration for this Intent.
   */
  securityConfig?: AssistantDevicesPlatformProtoSecurityConfig;
  /**
   * The conditions which must be met by the device before executing this
   * Intent. More than one can be provided, in which case the conditions operate
   * with the "AND" operator, i.e. the first condition which is failed will be
   * used to restrict the execution of this Intent.
   */
  triggerConditions?: AssistantDevicesPlatformProtoTriggerCondition[];
}

function serializeAssistantDevicesPlatformProtoIntent(data: any): AssistantDevicesPlatformProtoIntent {
  return {
    ...data,
    argSpecs: data["argSpecs"] !== undefined ? Object.fromEntries(Object.entries(data["argSpecs"]).map(([k, v]: [string, any]) => ([k, serializeAssistantDevicesPlatformProtoArgSpec(v)]))) : undefined,
    triggerConditions: data["triggerConditions"] !== undefined ? data["triggerConditions"].map((item: any) => (serializeAssistantDevicesPlatformProtoTriggerCondition(item))) : undefined,
  };
}

function deserializeAssistantDevicesPlatformProtoIntent(data: any): AssistantDevicesPlatformProtoIntent {
  return {
    ...data,
    argSpecs: data["argSpecs"] !== undefined ? Object.fromEntries(Object.entries(data["argSpecs"]).map(([k, v]: [string, any]) => ([k, deserializeAssistantDevicesPlatformProtoArgSpec(v)]))) : undefined,
    triggerConditions: data["triggerConditions"] !== undefined ? data["triggerConditions"].map((item: any) => (deserializeAssistantDevicesPlatformProtoTriggerCondition(item))) : undefined,
  };
}

/**
 * Capabilities that may only be set internally. Only internal callers (i.e.
 * Googlers or Google owned projects) will be able to set these, thanks to
 * go/assistant-device-model-package-ownership.
 */
export interface AssistantDevicesPlatformProtoInternalCapability {
  /**
   * When using the Assistant SDK (Embedded Assistant API), the project id used
   * to authenticate the gRPC request is checked and must match against the
   * project id of the Device Model. We will additionally allow the project ids
   * listed in the device model here to be let through. See
   * https://docs.google.com/document/d/1InAczpQJs6LCH1l--2yy67JM9hsBJbiL57fusnL3A8A
   */
  allowedAssistantSdkAuthProjectIds?: string[];
  /**
   * Load the assistant.api.AppCapabilities from DEVICE_INSTALLED_APP footprint
   * corpus. See go/edoras-geller.
   */
  appCapabilitiesFromDeviceInstallApps?: boolean;
  /**
   * Uses this endpoint for device action fulfillment when there's no endpoint
   * in syndication_metadata. 1p surfaces/devices such as telephone can enable
   * this for its cloud action fulfillment without enabling the whole
   * syndication experience.
   */
  cloudDeviceActionEndpoint?: AssistantDevicesPlatformProtoCloudEndpoint;
  /**
   * Signals that the model will have updated ranking behavior as described in
   * https://docs.google.com/document/d/1SN_AgadRr_cdIrFe-qgRbIX2J1sOE7lcRXAvM1GUPoU.
   */
  deviceActionsEligibleForHighConfidence?: boolean;
  /**
   * Make Google sign-in mandatory for using Google Assistant on the device.
   * (This bit is initially added for Samsung TV.)
   */
  forceSignIn?: boolean;
  /**
   * When looking up device (for example for disclosure consent check), then
   * always use the third party device id for lookup instead of any other device
   * id which would normally have higher precedence, such as cast_device_id.
   */
  forceThirdPartyDeviceIdForDeviceLookup?: boolean;
  /**
   * Adds "transactions.AUTHENTICATION" for car automation probers. Since the
   * probers run as Assistant SDK requests, voice match always fails for car
   * automation requests, so we add this client op as a hack to allow probers to
   * appear as personal devices and bypass voice match. See b/137221645.
   */
  forceTransactionsAuthentication?: boolean;
  /**
   * Signals that this device can "render" raw search results even with no
   * screen (e.g., using a text reader). If this is true, fallback search
   * results can be returned as a custom device action in a SearchResults
   * message.
   * http://google3/assistant/embedded/proto_translation/utils/proto/search_results.proto
   */
  hasCustomSearchResultsRendering?: boolean;
  /**
   * When looking up device (for example for disclosure consent check), use
   * this project id as part of the primary key for the device lookup (i.e.
   * instead of the device_config.agent_id.) The precedence is as follows: 1)
   * this field, if set for the device's device model 2) device_config.agent_id
   * 3) device_model.project_id
   */
  overrideProjectIdForDeviceLookup?: string;
  stadiaAssistantConfig?: AssistantDevicesPlatformProtoInternalCapabilityStadiaAssistantConfig;
  /**
   * Telephone server is able to send attribution to user feature phone. See
   * go/telephone-attribution.
   */
  telephoneAttribution?: boolean;
}

/**
 * The StadiaAssistantConfig. This field should only be set if the device model
 * is a Stadia.
 */
export interface AssistantDevicesPlatformProtoInternalCapabilityStadiaAssistantConfig {
  stadiaPlatform?:  | "UNSPECIFIED" | "CHROMECAST" | "WEB_BROWSER";
}

export interface AssistantDevicesPlatformProtoIntValueSpec {
  maxValue?: bigint;
  minValue?: bigint;
}

function serializeAssistantDevicesPlatformProtoIntValueSpec(data: any): AssistantDevicesPlatformProtoIntValueSpec {
  return {
    ...data,
    maxValue: data["maxValue"] !== undefined ? String(data["maxValue"]) : undefined,
    minValue: data["minValue"] !== undefined ? String(data["minValue"]) : undefined,
  };
}

function deserializeAssistantDevicesPlatformProtoIntValueSpec(data: any): AssistantDevicesPlatformProtoIntValueSpec {
  return {
    ...data,
    maxValue: data["maxValue"] !== undefined ? BigInt(data["maxValue"]) : undefined,
    minValue: data["minValue"] !== undefined ? BigInt(data["minValue"]) : undefined,
  };
}

export interface AssistantDevicesPlatformProtoMediaNextCapability {
}

export interface AssistantDevicesPlatformProtoMediaPauseCapability {
}

export interface AssistantDevicesPlatformProtoMediaPlayMediaCapability {
}

export interface AssistantDevicesPlatformProtoMediaPreviousCapability {
}

export interface AssistantDevicesPlatformProtoMediaResumeCapability {
}

export interface AssistantDevicesPlatformProtoMediaStopCapability {
}

export interface AssistantDevicesPlatformProtoOptionValueSpec {
  values?: string[];
}

/**
 * Provided data which augments the device action capabilities. Some built-in
 * intents may require additional configuration to be provided. One example
 * could be the list of channels available for the `action.intent.SelectChannel`
 * intent.
 */
export interface AssistantDevicesPlatformProtoProvidedData {
  name?: string;
}

export interface AssistantDevicesPlatformProtoProviderOpenCapability {
  clientOpProperty?: AssistantApiClientOpPropertiesProviderOpenClientOpProperty;
}

/**
 * Specifies the size limits on responses receivable by the client.
 */
export interface AssistantDevicesPlatformProtoResponseLimits {
  /**
   * Max size in bytes of the total serialized AssistResponse receivable by the
   * client. If response exceeds this max, response may be modified by the
   * server.
   */
  maxAssistResponseSizeBytes?: number;
  /**
   * Maximum size in bytes (not characters) of text the display can handle
   * (which may be different from how much the display can show at a time due to
   * scrolling).
   */
  maxDisplayLinesBytes?: number;
  /**
   * Maximum size in bytes (not characters) for each suggestion chip.
   */
  maxSuggestionChipBytes?: number;
  /**
   * Maximum number of suggestion chips the device can handle to display.
   */
  maxSuggestionChips?: number;
}

/**
 * Encapsulates security configuration for a single intent of a device model.
 */
export interface AssistantDevicesPlatformProtoSecurityConfig {
  /**
   * Specifies auth mechanism to be used upon remote request for device action.
   */
  authMechanismForRemoteRequests?:  | "NONE" | "ENABLED" | "FINGERPRINT_OR_PASSWORD" | "PIN";
}

export interface AssistantDevicesPlatformProtoSendChatMessageCapability {
}

/**
 * This message will specify supports for fields in
 * |assistant.embedded.v1.DeviceOp|, for a device model package. See
 * go/easi-client-op2 for more info.
 */
export interface AssistantDevicesPlatformProtoSupportedDeviceOps {
  /**
   * |call_call| specifies the support for the call.CALL clientop, and the
   * corresponding call_call field in assistant.embedded.v1.DeviceOp.
   */
  callCall?: AssistantDevicesPlatformProtoCallCallCapability;
  /**
   * |client_reconnect| indicates support for client.RECONNECT using
   * assistant.embedded.v1.DeviceOp. There is an alternative API/capability for
   * client.RECONNECT specified in RoutineCapability.supports_reconnect. Client
   * should choose between this and RoutineCapability but not both.
   */
  clientReconnect?: AssistantDevicesPlatformProtoClientReconnectCapability;
  /**
   * |device_modify_setting| specifies the support for device.MODIFY_SETTING
   * client_op, and the corresponding device_modify_setting field in
   * assistant.embedded.v1.DeviceOp.
   */
  deviceModifySetting?: AssistantDevicesPlatformProtoDeviceModifySettingCapability;
  /**
   * [device_take_photo] specifies the support for the device.TAKE_PHOTO
   * clientop, and the corresponding device_take_photo field in
   * assistant.embedded.v1.DeviceOp.
   */
  deviceTakePhoto?: AssistantDevicesPlatformProtoDeviceTakePhotoCapability;
  mediaNext?: AssistantDevicesPlatformProtoMediaNextCapability;
  mediaPause?: AssistantDevicesPlatformProtoMediaPauseCapability;
  mediaPlayMedia?: AssistantDevicesPlatformProtoMediaPlayMediaCapability;
  mediaPrevious?: AssistantDevicesPlatformProtoMediaPreviousCapability;
  mediaResume?: AssistantDevicesPlatformProtoMediaResumeCapability;
  mediaStop?: AssistantDevicesPlatformProtoMediaStopCapability;
  /**
   * |provider_open| specifies the support for provider.OPEN client_op, and the
   * corresponding provider_open field in assistant.embedded.v1.DeviceOp.
   */
  providerOpen?: AssistantDevicesPlatformProtoProviderOpenCapability;
  /**
   * |send_chat_message| specifies the support for the chat_message.SEND
   * clientop, and the corresponding send_chat_message field in
   * assistant.embedded.v1.DeviceOp.
   */
  sendChatMessage?: AssistantDevicesPlatformProtoSendChatMessageCapability;
}

/**
 * Capability with regard to support of timers by the client.
 */
export interface AssistantDevicesPlatformProtoTimerCapability {
  /**
   * Maximum extended timer duration supported by the client. The extended
   * timer duration is the total start-to-finish duration after an
   * AddTimeToTimer operation. E.g. if a user sets a timer for 30 minutes, and
   * later adds 10 minutes, the extended duration is 40 minutes. Zero or unset
   * indicates no maximum limit.
   */
  maxSupportedExtendedTimerDuration?: AssistantApiDuration;
  /**
   * Maximum timer duration supported by the client. Zero or unset indicates no
   * maximum limit.
   */
  maxSupportedTimerDuration?: AssistantApiDuration;
  /**
   * Maximum number of timers that can be created on the client. Zero or unset
   * indicates no maximum limit.
   */
  maxSupportedTimers?: number;
  /**
   * Whether the client supports the MUTATE timer action. If this is false,
   * mutate operations may be handled by sending a pair of REMOVE and CREATE
   * timer actions to replace the existing timer instead of mutating it.
   */
  supportsMutateAction?: boolean;
}

function serializeAssistantDevicesPlatformProtoTimerCapability(data: any): AssistantDevicesPlatformProtoTimerCapability {
  return {
    ...data,
    maxSupportedExtendedTimerDuration: data["maxSupportedExtendedTimerDuration"] !== undefined ? serializeAssistantApiDuration(data["maxSupportedExtendedTimerDuration"]) : undefined,
    maxSupportedTimerDuration: data["maxSupportedTimerDuration"] !== undefined ? serializeAssistantApiDuration(data["maxSupportedTimerDuration"]) : undefined,
  };
}

function deserializeAssistantDevicesPlatformProtoTimerCapability(data: any): AssistantDevicesPlatformProtoTimerCapability {
  return {
    ...data,
    maxSupportedExtendedTimerDuration: data["maxSupportedExtendedTimerDuration"] !== undefined ? deserializeAssistantApiDuration(data["maxSupportedExtendedTimerDuration"]) : undefined,
    maxSupportedTimerDuration: data["maxSupportedTimerDuration"] !== undefined ? deserializeAssistantApiDuration(data["maxSupportedTimerDuration"]) : undefined,
  };
}

/**
 * A TriggerCondition is described as a set of states which must be met by the
 * device. It also includes instructions to the Assistant on what kind of
 * response to execute when the condition is not met.
 */
export interface AssistantDevicesPlatformProtoTriggerCondition {
  /**
   * The map of state keys along with their values which must be returned by
   * the device, for example to start the dishwasher you may require states:
   * {"door": "CLOSED", "detergent_status": "READY"}.
   */
  requiredStateValues?: {
    [key: string]: AssistantDevicesPlatformProtoArgSpec
  };
  /**
   * A simple TTS to play.
   */
  simpleTts?: string;
  /**
   * Refers to a defined ConditionalResult keyed by its status. It could be a
   * built-in or custom ConditionalResult for this Intent. Note: the states
   * provided by the device MUST contain all of the states required by the
   * ConditionalResult.
   */
  status?: string;
}

function serializeAssistantDevicesPlatformProtoTriggerCondition(data: any): AssistantDevicesPlatformProtoTriggerCondition {
  return {
    ...data,
    requiredStateValues: data["requiredStateValues"] !== undefined ? Object.fromEntries(Object.entries(data["requiredStateValues"]).map(([k, v]: [string, any]) => ([k, serializeAssistantDevicesPlatformProtoArgSpec(v)]))) : undefined,
  };
}

function deserializeAssistantDevicesPlatformProtoTriggerCondition(data: any): AssistantDevicesPlatformProtoTriggerCondition {
  return {
    ...data,
    requiredStateValues: data["requiredStateValues"] !== undefined ? Object.fromEntries(Object.entries(data["requiredStateValues"]).map(([k, v]: [string, any]) => ([k, deserializeAssistantDevicesPlatformProtoArgSpec(v)]))) : undefined,
  };
}

/**
 * Specifies the NLU level that Google performs, which determines the request
 * format sent to the 3P cloud.
 */
export interface AssistantDevicesPlatformProtoUnderstandingConfig {
  /**
   * Specifies the NLU level for the intent.
   */
  nluLevel?:  | "DEFAULT_SHALLOW_NLU" | "NO_NLU" | "DEEP_NLU";
}

/**
 * The information associated with an error while selecting the target device.
 * Next ID: 2
 */
export interface AssistantDeviceTargetingDeviceTargetingError {
  type?:  | "UNKNOWN_ERROR" | "NO_DEVICE_IN_SAME_STRUCTURE" | "NO_DEVICE_IN_SAME_NETWORK_OR_LOCATION" | "NO_DEVICE_IN_SAME_STRUCTURE_OR_NETWORK_OR_LOCATION" | "NO_DEVICE_SATISFIES_SAME_STRUCTURE_OR_UNKNOWN_IF_OWNED" | "NO_DEVICE_SATISFIES_CAPABILITIES_REQUIREMENT" | "NO_DEVICE_MATCHED_DEVICE_ANNOTATION" | "MULTI_TARGET_DEVICE_NOT_SUPPORTED" | "NO_DEVICE_AFTER_LOCAL_DEVICE_EXCLUDED" | "UNABLE_TO_TARGET_ONLY_LOCAL_DEVICE" | "NO_DEVICE_MATCHED_REQUIRED_TRAITS" | "NO_DEVICE_MATCHED_REQUIRED_ATTRIBUTES" | "NO_DEVICE_MATCHED_REQUIRED_DEVICE_TYPE" | "NO_DEVICE_IN_SAME_OR_MENTIONED_STRUCTURE" | "NO_DEVICE_SATISFIES_PLAYBACK_REQUIREMENT" | "STRUCT_DISAMBIG_NOT_SUPPORTED" | "ROOM_DISAMBIG_NOT_SUPPORTED" | "UNRECOGNIZED_DEVICE_NAME" | "NO_LINKED_REMOTE_DEVICES" | "NO_LINKED_REMOTE_VIDEO_DEVICES" | "NO_SAFE_DEVICE_WITH_SCREEN" | "ALL_QUALIFIED_DEVICES_OFFLINE" | "CROSS_STRUCTURE_TARGETING_DISALLOWED" | "NO_DEVICE_MEETS_PROVIDER_REQUIREMENT" | "MISSING_LOCAL_DEVICE_SETTING" | "NO_DEVICE_HAS_REQUIRED_APP" | "HYBRID_DEVICE_NOT_QUALIFIED" | "NO_NEARBY_DEVICES";
}

export interface AssistantGroundingRankerAssistantInteractionFeatures {
  timeDecayed14dHalfLife?: number;
  /**
   * Frequency features.
   */
  timeDecayed1dHalfLife?: number;
  timeDecayed7dHalfLife?: number;
  timeDecayedAccepted14dHalfLife?: number;
  timeDecayedAuis14dHalfLife?: number;
  timeDecayedCanceled14dHalfLife?: number;
  timeDecayedDeclined14dHalfLife?: number;
  timeSinceLastButOneCanceledActionSecs?: number;
  timeSinceLastButOneCompletedActionSecs?: number;
  timeSinceLastButTwoCanceledActionSecs?: number;
  timeSinceLastButTwoCompletedActionSecs?: number;
  timeSinceLastCanceledActionSecs?: number;
  /**
   * Recency features.
   */
  timeSinceLastCompletedActionSecs?: number;
}

/**
 * Features to be passed from Contact GP to HGR. Next ID: 13
 */
export interface AssistantGroundingRankerContactGroundingProviderFeatures {
  /**
   * Concept id for relationships in English, e.g. "Mother" for all non-English
   * locales. It's only populated for source = RELATIONSHIP.
   */
  conceptId?: string;
  contactSource?:  | "FOCUS_CONTACT" | "DEVICE_CONTACT" | "GMAIL_INFERENCE" | "S3_DECORATOR" | "RELATIONSHIP" | "VANITY" | "SIGNED_OUT_DEVICE" | "SHARED_CONTACT" | "FAMILY_MEMBER" | "SHARED_DEVICE_USER" | "ON_DEVICE_CONTACT_LOOKUP";
  /**
   * Whether the query is a relationship query based on the annotation source.
   */
  isRelationshipFromAnnotation?: boolean;
  /**
   * Whether the contact has relationship in the contact metadata.
   */
  isRelationshipFromSource?: boolean;
  /**
   * Whether only populates a single candidate.
   */
  isSingleCandidate?: boolean;
  /**
   * Whether the contact is starred contact.
   */
  isStarred?: boolean;
  matchedNameType?:  | "UNSPECIFIED" | "GIVEN_NAME" | "FAMILY_NAME" | "FULL_NAME" | "NICKNAME" | "OTHER" | "INITIAL_WITH_FAMILY_NAME" | "EMAIL_USERNAME" | "VANITY_NICKNAME" | "GIVEN_NAME_ALIAS" | "FULL_NAME_ALIAS" | "HOMOPHONE_GIVEN_NAME" | "HOMOPHONE_FAMILY_NAME" | "HOMOPHONE_FULL_NAME" | "HOMOPHONE_NICKNAME" | "GIVEN_MIDDLE_NAME" | "GIVEN_NAME_WITH_FAMILY_NAME_INITIAL" | "EMAIL_OF_FAMILY_MEMBER";
  /**
   * Number of alternate contact names from fuzzy contact match. (Not suggest
   * using it since it can change due to retrieval iteration)
   */
  numAlternateNameFromFuzzyContactMatch?: number;
  /**
   * Number of alternate contact names from S3_HYPOTHESES. (Not suggest using
   * it since it can change due to retrieval iteration)
   */
  numAlternateNamesFromS3?: number;
  /**
   * Number of alternate contact names from interpretation. (Not suggest using
   * it since it can change due to retrieval iteration)
   */
  numAlternativeNamesFromInterpretation?: number;
  /**
   * Number of contacts populated by the contact Grounding Provider. (Not
   * suggest using it since it can change due to retrieval iteration)
   */
  numCandidates?: number;
  recognitionAlternateSource?:  | "NONE" | "S3_HYPOTHESES" | "GENIE_QUERY_ALTERNATIVES" | "NAME_CORRECTION_LOG" | "FUZZY_CONTACT_MATCH" | "NEURAL_CONTACT_MATCH" | "NEURAL_CONTACT_MATCH_DARK_LAUNCH";
}

/**
 * Device contact affinity from android call logs.
 */
export interface AssistantGroundingRankerDeviceContactAffinityFeatures {
  aggregateAffinity?: number;
  callAffinity?: number;
  messageAffinity?: number;
}

/**
 * Next ID: 4
 */
export interface AssistantGroundingRankerGroundingProviderFeatures {
  contactGroundingProviderFeatures?: AssistantGroundingRankerContactGroundingProviderFeatures;
  mediaGroundingProviderFeatures?: AssistantGroundingRankerMediaGroundingProviderFeatures;
  providerGroundingProviderFeatures?: AssistantGroundingRankerProviderGroundingProviderFeatures;
}

export interface AssistantGroundingRankerLaaFeatures {
  bindingSet?: AssistantGroundingRankerLaaFeaturesBindingSet;
  communicationEndpoint?: AssistantGroundingRankerLaaFeaturesCommunicationEndpoint;
  contact?: AssistantGroundingRankerLaaFeaturesContact;
  provider?: AssistantGroundingRankerLaaFeaturesProvider;
}

export interface AssistantGroundingRankerLaaFeaturesBindingSet {
  assistantInteractionFeatures?: AssistantGroundingRankerAssistantInteractionFeatures;
}

export interface AssistantGroundingRankerLaaFeaturesCommunicationEndpoint {
  assistantInteractionFeatures?: AssistantGroundingRankerAssistantInteractionFeatures;
}

export interface AssistantGroundingRankerLaaFeaturesContact {
  assistantInteractionFeatures?: AssistantGroundingRankerAssistantInteractionFeatures;
  deviceContactAffinityFeatures?: AssistantGroundingRankerDeviceContactAffinityFeatures;
}

export interface AssistantGroundingRankerLaaFeaturesProvider {
  assistantInteractionFeatures?: AssistantGroundingRankerAssistantInteractionFeatures;
}

/**
 * Features to be passed from Media GP to HGR. Next ID: 6
 */
export interface AssistantGroundingRankerMediaGroundingProviderFeatures {
  /**
   * Whether the candidate is YouTube CAST_VIDEO candidate. CAST_VIDEO is a
   * deeplink platform. This signal will be used to promote YouTube Music
   * screenful candidates with CAST_VIDEO platform for free users because free
   * users cannot get exact entities in screenless response and can get exact
   * entities with ads in screenful response.
   */
  isCastVideo?: boolean;
  /**
   * True if the media deeplink has tag SEED_RADIO.
   */
  isSeedRadio?: boolean;
  /**
   * True if the user requests seed radio.
   */
  isSeedRadioRequest?: boolean;
  /**
   * MSC(Media Short Click) rate. MSC rate = total number of MSC events / total
   * number of MSC candidates The event is considered as MSC candidate if the
   * event is a media seeking query(excluding follow-ons) and the media result
   * is successfully fulfilled. The event is MSC event if any of the following
   * is in the following queries within 30 secs: FOLLOWED_BY_DUPLICATE
   * FOLLOWED_BY_ADD_OR_DELETE_MANUAL_REFINEMENT FOLLOWED_BY_SAME_VERTICAL
   * (MEDIA) FOLLOWED_BY_STOP More details: go/media-ranking,
   * go/billboard-navboost, go/magma-music-actions-efrac
   */
  mscRate?: number;
  /**
   * Scubed predicted SAI value (pSAI) for music populated by a regression
   * model that incorporates a BERT model signal as well as other Scubed
   * signals.
   */
  scubedPSaiMusic?: number;
}

/**
 * Features to be extracted from Provider GP for ranking in HGR. Next ID: 2
 */
export interface AssistantGroundingRankerProviderGroundingProviderFeatures {
  /**
   * Provider quality score in the range [0,1] that can be used for ranking
   * providers. Incorporates both policy rules and quality considerations.
   */
  pslScore?: number;
}

export interface AssistantLogsAllMediaStreamLog {
  /**
   * All active media streams while the user issues the query.
   */
  streams?: AssistantLogsMediaStreamLog[];
  /**
   * The stream selected by stream transfer logic to be transferred to another
   * device. It will be empty for other features. Target_stream is different
   * from target_device since target_stream could have multiple devices.
   */
  targetStream?: AssistantLogsMediaStreamLog;
}

/**
 * This message logs details on ambiguous device targeting logic. 1. It first
 * takes a list of ambiguous devices 2. Then applies two filters: structure
 * filter and playability filter. 3. If more than one device remains, it tiggers
 * DeviceSelectionDialog to let the user pick one device.
 */
export interface AssistantLogsAmbiguousTargetDeviceLog {
  /**
   * Device index of the initial ambiguous devices. The device index in this
   * message is consistent with the device index in DeviceInfoLog. It would be
   * used to track more detailed information of a device if needed.
   */
  ambiguousDeviceIndex?: number[];
  /**
   * DeviceInfo for devices after the filters and promoters. - When device
   * targeting is only configured for single target, these are ambiguous devices
   * that would have been the output of Lumos. Downstream may perform extra
   * check before disambiguation dialog. For example, Media Initiation checks
   * playability for devices. The output here is before the check. - When
   * configured for multi-target, these are just the target devices. For privacy
   * consideration, we may only log device id field inside.
   */
  devicesAfterPromoters?: AssistantLogsDeviceInfoLog[];
  /**
   * the final targeted device selected by playability filter or
   * DeviceSelectionDialog
   */
  finalTargetDevice?: AssistantLogsDeviceInfoLog;
  /**
   * Device index of the devices after playability filter
   */
  playabilityFilteredDevicesIndex?: number[];
  /**
   * When there is no qualified devices after playability check, it would
   * populate punt_info below. If all devices are filtered out for the same
   * reason, there would only be one item. Otherwise, there will be multiple
   * items.
   */
  puntInfoLog?: AssistantLogsAmbiguousTargetDeviceLogPuntInfoLog[];
  /**
   * Device index of the devices after structure filter
   */
  structureFilteredDeviceIndex?: number[];
}

/**
 * PuntInfoLog is used to log why devices get filtered out during media content
 * playability check. It contains media excuse, provider mid and also index of
 * devices filtered by them.
 */
export interface AssistantLogsAmbiguousTargetDeviceLogPuntInfoLog {
  /**
   * Index of devices that have the same punt info during playability check,
   * i.e. same media_excuse and provider_mid.
   */
  deviceIndex?: number[];
  /**
   * Excuse for media action triggering. See:
   * assistant/verticals/media/proto/media_excuse.proto.
   */
  mediaExcuse?: number;
  /**
   * Provider id that the excuse belongs to. This is the KG MID of the
   * provider, e.g., "/m/09jcvs" for Youtube.
   */
  providerMid?: string;
}

/**
 * This is the log version of
 * apps.people.oz.external.mergedpeopleapi.DeviceContactInfo Next ID: 2
 */
export interface AssistantLogsCommunicationDeviceContactInfoLog {
  /**
   * This list provides account information from the raw contact which is the
   * source of this field.
   */
  rawContactInfo?: AssistantLogsCommunicationRawDeviceContactInfoLog[];
}

/**
 * This is the log version of fuzzy ngram match results that's used for
 * generating the best fuzzy match. Next ID: 3
 */
export interface AssistantLogsCommunicationFuzzyNgramMatchLog {
  relativeCost?: number;
  type?:  | "NONE" | "EDIT_DISTANCE" | "GENIE_PLEXICON_DISTANCE" | "GENIE_ALTERNATIVE_RECOGNITION" | "JAPANESE_NAME_TRANSLITERATOR";
}

/**
 * From google3/quality/qrewrite/proto/account_provenance.proto;l=14 We need to
 * copy this as the above proto has Enum field which is not compatible between
 * proto2 and proto3. go/proto2-versus-proto3#enums
 */
export interface AssistantLogsCommunicationGoogleAccountProvenance {
  email?: string;
  gaiaId?: bigint;
  isDasherAccount?: boolean;
}

function serializeAssistantLogsCommunicationGoogleAccountProvenance(data: any): AssistantLogsCommunicationGoogleAccountProvenance {
  return {
    ...data,
    gaiaId: data["gaiaId"] !== undefined ? String(data["gaiaId"]) : undefined,
  };
}

function deserializeAssistantLogsCommunicationGoogleAccountProvenance(data: any): AssistantLogsCommunicationGoogleAccountProvenance {
  return {
    ...data,
    gaiaId: data["gaiaId"] !== undefined ? BigInt(data["gaiaId"]) : undefined,
  };
}

/**
 * Contact meta data. Next ID: 30
 */
export interface AssistantLogsCommunicationPersonalContactDataLog {
  /**
   * Google AccountProvenance of the contact.
   */
  accountProvenance?: AssistantLogsCommunicationGoogleAccountProvenance;
  /**
   * Populated if matched_name_type is GIVEN_NAME_ALIAS or FULL_NAME_ALIAS.
   */
  commonNameAliasConfidence?: number;
  /**
   * Concept id for relationships in English, e.g. "Mother" for all non-English
   * locales. It's only populated for source = RELATIONSHIP.
   */
  conceptId?: string;
  /**
   * Integer value corresponding to DeviceContactExtraMetadata.Attribute enum.
   * http://google3/social/graph/wire/proto/merged_person.proto?l=933&rcl=320308954
   */
  deviceContactAttributes?: number[];
  /**
   * # emails stored for the contact.
   */
  emailIdCount?: number;
  /**
   * Populate only if ContactRecognitionAlternate.Source is
   * 'FUZZY_CONTACT_MATCH'.
   */
  fuzzyNgramMatch?: AssistantLogsCommunicationFuzzyNgramMatchLog[];
  /**
   * Contact owner's gaia id from
   * cs/symbol::symbol:quality_qrewrite.PersonalContactData.shared_contact_owner_gaia_id.
   * Only populated for is_shared = true and non sign-out mode and user is not
   * the owner of the contact(shared contact from other user).
   */
  gaiaId?: bigint;
  /**
   * Boolean value indicating whether selected contact is from different
   * account than the logged in account.
   */
  isContactFromSecondaryAccount?: boolean;
  /**
   * If this is a shared contact. This is true in 2 cases: - User is calling
   * their own contacts that have been marked as shared. - User is calling
   * shared contacts from some other user's contact list.
   */
  isShared?: boolean;
  /**
   * Indicate the contact matches the transliterated query.
   */
  isTransliteratedMatch?: boolean;
  /**
   * True if the contact is a vanity contact(has email = user's email address).
   */
  isVanityContact?: boolean;
  /**
   * If the lookup was done using relationship which is visible to guests. This
   * value will only be set if lookup was done using relationship. E.g. user has
   * a guest relationship (doctor) -> (John) And user says "call doctor", then
   * this value will be true.
   */
  isVisibleToGuestsRelationship?: boolean;
  /**
   * The matched name type of a contact candidate.
   */
  matchedNameType?:  | "UNSPECIFIED" | "GIVEN_NAME" | "FAMILY_NAME" | "FULL_NAME" | "NICKNAME" | "OTHER" | "INITIAL_WITH_FAMILY_NAME" | "EMAIL_USERNAME" | "VANITY_NICKNAME" | "GIVEN_NAME_ALIAS" | "FULL_NAME_ALIAS" | "HOMOPHONE_GIVEN_NAME" | "HOMOPHONE_FAMILY_NAME" | "HOMOPHONE_FULL_NAME" | "HOMOPHONE_NICKNAME" | "GIVEN_MIDDLE_NAME" | "GIVEN_NAME_WITH_FAMILY_NAME_INITIAL" | "EMAIL_OF_FAMILY_MEMBER";
  /**
   * Alternate recognition term which was used to match this contact.
   */
  matchedRecognitionAlternateName?: string;
  /**
   * Ngram matched by starlight lookup for fuzzy matching in fulfillment. We
   * need this to analyze how many contacts are returned by starlight lookup
   * that is not matched by fuzzy matching. For example, "Komal Dear" is matched
   * to "Komal Dr" by fuzzy match. When doing starlight lookup, "Komal" and "Dr"
   * will be looked up separately. So "Dr xxx" will also be returned. We want to
   * see how often this happens.
   */
  matchedStarlightLookupName?: string[];
  /**
   * PersonMetadata of the selected contact.
   */
  metadata?: AssistantLogsCommunicationPersonMetadataLog;
  /**
   * The indices of the contact in |candidate_contact| whose name matches the
   * |selected_contact_data|. |candidate_contact|:
   * http://google3/logs/proto/assistant/contact.proto?l=111&rcl=306283376
   * |selected_contact_data|:
   * http://google3/logs/proto/assistant/contact.proto?l=108&rcl=306283376
   */
  nameMatchedContactIndex?: number[];
  /**
   * The original name in the query as transcribed by ASR.
   */
  originalQueryName?: string;
  /**
   * Information regarding the phone endpoints of the selected contact.
   * Currently it is only logged for selected candidate.
   */
  phone?: AssistantLogsCommunicationPhoneLog[];
  /**
   * # phone_numbers stored for the contact.
   */
  phoneNumberCount?: number;
  /**
   * Encodes if pkg_person was resolved via a name or relationship reference.
   */
  pkgReferenceType?:  | "UNKNOWN_PKG_REFERENCE_TYPE" | "PKG_NAME_REFERENCE" | "PKG_RELATIONSHIP_REFERENCE";
  /**
   * Populate only if ContactRecognitionAlternate.Source is not NONE.
   */
  recognitionAlternateScore?: number;
  /**
   * Recognition alternative source type. If not none, then it indicates the
   * personal contact data is alternative and how the alternative is fulfilled.
   */
  recognitionAlternateSource?:  | "NONE" | "S3_HYPOTHESES" | "GENIE_QUERY_ALTERNATIVES" | "NAME_CORRECTION_LOG" | "FUZZY_CONTACT_MATCH" | "NEURAL_CONTACT_MATCH" | "NEURAL_CONTACT_MATCH_DARK_LAUNCH";
  /**
   * The number of resolved relationship names and contact pointers from
   * Assistant Memory.
   */
  relationshipMemoryCount?: number;
  /**
   * Information regarding the selected phone endpoint. Currently it is only
   * logged for selected candidate.
   */
  selectedPhone?: AssistantLogsCommunicationPhoneLog;
  /**
   * Shortcut information of the contact.
   */
  shortcutContactInfo?: MajelContactInformationShortcutInformation;
  /**
   * The contact source of a contact candidate.
   */
  source?:  | "UNKNOWN" | "FOCUS_CONTACT" | "DEVICE_CONTACT" | "GMAIL_INFERENCE" | "S3_DECORATOR" | "RELATIONSHIP" | "VANITY" | "SIGNED_OUT_DEVICE" | "SHARED_CONTACT" | "FAMILY_MEMBER" | "SHARED_DEVICE_USER" | "ON_DEVICE_CONTACT_LOOKUP";
  /**
   * Integer value corresponding to SystemContactGroup enum.
   * http://google3/social/graph/wire/proto/merged_person.proto?l=3151&rcl=320308954
   */
  systemContactGroupId?: number[];
  /**
   * DEPRECATED. Use phone instead. Used before 2020-01-13. Number of phone
   * numbers annotated with Whatsapp.
   */
  whatsappPhoneNumberCount?: number;
}

function serializeAssistantLogsCommunicationPersonalContactDataLog(data: any): AssistantLogsCommunicationPersonalContactDataLog {
  return {
    ...data,
    accountProvenance: data["accountProvenance"] !== undefined ? serializeAssistantLogsCommunicationGoogleAccountProvenance(data["accountProvenance"]) : undefined,
    gaiaId: data["gaiaId"] !== undefined ? String(data["gaiaId"]) : undefined,
  };
}

function deserializeAssistantLogsCommunicationPersonalContactDataLog(data: any): AssistantLogsCommunicationPersonalContactDataLog {
  return {
    ...data,
    accountProvenance: data["accountProvenance"] !== undefined ? deserializeAssistantLogsCommunicationGoogleAccountProvenance(data["accountProvenance"]) : undefined,
    gaiaId: data["gaiaId"] !== undefined ? BigInt(data["gaiaId"]) : undefined,
  };
}

/**
 * This is the log version of
 * apps.people.oz.external.mergedpeopleapi.PersonMetadata Next ID: 2
 */
export interface AssistantLogsCommunicationPersonMetadataLog {
  deviceContactInfo?: AssistantLogsCommunicationDeviceContactInfoLog[];
}

/**
 * This is the log version of apps.people.oz.external.mergedpeopleapi.Phone
 * proto. Next ID: 3
 */
export interface AssistantLogsCommunicationPhoneLog {
  /**
   * This list provides account information from the raw contact which is the
   * source of this field.
   */
  rawDeviceContactInfo?: AssistantLogsCommunicationRawDeviceContactInfoLog[];
  /**
   * Label for phone number in the Contacts app. It can have standard values
   * provided by the app e.g. MOBILE, HOME, WORK etc, but users are allowed to
   * modify. So essentially it becomes user content.
   */
  type?: string;
}

/**
 * This is the log version of
 * apps.people.oz.external.mergedpeopleapi.RawDeviceContactInfo proto. Next ID:
 * 3
 */
export interface AssistantLogsCommunicationRawDeviceContactInfoLog {
  /**
   * Account type of raw contact, e.g. "com.google" or "com.linkedin.android".
   */
  accountType?: string;
}

/**
 * Log device info of default speaker and tv
 */
export interface AssistantLogsDefaultDeviceLog {
  defaultSpeaker?: AssistantLogsDeviceInfoLog;
  defaultTv?: AssistantLogsDeviceInfoLog;
  sourceDeviceId?: string;
}

export interface AssistantLogsDefaultDevicesLog {
  localDefaultDevices?: AssistantLogsDefaultDeviceLog;
  /**
   * Default settings of nearby devices.
   */
  nearbyDefaultDevices?: AssistantLogsDefaultDeviceLog[];
}

/**
 * Device annotation mention from query
 */
export interface AssistantLogsDeviceAnnotationLog {
  /**
   * The raw text mentioning a device from the query, such as "any tv".
   */
  rawTextFromQuery?: string;
  /**
   * The annotation type mentioned in the query.
   */
  type?:  | "NO_DEVICE_ANNOTATION" | "DEVICE_ID_ANNOTATION" | "DEVICE_TYPE_ANNOTATION" | "DEVICE_TEXT_ANNOTATION";
  /**
   * The matched device name set by the user, such as "big screen tv".
   */
  userDefinedName?: string;
}

/**
 * The information related to the device.
 */
export interface AssistantLogsDeviceInfoLog {
  /**
   * Device identifier string for the current device used in the arbitration
   * service.
   */
  arbitrationDeviceId?: string;
  connectivity?:  | "UNKNOWN_CONNECTIVITY" | "ONLINE_STATE" | "OFFLINE_STATE";
  /**
   * The identification of the device. DeviceId (go/as-device-id) has multiple
   * fields. To consloidate it to a single to make dremel easier, we use the
   * string obtained by calling go/get-device-id.
   */
  deviceId?: string;
  /**
   * The identification of the device. The logging version of the full
   * DeviceId.
   */
  deviceIdLog?: AssistantLogsSettingsDeviceIdLog;
  /**
   * We index linked devices and log these index to avoid logging device_id.
   * device_index should always be a positive number or -1. -1 means this device
   * is not in homegraph.
   */
  deviceIndex?: number;
  /**
   * This is the device_model_id field in device_settings proto. It has the
   * same value for the same type of devices. e.g. Sonos.Sonos One.S13
   */
  deviceModelId?: string;
  /**
   * 
   * LINT.ThenChange(//depot/google3/assistant/context/proto/device_arbitration.proto:EstimatedRelativeDistance)
   */
  distance?:  | "UNKNOWN_DISTANCE" | "CLOSEST" | "EQUALLY_CLOSE" | "FURTHER";
  /**
   * The lumos processor which eliminated this device, if applicable
   */
  eliminatingLumosProcessor?:  | "UNKNOWN_LUMOS_PROCESSOR" | "CAPABILITIES_FILTER" | "DEVICE_ANNOTATION_FILTER" | "DEVICE_CONNECTIVITY_FILTER" | "LOCAL_DEVICE_INCLUSIVENESS_FILTER" | "LOCATION_FILTER" | "MEDIA_PLAYBACK_FILTER" | "SAFETY_FILTER" | "TRAITS_FILTER" | "DEVICE_TYPE_FILTER" | "APP_FILTER" | "HYBRID_DEVICE_PROPERTIES_FILTER" | "NEARBY_DEVICE_FILTER" | "DEVICE_ATTRIBUTES_FILTER" | "DEFAULT_MEDIA_OUTPUT_PROMOTER" | "DEVICE_GROUP_PROMOTER" | "LOCAL_DEVICE_PROMOTER" | "LOCATION_PROMOTER" | "MEDIA_FOCUS_PROMOTER" | "MEDIA_PLAYBACK_PROMOTER" | "SAME_NAME_DEVICE_PROMOTER" | "PHONE_TARGETING_PROMOTER" | "TRAITS_PROMOTER" | "DEVICE_TYPE_PROMOTER";
  isRemote?: boolean;
  /**
   * This flag indicates this is a non-local device that is tethered to
   * local/originating device. Tethered device is a special case of is_remote
   * and typically used in wearable scenarios. This is always false for local
   * device and when it is true, it implies is_remote is also true.
   */
  isTethered?: boolean;
  mediaCapabilities?: AssistantLogsMediaCapabilities;
  mediaDeviceType?:  | "UNKNOWN_DEVICE_TYPE" | "ASSISTANT" | "HOME_AUTOMATION" | "CAST" | "CAST_GROUP" | "QUARTZ" | "QUARTZ_IOS" | "CLOUD_AUTO";
  /**
   * User defined device name
   */
  name?: string;
  /**
   * This field should be populated only when there is at least one session on
   * this device.
   */
  sessions?: AssistantLogsDeviceMediaSessionLog[];
  /**
   * This field should be populated only when the device is an Assistant
   * device.
   */
  surfaceType?:  | "UNKNOWN" | "ANDROID_ALLO" | "ANDROID_AUTO" | "ANDROID_THINGS_CUBE" | "ANDROID_THINGS_JASPER" | "ANDROID_TV" | "ANDROID_TV_KIDS" | "ANDROID_WEAR" | "AR_GLASSES" | "ASSISTANT_SDK" | "AUDIOWEAR" | "BUBBLE_CHARACTERS_IOS" | "CAPABILITY_BASED_SURFACE" | "CHROMECAST_ASSISTANT" | "CHROMECAST_MANHATTAN" | "CHROMECAST_SEARCH" | "CLOUD_DEVICE" | "COMPANION_SCREEN" | "DYNAMITE_WEB" | "ENSEMBLE" | "EYESFREE_AGSA" | "EYESFREE_GMM" | "GBOARD" | "GLASS" | "GOOGLE_HOME" | "HANGOUTS_CHATBOT" | "IOS_ALLO" | "IOS_GSA" | "IOS_WEAR" | "LIBASSISTANT" | "LINE_CHATBOT" | "MULTIMODAL_AGSA" | "NON_ASSISTANT_SURFACE" | "OPA_AGSA" | "OPA_AGSA_CHROME_OS" | "OPA_ANDROID_AUTO" | "OPA_ANDROID_LITE" | "OPA_ANDROID_SCREENLESS" | "OPA_ANDROID_SMART_DISPLAY" | "OPA_ANDROID_TABLET" | "OPA_CROS" | "OPA_GACS" | "OPA_IOS" | "OPA_IOS_SCREENLESS" | "OPA_KAIOS" | "OPA_MOBILE_WEB" | "RTOS_PHONE" | "SMS_CHATBOT" | "TELEGRAM_CHATBOT" | "TELEPHONE_ASSISTANT" | "VERILY_ONDUO" | "YOUTUBE_APP" | "AGSA_BISTO_FOR_EVAL" | "COGSWORTH_FOR_EVAL" | "LOCKHART_MIC_FOR_EVAL" | "OPA_ANDROID_AUTO_EMBEDDED_FAKE" | "SPARK" | "WALLE" | "UNIT_TESTING";
}

/**
 * Log about the media session on a device.
 */
export interface AssistantLogsDeviceMediaSessionLog {
  deviceId?: AssistantApiCoreTypesDeviceId;
  mediaSessionType?:  | "UNKNOWN" | "SINGLE_DEVICE_SESSION" | "STATIC_GROUP_SESSION" | "DYNAMIC_GROUP_SESSION";
  /**
   * The type of the media session. If provider does not report this field, we
   * ## compute it by mapping provider type to media type. Here is the mapping:
   * |ProviderType |MediaItemMetadata.Type|
   * |-------------------------------------- |MUSIC |TRACK | |VIDEO |VIDEO |
   * |LIVE_TV |TV_CHANNEL | |AUDIOBOOK |AUDIO_BOOK | |PODCAST |PODCAST_EPISODE |
   * ## |LIVE_STREAMING|VIDEO |
   */
  mediaType?:  | "UNKNOWN" | "TRACK" | "ALBUM" | "ARTIST" | "PLAYLIST" | "EPISODE" | "MOVIE" | "PHOTO" | "TV_SHOW_EPISODE" | "MUSIC_GENRE" | "MUSIC_STATION" | "AUDIO_BOOK" | "CHAPTER" | "RADIO_STATION" | "MUSIC_MIX" | "SPORTS_EVENT" | "TV_CHANNEL" | "VIDEO" | "YOUTUBE_CHANNEL" | "YOUTUBE_VIDEO_PLAYLIST" | "TV_SHOW" | "NEWS" | "NARRATED_WEB" | "NEWS_CALL_TO_ACTION" | "AUDIO_STORY" | "PODCAST_SERIES" | "PODCAST_EPISODE";
  /**
   * The playback states of the session.
   */
  playbackState?:  | "UNKNOWN_STATE" | "STOPPED" | "PAUSED" | "PLAYING" | "FAST_FORWARDING" | "REWINDING" | "BUFFERING" | "ERROR" | "CONNECTING" | "SKIPPING_TO_PREVIOUS" | "SKIPPING_TO_NEXT" | "SKIPPING_TO_QUEUE_ITEM";
  /**
   * The KG mid of the media provider.
   */
  providerMid?: string;
  supportedTransportControl?:  | "UNKNOWN_COMMAND" | "PLAY_FROM_SEARCH" | "PLAY_FROM_URI" | "SEND_CUSTOM_ACTION" | "SKIP_TO_NEXT" | "SKIP_TO_PREVIOUS" | "PLAY" | "PAUSE" | "STOP" | "SET_RATING" | "SEEK_TO" | "SHUFFLE" | "REWIND" | "FAST_FORWARD" | "SKIP_TO_QUEUE_ITEM" | "SET_REPEAT_MODE" | "SET_CAPTIONING_ENABLED"[];
}

/**
 * Contains information logged in target device selection. See
 * go/improve-device-targeting-logging for details. Next Id: 22
 */
export interface AssistantLogsDeviceSelectionLog {
  /**
   * Default settings of all nearby devices Deprecated, use default_devices_log
   * instead.
   */
  allDefaultDevices?: AssistantLogsDefaultDeviceLog[];
  /**
   * Logs all active media sessions.
   */
  allMediaStreamLog?: AssistantLogsAllMediaStreamLog;
  /**
   * DeviceSelectionLog for counterfactual logging.
   */
  counterfactualDeviceSelectionLog?: AssistantLogsDeviceSelectionLog;
  /**
   * Include default tv and default speaker Deprecated, use all_default_devices
   * below.
   */
  defaultDevices?: AssistantLogsDefaultDeviceLog;
  defaultDevicesLog?: AssistantLogsDefaultDevicesLog;
  /**
   * Temporaray field for debugging ANDROID_AUTO multi_target_devices punt.
   * This will be removed once we identify the root cause.
   */
  devicesStr?: string[];
  inputErrorLog?: AssistantLogsInputErrorLog[];
  /**
   * Now we just log the media sessions on local device Deprecated, use
   * NearbyDevicesLog::LocalDevice instead.
   */
  localDevice?: AssistantLogsDeviceInfoLog;
  /**
   * Indicates which library populated the device_selection_log for this query.
   */
  logDataSource?:  | "UNKNOWN" | "MEDIA_FOCUS_SELECTOR" | "LUMOS_DEVICE_TARGETING_LIBRARY";
  /**
   * The Media Focus information. This field should be populated only when
   * there is a Media Focus. Deprecated, use media_focuses below instead.
   */
  mediaFocus?: AssistantLogsMediaFocusInfoLog;
  /**
   * Media focuses on all devices.
   */
  mediaFocusesLog?: AssistantLogsMediaFocusesLog;
  /**
   * All nearby devices and local device.
   */
  nearbyDevicesLog?: AssistantLogsNearbyDevicesLog;
  /**
   * This should log the query annotation features found in the device, such as
   * the device annotation, the room annotation, and the structure annotation
   * from the query.
   */
  queryAnnotation?: AssistantLogsQueryAnnotationLog;
  /**
   * The result of device selection.
   */
  selectionResult?: AssistantLogsDeviceSelectionResultLog;
  testCodes?: AssistantLogsDeviceTargetingTestCode[];
}

function serializeAssistantLogsDeviceSelectionLog(data: any): AssistantLogsDeviceSelectionLog {
  return {
    ...data,
    counterfactualDeviceSelectionLog: data["counterfactualDeviceSelectionLog"] !== undefined ? serializeAssistantLogsDeviceSelectionLog(data["counterfactualDeviceSelectionLog"]) : undefined,
    nearbyDevicesLog: data["nearbyDevicesLog"] !== undefined ? serializeAssistantLogsNearbyDevicesLog(data["nearbyDevicesLog"]) : undefined,
  };
}

function deserializeAssistantLogsDeviceSelectionLog(data: any): AssistantLogsDeviceSelectionLog {
  return {
    ...data,
    counterfactualDeviceSelectionLog: data["counterfactualDeviceSelectionLog"] !== undefined ? deserializeAssistantLogsDeviceSelectionLog(data["counterfactualDeviceSelectionLog"]) : undefined,
    nearbyDevicesLog: data["nearbyDevicesLog"] !== undefined ? deserializeAssistantLogsNearbyDevicesLog(data["nearbyDevicesLog"]) : undefined,
  };
}

/**
 * Log the selection result. Next ID: 11
 */
export interface AssistantLogsDeviceSelectionResultLog {
  /**
   * Deprecated, please use qualified_devices.
   */
  ambiguousTargetDevices?: AssistantLogsAmbiguousTargetDeviceLog;
  deviceSelectionDecisionSummary?: AssistantLogsMediaDeviceSelectionDecisionSummary;
  deviceTargetingErrorType?:  | "UNKNOWN_ERROR" | "NO_DEVICE_IN_SAME_STRUCTURE" | "NO_DEVICE_IN_SAME_NETWORK_OR_LOCATION" | "NO_DEVICE_IN_SAME_STRUCTURE_OR_NETWORK_OR_LOCATION" | "NO_DEVICE_SATISFIES_SAME_STRUCTURE_OR_UNKNOWN_IF_OWNED" | "NO_DEVICE_SATISFIES_CAPABILITIES_REQUIREMENT" | "NO_DEVICE_MATCHED_DEVICE_ANNOTATION" | "MULTI_TARGET_DEVICE_NOT_SUPPORTED" | "NO_DEVICE_AFTER_LOCAL_DEVICE_EXCLUDED" | "UNABLE_TO_TARGET_ONLY_LOCAL_DEVICE" | "NO_DEVICE_MATCHED_REQUIRED_TRAITS" | "NO_DEVICE_MATCHED_REQUIRED_ATTRIBUTES" | "NO_DEVICE_MATCHED_REQUIRED_DEVICE_TYPE" | "NO_DEVICE_IN_SAME_OR_MENTIONED_STRUCTURE" | "NO_DEVICE_SATISFIES_PLAYBACK_REQUIREMENT" | "STRUCT_DISAMBIG_NOT_SUPPORTED" | "ROOM_DISAMBIG_NOT_SUPPORTED" | "UNRECOGNIZED_DEVICE_NAME" | "NO_LINKED_REMOTE_DEVICES" | "NO_LINKED_REMOTE_VIDEO_DEVICES" | "NO_SAFE_DEVICE_WITH_SCREEN" | "ALL_QUALIFIED_DEVICES_OFFLINE" | "CROSS_STRUCTURE_TARGETING_DISALLOWED" | "NO_DEVICE_MEETS_PROVIDER_REQUIREMENT" | "MISSING_LOCAL_DEVICE_SETTING" | "NO_DEVICE_HAS_REQUIRED_APP" | "HYBRID_DEVICE_NOT_QUALIFIED" | "NO_NEARBY_DEVICES";
  /**
   * The class name for the final filter/promoter used by Lumos for device
   * targeting. This filter or promoter runs for all users, and contains no data
   * specific to the individual user.
   */
  finalLumosStage?: string;
  /**
   * //////////////////////////////////////////////////////////////////////////
   * Ambiguous Results: the library failed to select the final target device(s)
   * but it narrows down to a set of devices which are all valid target device
   * candidates. The client needs to do further disambiguation, e.g., giving a
   * dialog or having costomized logic. The low confidence target device means
   * the library falied to select the target device but it picked two devices
   * for the client to do disambiguation.
   */
  lowConfidenceTargetDevice?: AssistantLogsLowConfidenceTargetDeviceLog;
  /**
   * //////////////////////////////////////////////////////////////////////////
   * This field log the error while selecting target device in
   * media_focus_selector.
   */
  mediaFocusSelectionErrorType?:  | "UNKNOWN_ERROR" | "FOUND_MULTIPLE_DEVICES" | "REQUESTED_DEVICE_HAS_NO_SCREEN" | "NO_LINKED_REMOTE_DEVICES" | "NO_LINKED_REMOTE_VIDEO_DEVICES" | "UNRECOGNIZED_DEVICE_NAME" | "UNRECOGNIZED_VIDEO_DEVICE_NAME" | "NO_DEVICE_MEETS_PROVIDER_REQUIREMENT" | "MULTIPLE_DEVICES_MEET_PROVIDER_REQUIREMENT" | "REMOTE_CLOUD_CASTING_NOT_ALLOWED" | "NO_SAFE_DEVICE_WITH_SCREEN" | "NO_DEVICE_MEETS_PLAYBACK_REQUIREMENT" | "MULTIPLE_DEVICES_MEET_PLAYBACK_REQUIREMENT" | "NO_VALID_DEVICE_IN_REQUESTED_ROOM" | "NO_DEVICE_FOUND_IN_REQUESTED_ROOM" | "MULTIPLE_DEVICES_FOUND_IN_REQUESTED_ROOM" | "ALL_QUALIFIED_DEVICES_IN_DIFFERENT_STRUCTURE" | "QUALIFIED_DEVICE_OFFLINE" | "ALL_QUALIFIED_DEVICES_OFFLINE" | "CROSS_STRUCTURE_TARGETING_DISALLOWED" | "NO_DEVICE_MEETS_STADIA_GAMING_CAPABILITY" | "MEDIA_STATES_MISSING" | "NO_DEVICE_SATISFIES_CAPABILITIES_REQUIREMENT" | "HYBRID_DEVICE_NOT_QUALIFIED";
  /**
   * The log for each stage of Lumos, showing the number of eliminated devices
   * from each processor.
   */
  processorInfo?: AssistantLogsLumosProcessorInfo[];
  /**
   * We will apply several filters and dialogs to select a target device if
   * media_focus_selector fail to select one. This field should log the devices
   * left after each filter or dialog. It also log the detailed info of the
   * final target device.
   */
  qualifiedDevices?: AssistantLogsAmbiguousTargetDeviceLog;
  /**
   * //////////////////////////////////////////////////////////////////////////
   * Unambiguous Results: the library successfully selected the final target
   * device(s) and no further disambiguation is needed. Deprecated, please use
   * target_device.
   */
  singleTargetDevice?: AssistantLogsDeviceInfoLog;
  targetDevice?: AssistantLogsTargetDeviceLog;
}

/**
 * Test code is used to track special events happening in Device Targeting
 * Library. Next Id: 2
 */
export interface AssistantLogsDeviceTargetingTestCode {
  type?:  | "UNKNOWN" | "IGNORE_NESTED_DEVICE_MENTION_WITH_ID" | "INCOMPLETE_LOCAL_AUTO_SETTINGS_FOUND" | "FINAL_RESULT_RESOLVED_BY_NEARBY_DEVICE";
}

export interface AssistantLogsInputErrorLog {
  errorCode?: number;
  errorType?:  | "ERROR_UNKNOWN" | "ERROR_DEVICE_PROPERTIES" | "ERROR_HOME_GRAPH" | "ERROR_CAPABILITIES_ACROSS_DEVICES";
}

/**
 * Represents the case where there is a target device with low confidence so
 * that the library didn't directly target it. Instead, the library returns the
 * low confidence target device and the fallback device for the client to decide
 * to either trigger a dialog to disambiguate or select one of them based on
 * extra business logic. Next ID: 3
 */
export interface AssistantLogsLowConfidenceTargetDeviceLog {
  /**
   * The fallback device.
   */
  fallbackDeviceLog?: AssistantLogsDeviceInfoLog;
  /**
   * The selected low confidence focus device.
   */
  lowConfTargetDeviceLog?: AssistantLogsDeviceInfoLog;
}

export interface AssistantLogsLumosProcessorInfo {
  /**
   * Number of candidate devices after this stage is run.
   */
  devicesAfterRun?: number;
  /**
   * Number of candidate devices before this stage is run.
   */
  devicesBeforeRun?: number;
  /**
   * Name of the processor for this stage.
   */
  processorName?:  | "UNKNOWN_LUMOS_PROCESSOR" | "CAPABILITIES_FILTER" | "DEVICE_ANNOTATION_FILTER" | "DEVICE_CONNECTIVITY_FILTER" | "LOCAL_DEVICE_INCLUSIVENESS_FILTER" | "LOCATION_FILTER" | "MEDIA_PLAYBACK_FILTER" | "SAFETY_FILTER" | "TRAITS_FILTER" | "DEVICE_TYPE_FILTER" | "APP_FILTER" | "HYBRID_DEVICE_PROPERTIES_FILTER" | "NEARBY_DEVICE_FILTER" | "DEVICE_ATTRIBUTES_FILTER" | "DEFAULT_MEDIA_OUTPUT_PROMOTER" | "DEVICE_GROUP_PROMOTER" | "LOCAL_DEVICE_PROMOTER" | "LOCATION_PROMOTER" | "MEDIA_FOCUS_PROMOTER" | "MEDIA_PLAYBACK_PROMOTER" | "SAME_NAME_DEVICE_PROMOTER" | "PHONE_TARGETING_PROMOTER" | "TRAITS_PROMOTER" | "DEVICE_TYPE_PROMOTER";
}

export interface AssistantLogsMediaCapabilities {
  canReceiveRemoteAction?: boolean;
  hasScreen?: boolean;
}

/**
 * A summary of the reasons that we chose a certain target device.
 */
export interface AssistantLogsMediaDeviceSelectionDecisionSummary {
  deviceSelectionPreferenceUsed?:  | "UNKNOWN_PRIORITY" | "SINGLE_QUALIFIED_SESSION_PREFERRED" | "FOCUS_SESSION_PREFERRED" | "FOCUS_DEVICE_SESSION_PREFERRED" | "LOCAL_DEVICE_SESSION_PREFERRED" | "PLAYING_DEVICE_STATE_PREFERRED" | "BUFFERING_DEVICE_STATE_PREFERRED" | "PAUSED_DEVICE_STATE_PREFERRED" | "STOPPED_DEVICE_STATE_PREFERRED";
  deviceSelectionReason?:  | "UNKNOWN_REASON" | "SYNDICATION_DEVICE_TARGETED" | "AUTO_DEVICE_TARGETED" | "QUERY_DEVICE_ANNOTATION_TARGETED" | "SINGLE_QUALIFIED_DEVICE_TARGETED" | "CAST_GROUP_TARGETED" | "MEDIA_SESSION_TARGETED" | "FOCUS_DEVICE_TARGETED" | "DEFAULT_DEVICE_TARGETED" | "LOCAL_DEVICE_TARGETED" | "DEVICE_IN_SAME_ROOM_TARGETED" | "AMBIGUOUS_DEVICES_TARGETED" | "LOCAL_GROUP_RETARGETED" | "FOCUS_OF_CLOSE_DEVICE_TARGETED" | "DEFAULT_OF_CLOSE_DEVICE_TARGETED" | "SINGLE_QUALIFIED_CLOSE_DEVICE_TARGETED" | "DEVICE_IN_CLOSE_ROOM_TARGETED" | "TETHERED_DEVICE_TARGETED";
  miscSelectionSignal?:  | "NONE" | "BETTER_MATCH_DEVICE_WITH_HUMAN_FRIENDLY_NAME_FOUND" | "LOCAL_DEVICE_IMPLICITLY_MENTIONED" | "USED_LOOSE_PLAYBACK_STATE_REQUIREMENTS" | "QUERY_3P_DEVICE_ANNOTATION_IGNORED_REQUIREMENTS"[];
}

/**
 * Following are the MDA compatible loggings for media focus, default settings
 * and nearby devices.
 */
export interface AssistantLogsMediaFocusesLog {
  dialogTriggered?: boolean;
  localMediaFocus?: AssistantLogsMediaFocusInfoLog;
  /**
   * Deprecated, use nearby_media_focuses instead.
   */
  mediaFocuses?: AssistantLogsMediaFocusInfoLog[];
  /**
   * MediaFouces found on nearby devices.
   */
  nearbyMediaFocuses?: AssistantLogsMediaFocusInfoLog[];
}

/**
 * The information related to Media Focus. TODO(b/138952173) Deprecate
 * MediaFocusState in logs/proto/majel_gws/media_action_triggering_info.proto
 * and assistant/verticals/media/proto/target_device_info.proto
 */
export interface AssistantLogsMediaFocusInfoLog {
  /**
   * How long the device is in focus so far
   */
  currentFocusDurationSec?: number;
  /**
   * TODO(b/134944092) Log MediaFocusDialogTrigger Enum in focus_status.
   */
  dialogTriggered?: boolean;
  /**
   * 
   * LINT.ThenChange(//depot/google3/logs/proto/majel_gws/media_action_triggering_info.proto)
   * The focus device.
   */
  focusDevice?: AssistantLogsDeviceInfoLog;
  /**
   * The media focus state at the time of the request.
   */
  mediaFocusState?:  | "NO_FOCUS" | "RECENT_FOCUS" | "STALE_FOCUS" | "HARD_FOCUS" | "SOFT_FOCUS";
  /**
   * The source device of media focus.
   */
  sourceDeviceId?: string;
}

/**
 * Media stream is composed of a media session and one or more devices which
 * are hosting (playing) the session. Usually, a session is only hosted by one
 * devcie. However, with cast group or stream transfer/expansion, a session
 * could be hosted by multiple devices, which are playing the same session
 * simultaneously.
 */
export interface AssistantLogsMediaStreamLog {
  /**
   * The device index in this message is consistent with the device index in
   * DeviceInfoLog. This field refers to the devices that hosting the session.
   */
  deviceIndex?: number[];
  session?: AssistantLogsDeviceMediaSessionLog;
}

export interface AssistantLogsNearbyDevicesLog {
  /**
   * The timestamp that DeviceArbitration is created in milliseconds.
   */
  deviceArbitrationCreationTimestampMs?: bigint;
  /**
   * The timestamp that DeviceTargetingInput is built in milliseconds.
   */
  deviceTargetingInputCreationTimestampMs?: bigint;
  eliminatedByFurtherDistance?: number;
  eliminatedByLocalClosest?: number;
  eliminatedByUnknownDifferentRoom?: number;
  eliminatedByUnregisteredDevice?: number;
  localDevice?: AssistantLogsDeviceInfoLog;
  nearbyDevices?: AssistantLogsDeviceInfoLog[];
  numClosestDevices?: number;
  numEquallyCloseDevices?: number;
  numFurtherDevices?: number;
  numHearingDevices?: number;
  numUnknownDistanceDevices?: number;
}

function serializeAssistantLogsNearbyDevicesLog(data: any): AssistantLogsNearbyDevicesLog {
  return {
    ...data,
    deviceArbitrationCreationTimestampMs: data["deviceArbitrationCreationTimestampMs"] !== undefined ? String(data["deviceArbitrationCreationTimestampMs"]) : undefined,
    deviceTargetingInputCreationTimestampMs: data["deviceTargetingInputCreationTimestampMs"] !== undefined ? String(data["deviceTargetingInputCreationTimestampMs"]) : undefined,
  };
}

function deserializeAssistantLogsNearbyDevicesLog(data: any): AssistantLogsNearbyDevicesLog {
  return {
    ...data,
    deviceArbitrationCreationTimestampMs: data["deviceArbitrationCreationTimestampMs"] !== undefined ? BigInt(data["deviceArbitrationCreationTimestampMs"]) : undefined,
    deviceTargetingInputCreationTimestampMs: data["deviceTargetingInputCreationTimestampMs"] !== undefined ? BigInt(data["deviceTargetingInputCreationTimestampMs"]) : undefined,
  };
}

/**
 * Provider annotation annotated from the query. These fields contain the
 * detailed information for the provider. (e.g. for Youtube, package_names
 * contains "com.google.android.youtube", localized_names contains "youtube",
 * and lang contains "en" from "en-US" which depends on user's setting.)
 */
export interface AssistantLogsProviderAnnotationLog {
  lang?: string;
  localizedNames?: string[];
  packageNames?: string[];
}

/**
 * Log about the query requirements
 */
export interface AssistantLogsQueryAnnotationLog {
  /**
   * Deprecated, please use room_annotations.
   */
  deviceAnnotation?: AssistantLogsDeviceAnnotationLog;
  /**
   * Log the device annotations mentioned in the query.
   */
  deviceAnnotations?: AssistantLogsDeviceAnnotationLog[];
  /**
   * Log the provider annotations annotated from the query.
   */
  providerAnnotation?: AssistantLogsProviderAnnotationLog;
  /**
   * TODO(b/171250187) Deprecates the optional RoomAnnotationLog and
   * DeviceAnnotationLog. Deprecated, please use device_annotations.
   */
  roomAnnotation?: AssistantLogsRoomAnnotationLog;
  /**
   * Log the room annotations mentioned in the query.
   */
  roomAnnotations?: AssistantLogsRoomAnnotationLog[];
  /**
   * Log the structure annotations mentioned in the query.
   */
  structureAnnotations?: AssistantLogsStructureAnnotationLog[];
}

/**
 * Annotate a single reminder instance.
 */
export interface AssistantLogsReminderLog {
  /**
   * The reminder is created N seconds ago. This helps tracking how the user
   * issues follow-up actions after reminder is created. For example, whether
   * the user likes to issues another [show reminders] query right after
   * reminder is created?
   */
  createdSecondsAgo?: bigint;
  /**
   * If the reminder is retrieved by a ranking class (see
   * go/opa-reminders-ranker), this will be populated with the class info. Refer
   * to assistant.productivity.ReminderRankingClass.RankingType. Since that
   * proto is in proto2 format, we can only wire by int type.
   */
  retrievedRankingClass?: number;
}

function serializeAssistantLogsReminderLog(data: any): AssistantLogsReminderLog {
  return {
    ...data,
    createdSecondsAgo: data["createdSecondsAgo"] !== undefined ? String(data["createdSecondsAgo"]) : undefined,
  };
}

function deserializeAssistantLogsReminderLog(data: any): AssistantLogsReminderLog {
  return {
    ...data,
    createdSecondsAgo: data["createdSecondsAgo"] !== undefined ? BigInt(data["createdSecondsAgo"]) : undefined,
  };
}

/**
 * Room annotation mentioned in query.
 */
export interface AssistantLogsRoomAnnotationLog {
  /**
   * The raw text mentioning a room from the query, such as "my living room".
   */
  rawTextFromQuery?: string;
  /**
   * The number of rooms annotated, if there are multiple structures. They are
   * guaranteed to have the same text_from_query and name due to exact matching.
   */
  roomCount?: number;
  /**
   * The annotation type mentioned in the query.
   */
  type?:  | "NO_ROOM_ANNOTATION" | "ROOM_ID_ANNOTATION" | "ROOM_TYPE_ANNOTATION" | "ROOM_TEXT_ANNOTATION";
  userDefinedName?: string;
}

/**
 * The logging-version of DeviceId proto, which identifies a device. This
 * mirrors
 * cs/google3/assistant/api/core_types/device_type.proto?q=symbol:DeviceId Next
 * ID: 6
 */
export interface AssistantLogsSettingsDeviceIdLog {
  /**
   * The client_instance_id on devices with GSA. See 'client_instance_field' in
   * go/androidids.
   */
  agsaClientInstanceId?: string;
  /**
   * A unique device ID for Assistant devices as proposed by go/ocelot-team.
   */
  canonicalDeviceId?: string;
  /**
   * If set, indicates that the device is a cast device, and contains the UUID
   * of the cast device. Corresponds to the device_id field of the CastDevice
   * proto.
   */
  castDeviceId?: string;
  /**
   * DUSI (go/dusi) is used as the identifier here. This identifier is unique
   * to the user and device. This will help identify which device or application
   * the user's request originated from. This is not to be confused with the
   * client_instance_id that android devices provide. This is currently used by
   * surfaces that use the assistant-legacy-nexus and assistant-legacy-clockwork
   * pipelines. DUSI is created and set in S3. This field is only filled for
   * GAIA requests.
   */
  clientInstanceId?: string;
  /**
   * The unique device ID for HomeGraph devices. This is the HomeGraph ID,
   * created when the device is registered into HomeGraph. It is immutable for
   * the same device unless it is completely deleted and recreated. See
   * go/home-graph for details. }
   */
  homeGraphDeviceId?: string;
  /**
   * The unique ID for libassistant based devices.
   */
  libassistantDeviceId?: string;
}

/**
 * Structure annotation mentioned in query.
 */
export interface AssistantLogsStructureAnnotationLog {
  /**
   * The raw text mentioning a structure from the query, such as "my house".
   */
  rawTextFromQuery?: string;
  /**
   * The annotation type mentioned in the query.
   */
  type?:  | "NO_STRUCTURE_ANNOTATION" | "STRUCTURE_ID_ANNOTATION" | "STRUCTURE_TEXT_ANNOTATION";
  userDefinedName?: string;
}

/**
 * Represents the case where the library successfully selects the target
 * device. It could be one or multiple devices. Next ID: 4
 */
export interface AssistantLogsTargetDeviceLog {
  devices?: AssistantLogsDeviceInfoLog[];
  lowConfidenceReason?:  | "UNKNOWN_REASON" | "LOCAL_FALLBACK" | "MANUAL_DEFINED_REASON" | "SINGLE_NEARBY_DEVICE" | "PERSONAL_RESPONSE_BIT_OPTOUT_ON_LOCKED_PHONE" | "FURTHER_LOCAL_DEVICE";
  resultConfidenceLevel?:  | "UNKNOWN" | "LOW_CONFIDENCE" | "HIGH_CONFIDENCE";
}

/**
 * Signals to be used by the Prefulfillment Ranker. Derived from the
 * ParsingSignals and GroundingSignals carried by the FunctionCall.
 * LINT.IfChange Next ID: 44
 */
export interface AssistantPrefulfillmentRankerPrefulfillmentSignals {
  /**
   * Assistant User Interaction Score for binding set.
   */
  bindingSetAuis?: number;
  /**
   * Pauis score for the binding set
   */
  bindingSetPauis?: number;
  /**
   * A parsing score that is independently calibrated by each parser/IG.
   */
  calibratedParsingScore?: number;
  /**
   * Whether the intent is dominant according to NSP deep-media.
   */
  deepMediaDominant?: boolean;
  /**
   * Indicates interpretation dominance predicted by KScorer
   */
  dominant?: boolean;
  /**
   * The total effective length of the spans for the arguments used to
   * construct the parse. May include vertical specific adjustments. Eg: For the
   * query [delete my 7 p.m. alarm called chicken] and intent
   * Delete_alarm(alarm_object=RD(category=AlarmObject( label="chicken",
   * trigger_time_datetime=<< 7 PM >>))), the effective argument span is "7
   * p.m." + "chicken" (total length of 13).
   */
  effectiveArgSpanLength?: number;
  /**
   * Whether this is a fulfillable, dominant Media intent.
   */
  fulfillableDominantMedia?: boolean;
  /**
   * Grounding Signals. Score indicating how grounded the intent is, populated
   * by the Grounding Box.
   */
  groundabilityScore?: number;
  /**
   * Grounding Provider related ranking features, including general Grounding
   * Provider ranking features(shared among multiple GPs) and specific Grounding
   * Provider ranking features(provided by a specific GP).
   */
  groundingProviderFeatures?: AssistantGroundingRankerGroundingProviderFeatures;
  /**
   * Whether the interpretation has a Search answer group object, signifying it
   * came from Search resolution.
   */
  hasAnswerGroup?: boolean;
  /**
   * This is a cross-intent feature which is calculated by iterating all intent
   * candidates. This feature should be populated in post-IG stage (before GB).
   */
  inQueryMaxEffectiveArgSpanLength?: number;
  /**
   * intent_name is used by PFR ensemble model. See go/pfr_ha_launch_doc
   */
  intentName?: string;
  /**
   * QUS intent-based ranking signals. Assistant User Interaction Score which
   * is aggregated using intent name.
   */
  intentNameAuisScore?: number;
  /**
   * Assistant User Interaction Score which is aggregated using intent name
   * from exp laelaps.
   */
  intentNameAuisScoreExp?: number;
  /**
   * Feasibility of fulfilling the binding set. Eg: For PlayMedia, this is
   * equivalent to playability. More details: go/hgr-feasibility-feature.
   */
  isFeasible?: boolean;
  /**
   * Whether the intent is fully grounded.
   */
  isFullyGrounded?: boolean;
  /**
   * Whether the intent is a PlayGenericMusic-type intent.
   */
  isPlayGenericMusic?: boolean;
  /**
   * Whether the intent is a podcast intent.
   */
  isPodcastIntent?: boolean;
  /**
   * The rank order of the interpretation as determined by kscorer. The
   * kscorer-determined dominant interpretation, if any, gets a rank of 0. The
   * remaining N interpretations get a rank of 1 through N.
   */
  kscorerRank?: number;
  /**
   * Learn and adapt(go/laa) related features. Design doc:
   * go/laa-profile-signal-for-grounding.
   */
  laaFeatures?: AssistantGroundingRankerLaaFeatures;
  /**
   * This feature is always false / no-op in serving time. In training time,
   * this feature may be set true on specific examples for weighted training
   * where when this signal is true, only cross-intent level features are used
   * for training and other candidate level features are masked (set as
   * missing).
   */
  maskCandidateLevelFeatures?: boolean;
  /**
   * The maximum score assigned by the Horizontal Grounding Ranker (HGR) across
   * all of the intent's binding sets.
   */
  maxHgrScoreAcrossBindingSets?: number;
  /**
   * Number of alternative hypotheses from speech recognition(S3).
   */
  numAlternativeHypothesis?: number;
  /**
   * Sum of the number of constraints used by the Grounding Box to ground each
   * variable.
   */
  numConstraints?: number;
  /**
   * Sum of the number of constraints satisfied for each variable. Depending on
   * the match score for a constraint, this number can be fractional and is in
   * the range [0, num_constraints]. Populated by the Grounding Box.
   */
  numConstraintsSatisfied?: number;
  /**
   * Number of groundable arguments the intent has, populated by the Grounding
   * Box.
   */
  numGroundableArgs?: number;
  /**
   * Number of grounded arguments the intent has, populated by the Grounding
   * Box.
   */
  numGroundedArgs?: number;
  /**
   * Signals as proposed in go/improved-grounding-signals. Number of arguments,
   * possibly nested, that the Grounding Box tried to ground.
   */
  numVariables?: number;
  /**
   * Number of arguments, possibly nested, that the Grounding Box was able to
   * ground. This includes ambiguously grounded arguments.
   */
  numVariablesGrounded?: number;
  /**
   * A ID corresponding to which bucket a given parsing score belongs in.
   */
  parsingScoreMse8BucketId?: number;
  /**
   * Cosine similarity between predicted query-to-term model and assistant
   * intent-type-based salient terms. This is intended to be only used for ACE
   * ranking and only populated for assistant traffic.
   */
  pq2tVsAssistantIbstCosine?: number;
  /**
   * Cosine similarity between predicted query-to-term model and
   * intent-type-based salient terms. This is intended to be used as a backoff
   * to pq2t_vs_qibst_cosine if it is missing.
   */
  pq2tVsIbstCosine?: number;
  /**
   * Intent confidence predicted by the AssistantVerticalClassifier QRewrite
   * servlet.
   */
  predictedIntentConfidence?: number;
  /**
   * The determination made by the SearchDispatchingConfig as to whether and
   * how this interpretation should be dispatched to Search.
   */
  searchDispatch?:  | "UNKNOWN" | "NONE" | "BRIDGE_API" | "FULFILL_INTENT" | "EMIT_ONLY" | "COUNTERFACTUAL_LOG_ONLY" | "CAPACITY_ACCOUNTING";
  /**
   * Average of per-word confidence for top speech recognition hypothesis. The
   * value is from RecognizerHypothesisLog:
   * http://google3/logs/proto/speech/service/recognizer_log.proto?l=848&rcl=281400256
   */
  topHypothesisConfidence?: number;
  /**
   * Horizontal feature that stores information about confidence scores for
   * each resolution within the binding set.
   */
  verticalConfidenceScore?: number;
}

/**
 * A message to represent an item in a list. Just a basic string for now, but
 * extensible for the future.
 */
export interface AssistantProductivityListItem {
  /**
   * [REQUIRED] The name of the list item.
   */
  name?: string;
}

/**
 * Proto descrbing an attachment to an Assistant Reminder. If the attachment
 * has different behavior on different surfaces (e.g., deeplinks), there will be
 * multiple attachments attach to the Reminder. Each of them will specify the
 * surface type and the corresponding deeplink.
 */
export interface AssistantRemindersAttachment {
  /**
   * REQUIRED. An unique identifier for the attachment. We have a plan to index
   * this field, so it's marked as REQUIRED. Chat with opa-reminders-eng@ if you
   * have a use case without an attachment ID.
   */
  id?: string;
  link?: AssistantRemindersAttachmentLink;
  /**
   * REQUIRED. Surface types this attachment should be shown.
   */
  surfaceType?:  | "UNSPECIFIED" | "ANDROID_PHONE"[];
}

export interface AssistantRemindersAttachmentLink {
  /**
   * REQUIRED. The link to surface to frontends (e.g., Hubpage, notifications.)
   * This could also be a surface-specific deeplink (be sure to set
   * `surface_type` accordingly.)
   */
  linkUrl?: string;
  /**
   * REQUIRED. The text for the notification link button. Note: We cannot take
   * nlp_generation.TemplateData yet due to cyclic dependency. The plan is to
   * cut dependency from TemplateData to quality.actions.Reminder.
   */
  notificationText?: AssistantRemindersNlgTemplateKey;
}

/**
 * Since this is stored in BE, any update on this proto needs LGTM by ARIS
 * storage owner
 */
export interface AssistantRemindersMemoryPayload {
  /**
   * Whether the reminder created has a referenced_entity attached to it or
   * not(go/hub-memory-payload). Since we plan to set this in Assistant reminder
   * creation path flow, in case later the referenced_entity is removed from the
   * reminder, then this bit might still remain true. Also in case
   * referenced_entity is later added to reminder(for example when
   * referenced_entity is attached by Server), then also this bit might remain
   * false. This bit will be used to *guess* if the user has a memory-enabled
   * AGSA, thus we'll surface the "open memory" button on hubpage. This check is
   * not perfect, as the user might have other phones with older AGSA, so this
   * is just a *best guess*. This field won't be stored in Memory backend, and
   * will not be populated back when retrieving reminders.
   */
  hasReferencedEntityAtCreation?: boolean;
  /**
   * Id of record that is associated with Reminder. This will be set for all
   * Assistant reminders created after the first launch of the Reminder Memory
   * integration, see go/reminders-memory for more details. Also, this might
   * apply to all other types of reminders.
   */
  recordId?: string;
}

/**
 * Equivalent to nlp_generation.TemplateKey. We cannot use
 * nlp_generation.TemplateKey message directly becasue that proto is defined in
 * a relatively large proto and has other dependencies, which will increase the
 * size unnecessary and might hit many limitations (e.g., 5MiB limitation for
 * Spanner type environment.).
 */
export interface AssistantRemindersNlgTemplateKey {
  /**
   * REQUIRED.
   */
  messageSet?: string;
  /**
   * REQUIRED.
   */
  templateName?: string;
}

export interface AssistantTeleportTeleportNicknameSignals {
  /**
   * Whether the nickname could also refer to a location. For example,
   * "walmart", "starbucks".
   */
  hasLocationInterpretation?: boolean;
  /**
   * Indicates whether the user has the app installed.
   */
  installInfo?:  | "INSTALLATION_INFORMATION_UNAVAILABLE" | "IS_INSTALLED_APP" | "IS_NOT_INSTALLED_APP";
  /**
   * True when the name is generic, i.e when it could refer to multiple
   * packages from different developrs. For example, "mail" is considered a
   * generic name (since it can refer to "gmail", "yahoo mail" etc.) but
   * "facebook" although could refer to both "facebook" and "facebook lite" is
   * not considered generic (both packages are from the same third party).
   */
  isGeneric?: boolean;
  /**
   * The tier of the nickname.
   */
  nicknameTier?:  | "UNKNOWN" | "UNRESTRICTED" | "INTENT_REQUIRED" | "APP_PHRASE_REQUIRED";
  source?:  | "DEFAULT" | "GELLER" | "DEVICE_CAPABILITIES";
}

/**
 * Neural contact match signals.
 */
export interface AssistantVerticalsCommonContactMatchSignal {
  /**
   * Neural contact match similarity score.
   */
  matchScore?: number;
}

/**
 * Metadata for Actions-on-Google configuration.
 */
export interface AssistantVerticalsHomeautomationProtoActionProjectConfig {
  /**
   * Actions-on-Google action context ID. See go/sdm-hospitality-design.
   */
  contextId?: string;
}

/**
 * An agent + device pair that uniquely identifies a device.
 */
export interface AssistantVerticalsHomeautomationProtoAgentDeviceId {
  /**
   * The agent's ID. Generally it is the agent's Google pantheon project id.
   */
  agentId?: string;
  /**
   * Device ID defined by the agent.
   */
  deviceId?: string;
}

/**
 * AgentInformation represents the details needed to support both 1P and 3P
 * partnerships for Home Automation. Next ID: 7
 */
export interface AssistantVerticalsHomeautomationProtoAgentInformation {
  authType?:  | "OPEN_AUTH_DEFAULT" | "NEST_AUTH_PROXY";
  deviceSource?:  | "UNKNOWN" | "CLOUD_SYNC" | "ASSISTANT_SETTING_OOBE" | "LOCAL_SYNC" | "CHIP_SYNC";
  executionPath?:  | "HARPOON_DEFAULT" | "STUBBY";
  /**
   * Unique Agent ID which maps to a specific Agent. Not using Agent Name here
   * as it may change over time.
   */
  id?: string;
  /**
   * Agent's foreign key that uniquely identifies a user's device.
   */
  key?: string;
}

/**
 * Protos representing device or structure attributes. See
 * go/hgs-attributes-protos. Only protos approved and formalized by assistant/HG
 * team should be added here.
 */
export interface AssistantVerticalsHomeautomationProtoAttribute {
  structureBasedRoutine?: AssistantVerticalsHomeautomationProtoCommonStructureBasedRoutine;
}

/**
 * LINT.IfChange(proto_attributes)
 */
export interface AssistantVerticalsHomeautomationProtoAttributes {
  attributeProtos?: AssistantVerticalsHomeautomationProtoAttribute[];
}

/**
 * LINT.IfChange(proto_event_trigger) Next id: 5
 */
export interface AssistantVerticalsHomeautomationProtoCommonEventTrigger {
  enabled?: boolean;
  /**
   * Detailed settings for the event trigger; unset if not applicable.
   */
  eventTriggerPayload?: {
    [key: string]: any
  };
  /**
   * Different event type may have different settings. For example: * SCHEDULED
   * will have event_trigger_payload of
   * cs/symbol:assistant.verticals.voice_shortcut.proto.Schedule * LOCATION will
   * have event_trigger_payload of
   * cs/symbol:assistant.verticals.voice_shortcut.proto.LocationTriggerEvent
   */
  eventTriggerType?:  | "UNKNOWN" | "SCHEDULED" | "LOCATION" | "DEVICE_CONTROL" | "DEVICE_SENSES";
  /**
   * Unique identifier for the EventTrigger, e.g. SCHEDULED_ROUTINES. See the
   * enum values of cs/symbol:WorkflowTriggerInput.TriggerSource
   */
  triggerSource?: number;
}

/**
 * Routines team stores the core Structure Based Routine data as the payload.
 * We will add specific metadata on a per-need basis.
 * LINT.IfChange(proto_structure_based_routine) Next id: 12 These two forms of
 * payload are equivalent data in different formats and both will be stored in
 * Home Graph. 1. The internal format will fan out to the DynamicEntity
 * Footprints for read in Settings flow and Execution. 2. The UI format will be
 * stripped out upon replication to DynamicEntity Footprints due to its
 * redundancy and the Footprints data size limit, i.e. DE Footprints will only
 * contain the internal format.
 */
export interface AssistantVerticalsHomeautomationProtoCommonStructureBasedRoutine {
  /**
   * Whether this Routine is enabled or not. If false, then this Routine can't
   * be triggered by Voice.
   */
  enabled?: boolean;
  /**
   * The unique identifier for a class of workflows. For example: * "sbr_001"
   * => Away * "sbr_002" => Home * "category_template" => CUSTOM
   */
  googlePreconfigWorkflowId?: string;
  language?: string;
  /**
   * Internal format payload primarily for Routines team use.
   */
  payload?: {
    [key: string]: any
  };
  /**
   * The security level of the Structure Based Routine as determined by the
   * most security-sensitive task.
   */
  securityLevel?:  | "UNKNOWN" | "ALLOW_UNVERIFIED" | "ALLOW_VERIFIED";
  shared?: boolean;
  storagePayload?: {
    [key: string]: any
  };
  structureId?: string;
  /**
   * Voice or event triggers.
   */
  triggers?: AssistantVerticalsHomeautomationProtoCommonStructureBasedRoutineTrigger[];
  type?:  | "UNDEFINED" | "CURATED" | "ALARM" | "CUSTOM";
  /**
   * UI format payload primarily for external team use.
   */
  uiPayload?: {
    [key: string]: any
  };
}

/**
 * Next id: 3
 */
export interface AssistantVerticalsHomeautomationProtoCommonStructureBasedRoutineTrigger {
  eventTrigger?: AssistantVerticalsHomeautomationProtoCommonEventTrigger;
  voiceTrigger?: AssistantVerticalsHomeautomationProtoCommonVoiceTrigger;
}

/**
 * LINT.IfChange(proto_voice_trigger) Next id: 2
 */
export interface AssistantVerticalsHomeautomationProtoCommonVoiceTrigger {
  query?: string;
}

/**
 * The Concierge features a structure is eligible for. See {@link
 * home.graph.common.ConciergeFeatures}.
 */
export interface AssistantVerticalsHomeautomationProtoConciergeFeatures {
  conciergeProductFeatures?:  | "UNKNOWN_PRODUCT_FEATURE" | "E911"[];
}

/**
 * Next ID: 5
 */
export interface AssistantVerticalsHomeautomationProtoDeviceTargetingOutputQueryInfo {
  /**
   * The query span for device mention.
   */
  annotatedSpanDevice?: string;
  /**
   * The query span for room mention.
   */
  annotatedSpanRoom?: string;
  /**
   * The query span for structure mention.
   */
  annotatedSpanStructure?: string;
  /**
   * This field is from query_info.processed_mentioned_span in DTO.
   */
  processedMentionedSpan?: string;
}

/**
 * Next ID: 43
 */
export interface AssistantVerticalsHomeautomationProtoHomeAutomation_MetaData {
  /**
   * Custom actions that this item supports.
   */
  actionProjectConfigs?: AssistantVerticalsHomeautomationProtoActionProjectConfig[];
  /**
   * Agent details.
   */
  agentInformation?: AssistantVerticalsHomeautomationProtoAgentInformation;
  /**
   * Device ID that matches the ID passed from the device to discourse_context
   * when a user issues a query to an Assistant-enabled device that is
   * registered with Cast (via CCS (see go/castservers)), or some other service.
   */
  assistantDeviceId?: string;
  /**
   * Attributes data as provided from SYNC. This gets used in mutation and
   * execution and in some potential cases, in biasing.
   */
  attributes?: {
    [key: string]: any
  };
  /**
   * See Device.creator_gaia_ids in //home/graph/proto/service/types.proto. If
   * empty, the GAIA ID from the request EUC is assumed to be the creator. We
   * only need at most one creator_gaia_id.
   */
  creatorGaiaId?: bigint;
  /**
   * Any types that are not the given item type, but derived later. For
   * example, if an item has type action.devices.types.OUTLET but is named
   * "floor lamp" we can derive that it also has type
   * action.devices.types.LIGHT. Also considered along with |type| when
   * triggering type-based actions.
   */
  derivedType?: string[];
  /**
   * See note in home_graph.proto; loaded into DE now to avoid having to
   * double-read assistant settings records as per
   * go/smarthome-removing-assistant-settings
   */
  deviceModelId?: string;
  /**
   * GCM address for cloud execution across google cloud messaging rather than
   * 3p cloud; for future use.
   */
  gcmExecutionAddress?: string;
  /**
   * List of parent group IDs, if the device is added to one or multiple device
   * groups (see go/home-groups). Will be consumed by Smart Home APIs and (in
   * the future) Assistant CTF to populate the group member list of device
   * groups.
   */
  groupIds?: string[];
  /**
   * The hash value from go/de-consistency-check
   */
  hashValue?: string;
  /**
   * Whether local home platform should discover new devices via LAN for the
   * structure.
   */
  lanscanOptedIn?: boolean;
  /**
   * Model name from HomeGraph, populated from model_manifest.model_name. See
   * b/200087451.
   */
  modelName?: string;
  /**
   * Indicates whether notifications have been enabled by a user and will be
   * announced for this device. This is set by the user within the Google app
   * settings, and Google will announce the device notification only if both
   * notification_supported_by_agent and notification_enabled_by_user are true.
   */
  notificationEnabledByUser?: boolean;
  /**
   * Indicates whether the device is capable of sending notifications. This
   * field will be set by the agent (partner) on an incoming SYNC. If a device
   * is not capable of generating notifications, the partner should set this
   * flag to false. If a partner is not capable of calling
   * ReportStateAndNotification to send notifications to Google, the partner
   * should set this flag to false. If there is a user setting in the partner
   * app to enable notifications and it is turned off, the partner should set
   * this flag to false.
   */
  notificationSupportedByAgent?: boolean;
  /**
   * Store custom data for agent calls here. This will likely be short-lived --
   * we will replace this with calls to HGS. (Note: This may end up not
   * temporary if we only need it for a couple partners -- more efficient to
   * have it on a few users than require HGS reads for all users.
   */
  opaqueCustomData?: string;
  /**
   * Operational CHIP Node ID that combines the fabric ID and node id in format
   * of . (Hex format without 0x prefix, for example,
   * 0F001234FA67AA39.1234ABCD1111DDDD).
   */
  operationalNodeId?: string;
  /**
   * Other agent id + foreign id pairs associated with the device. This can be
   * used to represent a group of devices (e.g. Sonos' bonded zone) as a single
   * device, or a device that comes in through different sync flows (e.g. Newman
   * with a Nest camera).
   */
  otherDeviceIds?: AssistantVerticalsHomeautomationProtoAgentDeviceId[];
  /**
   * Additional device sources. This can be the result of the device being
   * merged with other devices with a different source.
   */
  otherDeviceSources?:  | "UNKNOWN" | "CLOUD_SYNC" | "ASSISTANT_SETTING_OOBE" | "LOCAL_SYNC" | "CHIP_SYNC"[];
  /**
   * LINT.IfChange(home_graph_single_parent) At the moment, we just have a
   * single string. In future this will expand with additional metadata from
   * client or cloud execution data store. In today's 'tree' HomeGraph each
   * object has a single parent. In the future this may have a mesh for complex
   * cases -- zones, doors, etc -- so we make this a repeated element today.
   * LINT.ThenChange(//depot/google3/assistant/assistant_server/settings/user_defined_actions/footprints/footprint_accessor.cc:home_graph_single_parent)
   */
  parentNode?: string[];
  /**
   * The type of the parent. Currently only set for devices, to distinguish
   * between structure and room parents. Items currently have only one parent,
   * and entries after the first parent_type are ignored.
   */
  parentType?:  | "UNKNOWN_ITEM_TYPE" | "DEVICE" | "ROOM" | "PLACE" | "GROUP" | "SCENE" | "STRUCTURE"[];
  /**
   * User-given nicknames for an entity (e.g. "My house"). These nicknames are
   * unique to the gaia user. Nickname in DeviceInfo is per-entity level
   * nickname, while personalized_nicknames is per-user per-entity.
   */
  personalizedNicknames?: string[];
  /**
   * Stores the location for the STRUCTURE type.
   */
  physicalLocation?: AssistantVerticalsHomeautomationProtoPhysicalLocation;
  /**
   * We use this to determine if the synonyms matched in the aqua
   * interpretation is plural. Then we will return disambiguate dialog or
   * execute commands with all the targets.
   */
  plural?: string[];
  /**
   * Which of the values was the original, user-provided name -- or our
   * disambiguated, cleaned-up version of it. This is what we use in TTS when we
   * need to identify an object that wasn't just spoken uniquely by the user --
   * in disambiguation dialogue, or in response to a collective interrogative
   * (e.g. "what lights are on in the kitchen?")
   */
  primaryName?: string;
  /**
   * User's role information for this device. This will be used in Home
   * Automation server to decide if user has authority to fulfill its request.
   */
  roleInformation?: AssistantVerticalsHomeautomationProtoRoleInformation;
  /**
   * Only present for a target device. Indicates this target device is
   * reachable by a local (AoGH) path via an AoGH device.
   */
  routableViaGcm?: boolean;
  /**
   * SAFT Document with linguistic annotations for the primary device name.
   */
  saftDocument?: NlpSaftDocument;
  /**
   * Data needed for SDM (fleet management). See go/enterprise-id-in-assistant.
   */
  smartDeviceManagementData?: AssistantVerticalsHomeautomationProtoSmartDeviceManagementData;
  /**
   * SmartHome feature flags that may be enabled per-item.
   */
  smartHomeFeatures?: AssistantVerticalsHomeautomationProtoSmartHomeFeatures;
  /**
   * The features that are available for a structure. Will only be populated if
   * the item_type == STRUCTURE.
   */
  supportedStructureFeatures?: AssistantVerticalsHomeautomationProtoSupportedStructureFeatures;
  /**
   * Map from agent ID to supported traits. Some devices (e.g. Newman) have
   * multiple agents, with each agent being associated with a specific set of
   * traits. This could alternatively have been formatted as map as {trait,
   * agent} pairs instead of the {agent, list of trait} pairs, but we retain
   * this format to be consistent with HomeGraph's representation. In practice,
   * a trait should only be paired with a single agent (i.e. we should not have
   * two agents with the same trait in their value list). This field is optional
   * and should only be provided if the item has multiple agents.
   */
  supportedTraitsByAgent?: {
    [key: string]: AssistantVerticalsHomeautomationProtoHomeAutomation_MetaDataSupportedTraits
  };
  /**
   * This device supports direct response -- if the device itself is issuing
   * the query (which means it's also an assistant surface) we can return its
   * payload directly rather than via cloud.
   */
  supportsDirectResponse?: boolean;
  /**
   * Only present for an AoGH device. HGS Device ID of a target device and the
   * signal strength (RSSI in dB, higher is better) between that target device
   * and the AoGH device. If this map is empty, there are no target devices
   * reachable by this AoGH device.
   */
  targetDeviceSignalStrengths?: {
    [key: string]: bigint
  };
  /**
   * The timestamp at which the TDSS map was last updated. This information is
   * used to help determine which hub would be preferred if multiple hubs report
   * the same reach-ability for a device.
   */
  tdssUpdateTimestamp?: Date;
  /**
   * For SHED devices, some traits can only be executed on 3P cloud, e.g.
   * "action.devices.traits.MediaInitiation", "action.devices.traits.Channel"
   * go/shed-per-trait-routing
   */
  traitRoutingHints?: HomeGraphCommonTraitRoutingHints[];
  /**
   * Map from traits to routing table. Metadata includes preferred execution
   * path per trait and, when Matter is preferred, which endpoint should be used
   * for the trait.
   */
  traitRoutingTable?: {
    [key: string]: HomeGraphCommonRoutingTable
  };
  /**
   * Map of trait to a proto representing the attribute. This is different from
   * the attributes field above which is represented as a struct. The attributes
   * here are represented as protos and will require specific support per trait.
   */
  traitToAttributeProtos?: {
    [key: string]: AssistantVerticalsHomeautomationProtoAttributes
  };
  /**
   * The item type, such as "action.devices.types.VACUUM" - to be used in
   * triggering type-based actions, e.g. "start vacuuming":
   * go/smarthome-type-based-actions.
   */
  type?: string;
  /**
   * The priority order of speech targeting: 1. user_defined_device_type 2.
   * derived_device_type 3. device_type
   */
  userDefinedDeviceType?: string;
  /**
   * Set to which level of voice match is needed. Enum based on string input
   * from the partner in json sync. Values accepted: "none" (but in this case
   * partners won't set it), "owner" [requires matching one of the creator gaia
   * IDs], or "member" [any recognized voice 'enrolled' on the device]. This may
   * expand; only "owner" is in use for first partner, Tile.
   */
  voiceMatchRequired?:  | "ANY" | "OWNER" | "MEMBER";
  /**
   * This device will report state; we can query realtime state from local HGS
   * rather than slow QUERY intent to the 3p cloud.
   */
  willReportState?: boolean;
  /**
   * SAFT Document with linguistic annotations for the zone name, if
   * applicable.
   */
  zoneNameSaftDocument?: NlpSaftDocument;
}

function serializeAssistantVerticalsHomeautomationProtoHomeAutomation_MetaData(data: any): AssistantVerticalsHomeautomationProtoHomeAutomation_MetaData {
  return {
    ...data,
    creatorGaiaId: data["creatorGaiaId"] !== undefined ? String(data["creatorGaiaId"]) : undefined,
    saftDocument: data["saftDocument"] !== undefined ? serializeNlpSaftDocument(data["saftDocument"]) : undefined,
    targetDeviceSignalStrengths: data["targetDeviceSignalStrengths"] !== undefined ? Object.fromEntries(Object.entries(data["targetDeviceSignalStrengths"]).map(([k, v]: [string, any]) => ([k, String(v)]))) : undefined,
    tdssUpdateTimestamp: data["tdssUpdateTimestamp"] !== undefined ? data["tdssUpdateTimestamp"].toISOString() : undefined,
    zoneNameSaftDocument: data["zoneNameSaftDocument"] !== undefined ? serializeNlpSaftDocument(data["zoneNameSaftDocument"]) : undefined,
  };
}

function deserializeAssistantVerticalsHomeautomationProtoHomeAutomation_MetaData(data: any): AssistantVerticalsHomeautomationProtoHomeAutomation_MetaData {
  return {
    ...data,
    creatorGaiaId: data["creatorGaiaId"] !== undefined ? BigInt(data["creatorGaiaId"]) : undefined,
    saftDocument: data["saftDocument"] !== undefined ? deserializeNlpSaftDocument(data["saftDocument"]) : undefined,
    targetDeviceSignalStrengths: data["targetDeviceSignalStrengths"] !== undefined ? Object.fromEntries(Object.entries(data["targetDeviceSignalStrengths"]).map(([k, v]: [string, any]) => ([k, BigInt(v)]))) : undefined,
    tdssUpdateTimestamp: data["tdssUpdateTimestamp"] !== undefined ? new Date(data["tdssUpdateTimestamp"]) : undefined,
    zoneNameSaftDocument: data["zoneNameSaftDocument"] !== undefined ? deserializeNlpSaftDocument(data["zoneNameSaftDocument"]) : undefined,
  };
}

export interface AssistantVerticalsHomeautomationProtoHomeAutomation_MetaDataSupportedTraits {
  traits?: string[];
}

/**
 * Next ID: 9
 */
export interface AssistantVerticalsHomeautomationProtoHomeAutomationDevice {
  /**
   * the next 3 fields are for Lumos output (DTO) that needs to be propagated
   * to the Fulfilment through the HomeAutomationDevice proto.
   */
  deviceSelectionLog?: AssistantLogsDeviceSelectionLog;
  dtoError?: AssistantDeviceTargetingDeviceTargetingError;
  /**
   * This field is from query_info in DTO.
   */
  dtoQueryInfo?: AssistantVerticalsHomeautomationProtoDeviceTargetingOutputQueryInfo;
  /**
   * Device meta data.
   */
  homeautomationMetadata?: AssistantVerticalsHomeautomationProtoHomeAutomation_MetaData;
  /**
   * list of HomeAutomationDeviceItem. After migration completes, we will mark
   * the above 4 field as deprecated and only use this field.
   */
  list?: AssistantVerticalsHomeautomationProtoHomeAutomationDeviceItem[];
  /**
   * Corresponding to casse matched_item CustomTypeItem key.
   */
  matchedItemKey?: string;
  /**
   * Corresponding to casse Argument raw_value.
   */
  matchedItemRawvalue?: string;
  /**
   * Corresponding to casse matched_item CustomTypeItem value.
   */
  matchedItemValue?: string[];
}

function serializeAssistantVerticalsHomeautomationProtoHomeAutomationDevice(data: any): AssistantVerticalsHomeautomationProtoHomeAutomationDevice {
  return {
    ...data,
    deviceSelectionLog: data["deviceSelectionLog"] !== undefined ? serializeAssistantLogsDeviceSelectionLog(data["deviceSelectionLog"]) : undefined,
    homeautomationMetadata: data["homeautomationMetadata"] !== undefined ? serializeAssistantVerticalsHomeautomationProtoHomeAutomation_MetaData(data["homeautomationMetadata"]) : undefined,
    list: data["list"] !== undefined ? data["list"].map((item: any) => (serializeAssistantVerticalsHomeautomationProtoHomeAutomationDeviceItem(item))) : undefined,
  };
}

function deserializeAssistantVerticalsHomeautomationProtoHomeAutomationDevice(data: any): AssistantVerticalsHomeautomationProtoHomeAutomationDevice {
  return {
    ...data,
    deviceSelectionLog: data["deviceSelectionLog"] !== undefined ? deserializeAssistantLogsDeviceSelectionLog(data["deviceSelectionLog"]) : undefined,
    homeautomationMetadata: data["homeautomationMetadata"] !== undefined ? deserializeAssistantVerticalsHomeautomationProtoHomeAutomation_MetaData(data["homeautomationMetadata"]) : undefined,
    list: data["list"] !== undefined ? data["list"].map((item: any) => (deserializeAssistantVerticalsHomeautomationProtoHomeAutomationDeviceItem(item))) : undefined,
  };
}

export interface AssistantVerticalsHomeautomationProtoHomeAutomationDeviceItem {
  /**
   * Device meta data.
   */
  homeautomationMetadata?: AssistantVerticalsHomeautomationProtoHomeAutomation_MetaData;
  /**
   * Corresponding to casse matched_item CustomTypeItem key.
   */
  matchedItemKey?: string;
  /**
   * Corresponding to casse Argument raw_value.
   */
  matchedItemRawvalue?: string;
  /**
   * Corresponding to casse matched_item CustomTypeItem value.
   */
  matchedItemValue?: string[];
}

function serializeAssistantVerticalsHomeautomationProtoHomeAutomationDeviceItem(data: any): AssistantVerticalsHomeautomationProtoHomeAutomationDeviceItem {
  return {
    ...data,
    homeautomationMetadata: data["homeautomationMetadata"] !== undefined ? serializeAssistantVerticalsHomeautomationProtoHomeAutomation_MetaData(data["homeautomationMetadata"]) : undefined,
  };
}

function deserializeAssistantVerticalsHomeautomationProtoHomeAutomationDeviceItem(data: any): AssistantVerticalsHomeautomationProtoHomeAutomationDeviceItem {
  return {
    ...data,
    homeautomationMetadata: data["homeautomationMetadata"] !== undefined ? deserializeAssistantVerticalsHomeautomationProtoHomeAutomation_MetaData(data["homeautomationMetadata"]) : undefined,
  };
}

export interface AssistantVerticalsHomeautomationProtoPhysicalLocation {
  address?: string;
  geoLocation?: GoogleTypeLatLng;
}

/**
 * Represents the user’s role such as assistant only or manager for a device.
 * Design doc:
 * https://docs.google.com/document/d/1c1hnauEbBfDkywO3GZkI8ejHP765l2tLspmPgckEe2Y/
 */
export interface AssistantVerticalsHomeautomationProtoRoleInformation {
  /**
   * When true, role_type will be ignored, Nest IAM RPC will called to check
   * authority.
   */
  iamCheckRequired?: boolean;
  roleType?:  | "UNDEFINED" | "ASSISTANT_ONLY" | "CAST_LEGACY_LINKED" | "MANAGER";
}

export interface AssistantVerticalsHomeautomationProtoSmartDeviceManagementData {
  /**
   * The enterprise that owns the structure. E.g. Disney, Dream Hotel, etc.
   * This is used for log/analytics purpose. For privacy reasons, we log at
   * enterprise level instead of structure level.
   */
  enterpriseId?: string;
}

/**
 * SmartHome feature flags that may be enabled per-item. LINT.IfChange
 */
export interface AssistantVerticalsHomeautomationProtoSmartHomeFeatures {
  /**
   * Flag indicating whether the background Circadian Lighting effect is
   * enabled for a particular light (go/circadian-lighting-e2e).
   */
  circadianLightingEnabled?: boolean;
  /**
   * Flag indicating whether automatic Energy Savings are enabled for this
   * item.
   */
  energySavingsEnabled?: boolean;
  /**
   * Flag indicating whether Gentle Wake Up is enabled for this item
   * (go/sleep-wake-design).
   */
  gentleWakeupEnabled?: boolean;
  /**
   * Flag indicating whether the user has enabled / disabled sending Home/Away
   * status updates to the device through the Google custom IntelligenceEvents
   * Matter cluster. (go/google-clusters-design)
   */
  homeAwayOverMatterEnabled?: boolean;
}

/**
 * The features a structure supports.
 */
export interface AssistantVerticalsHomeautomationProtoSupportedStructureFeatures {
  conciergeFeatures?: AssistantVerticalsHomeautomationProtoConciergeFeatures;
}

/**
 * Represents the properties of a mention. Next ID: 13
 */
export interface AttentionalEntitiesMentionProperties {
  /**
   * The unique device on which the mention occurred. For example, if the user
   * has two Google Home devices, this indicates which of the two was used.
   */
  deviceId?: AssistantApiCoreTypesDeviceId;
  /**
   * ID of the event that resulted in this entity mention. For user and system
   * turn AEs, this is taken from the ConversationSnapshotId of the snapshot
   * containing this mention. For client AEs, this is empty. This can be used to
   * join back this particular mention to the specific "turn" in which this
   * mention took place.
   */
  eventId?: EventIdMessage;
  /**
   * If this mention corresponds to a WebAnswer, then this defines the score
   * associated with that answer.
   */
  factoidScore?: number;
  /**
   * If present, this entity was mentioned as part of a larger list.
   */
  listEntryInfo?: AttentionalEntitiesMentionPropertiesListEntryInfo;
  /**
   * Estimates the recency of the mention. This is internally computed at
   * runtime on a turn-by-turn basis.
   */
  recency?:  | "RECENCY_UNSPECIFIED" | "MOST_RECENT_TURN";
  /**
   * The semantic role that the entity was used in.
   */
  role?: AttentionalEntitiesSemanticRoleId;
  /**
   * How salient this mention is. This field will only be set if the mention is
   * derived from a SearchAnswerValue. See go/webresultsdata-as-aes for more
   * details.
   */
  salience?:  | "UNKNOWN_SALIENCE" | "PRIMARY" | "METADATA";
  /**
   * Contains metadata about the source of the mention.
   */
  source?: AttentionalEntitiesMentionPropertiesSource;
  /**
   * If present, properties of visual mentions (e.g., how they are displayed to
   * the user, visibility, etc.).
   */
  spatialProperties?: AttentionalEntitiesSpatialProperties;
  /**
   * Details about how this mention was presented.
   */
  surfaceForm?: AttentionalEntitiesSurfaceForm;
  /**
   * Unix timestamp noting (approximately) when this mention occurred. We do
   * not guarantee that the time will correspond precisely to when the user
   * uttered/heard a response. If mentions within a single turn have *different*
   * timestamps, they should accurately reflect the order in which the mentions
   * occurred. If that order is unknown, they should all have the same
   * timestamp.
   */
  timestamp?: Date;
}

function serializeAttentionalEntitiesMentionProperties(data: any): AttentionalEntitiesMentionProperties {
  return {
    ...data,
    eventId: data["eventId"] !== undefined ? serializeEventIdMessage(data["eventId"]) : undefined,
    listEntryInfo: data["listEntryInfo"] !== undefined ? serializeAttentionalEntitiesMentionPropertiesListEntryInfo(data["listEntryInfo"]) : undefined,
    timestamp: data["timestamp"] !== undefined ? data["timestamp"].toISOString() : undefined,
  };
}

function deserializeAttentionalEntitiesMentionProperties(data: any): AttentionalEntitiesMentionProperties {
  return {
    ...data,
    eventId: data["eventId"] !== undefined ? deserializeEventIdMessage(data["eventId"]) : undefined,
    listEntryInfo: data["listEntryInfo"] !== undefined ? deserializeAttentionalEntitiesMentionPropertiesListEntryInfo(data["listEntryInfo"]) : undefined,
    timestamp: data["timestamp"] !== undefined ? new Date(data["timestamp"]) : undefined,
  };
}

/**
 * Contains information about how an entity was presented as part of a list.
 */
export interface AttentionalEntitiesMentionPropertiesListEntryInfo {
  /**
   * The index of the entity presented to the user. NOTE: Indexing starts from
   * 0.
   */
  index?: bigint;
  /**
   * A string which uniquely identifies the list item this entity represents in
   * the list. For example, consider the "OrderPizza" intent with the "size"
   * slot: U: I want to order a pizza A: Sure. What size do you want: large,
   * medium, or small? U: Gigantic The lexical_groundings_id can be "large" to
   * identify the large item in the list. This lexical_groundings_id together
   * with the semantic role fields (i.e., role.intent_id & role.role_id) can be
   * used to match the nlp_semantic_parsing::LexicalGroundings::ValueTermType to
   * utilize lexical grounding for i18n of static list selection items. Note
   * that this field only needs to be populated when developers expect to
   * provide lexical groundings for the list item this entity represents.
   * Effectively, this field will be populated when this entity is published by
   * ListPresentationFrame and the
   * ::quality::dialog_manager::IntentStageSignals::FieldCandidate.lexical_groundings_id
   * field is populated. See go/lpf-i18nv2 & go/taskstate-ae-sync for more
   * details.
   */
  lexicalGroundingsId?: string;
}

function serializeAttentionalEntitiesMentionPropertiesListEntryInfo(data: any): AttentionalEntitiesMentionPropertiesListEntryInfo {
  return {
    ...data,
    index: data["index"] !== undefined ? String(data["index"]) : undefined,
  };
}

function deserializeAttentionalEntitiesMentionPropertiesListEntryInfo(data: any): AttentionalEntitiesMentionPropertiesListEntryInfo {
  return {
    ...data,
    index: data["index"] !== undefined ? BigInt(data["index"]) : undefined,
  };
}

/**
 * The agent or system from which the mention was derived. Each mention
 * corresponds to a single source.
 */
export interface AttentionalEntitiesMentionPropertiesSource {
  client?: AttentionalEntitiesMentionPropertiesSourceClient;
  system?: AttentionalEntitiesMentionPropertiesSourceSystem;
  user?: AttentionalEntitiesMentionPropertiesSourceUser;
}

/**
 * The client provided this entity. Currently, this exclusively corresponds to
 * an entity that was circulated by the client. See go/on-device-aes for more
 * details.
 */
export interface AttentionalEntitiesMentionPropertiesSourceClient {
}

/**
 * The Assistant mentioned this entity. This corresponds to entities annotated
 * during fulfillment. More specifically, these entities are typically provided
 * by developers either via a Monastery frame or an InteractionBuilder.
 */
export interface AttentionalEntitiesMentionPropertiesSourceSystem {
}

/**
 * The user mentioned this entity. It was extracted from a previous winning
 * intent (IntentQuery or IntentUpdate). Such entities are computed at runtime
 * from the interpretation history without any developer intervention.
 */
export interface AttentionalEntitiesMentionPropertiesSourceUser {
}

/**
 * Uniquely identifies a semantic role. When this role corresponds to a slot in
 * a registered user intent (see go/assistant-intent-catalog), then the
 * SemanticRoleId maps precisely onto that slot in the intent catalog. However,
 * not all semantic roles corresponds to such user intent slots.
 */
export interface AttentionalEntitiesSemanticRoleId {
  /**
   * Semantic roles will be defined locally, within the context of a single
   * task/feature. The |intent_id| is a unique identifier for such a local
   * cluster. In most cases, this should be exactly the same as the name of the
   * intent used for TaskState (see go/assistant-intent-catalog). In cases where
   * the intent isn't well-defined, this can be an arbitrary, feature-defined
   * identifier.
   */
  intentId?: string;
  /**
   * Identifier for a semantic role, unique within the namespace of
   * |intent_id|. When this role corresponds to a slot in the intent, the
   * |role_id| should be equal to the name of that argument. For example,
   * consider an entry in the intent catalog: core_intent { id { id: "BookARide"
   * } slot { name: "provider" type { string_type { } } } slot { name:
   * "num_riders" type { number_type { } } } } Then, the |role_id| would be
   * "provider" or "num_riders" when referring to one of these slots. NOTE: when
   * responding to the user, the Assistant may actually make use of other roles
   * such as "ETA" or "driver" that are not part of the intent declaration.
   * These should still be assigned consistent semantic roles. For example, a
   * dialog with the Shopping feature: User: Where can I buy XYZ? Google: [Best
   * Buy in Sunnyvale] has [XYZ] in stock. User: Great! Give me directions. In
   * this case, both "Best Buy" and "XYZ" would be pushed to attentional
   * entities. Best Buy, in this case, may not be an argument in the
   * ShoppingItemStockInquiry intent, but should still have a consistent
   * |role_id| such as "possessing_business".
   */
  roleId?: string;
}

/**
 * Properties of visual mentions (e.g., how they are displayed to the user,
 * visibility, etc.).
 */
export interface AttentionalEntitiesSpatialProperties {
  visibility?:  | "UNKNOWN_VISIBILITY" | "VISIBLE" | "HIDDEN";
}

/**
 * How the entity was presented in this mention at a surface level. For
 * example, "President Barack Obama" or "Barack Obama" or "he" might all be
 * reasonable surface forms for the MID /m/02mjmr.
 */
export interface AttentionalEntitiesSurfaceForm {
  text?: string;
}

/**
 * This data is expected to appear in approximately 2 out of every 1,000
 * documents with an average of 2 fields per document. Rough order of size is in
 * the hundreds of kilobytes per Mustang shard.
 */
export interface BiasingPerDocData {
  biasingfield?: BiasingPerDocDataBiasingField[];
}

function serializeBiasingPerDocData(data: any): BiasingPerDocData {
  return {
    ...data,
    biasingfield: data["biasingfield"] !== undefined ? data["biasingfield"].map((item: any) => (serializeBiasingPerDocDataBiasingField(item))) : undefined,
  };
}

function deserializeBiasingPerDocData(data: any): BiasingPerDocData {
  return {
    ...data,
    biasingfield: data["biasingfield"] !== undefined ? data["biasingfield"].map((item: any) => (deserializeBiasingPerDocDataBiasingField(item))) : undefined,
  };
}

/**
 * A replacement for BiasingPerDocData that is more efficient wrt size in the
 * index.
 */
export interface BiasingPerDocData2 {
  biasingField?: BiasingPerDocData2BiasingField[];
}

export interface BiasingPerDocData2BiasingField {
  /**
   * A fingerprint of the actual name of the field.
   */
  compressedName?: number;
  /**
   * The value, under various representations to get maximum compression.
   * Exactly one of them is guaranteed to be filled. value as a double.
   */
  value?: number;
  /**
   * a floating value, represented as an integer by converting using
   * floating_value * 1000. Useable for all floating values that need 3 digits
   * of precision, and are small enough.
   */
  valueFloat?: number;
  /**
   * value as an int32. When the value is encode-able as an integer.
   */
  valueInt?: number;
}

/**
 * Metadata fields on which we can bias (sort) search results independently
 * from the normal ranking using a ScoreAdjuster
 */
export interface BiasingPerDocDataBiasingField {
  /**
   * Fingerprint of the attribute name (no need to keep long field names)
   */
  Name?: bigint;
  /**
   * Biasing value translated into a double for uniform comparison
   */
  Value?: number;
}

function serializeBiasingPerDocDataBiasingField(data: any): BiasingPerDocDataBiasingField {
  return {
    ...data,
    Name: data["Name"] !== undefined ? String(data["Name"]) : undefined,
  };
}

function deserializeBiasingPerDocDataBiasingField(data: any): BiasingPerDocDataBiasingField {
  return {
    ...data,
    Name: data["Name"] !== undefined ? BigInt(data["Name"]) : undefined,
  };
}

/**
 * A BlobRef is used to refer to a blob in BlobStore. Clients may only
 * manipulate blobs through BlobRefs. BlobRefs should not be sent in the clear
 * outside of Google (for example, encoded in URLs, stored in a client cookie,
 * or referred to in Javascript); for efficiency, the IDs expose internal
 * details of the blobstore (such as machine IPs or cluster names). If clients
 * need to store BlobRefs outside of Google, they must encrypt the BlobRef
 * securely or use an alternative insecure identifier with an id->BlobRef
 * mapping inside our network.
 */
export interface BlobstoreBlobRef {
  BlobID?: Uint8Array;
  Options?: bigint;
  RefID?: Uint8Array;
  ShardBin?: number;
  /**
   * Size of the complete blob, in bytes.
   */
  Size?: bigint;
  /**
   * The ID of the V2 blob this blob has
   */
  SourceV2BlobID?: string;
  /**
   * Deprecated.
   */
  V2ReadBlobToken?: string;
}

function serializeBlobstoreBlobRef(data: any): BlobstoreBlobRef {
  return {
    ...data,
    BlobID: data["BlobID"] !== undefined ? encodeBase64(data["BlobID"]) : undefined,
    Options: data["Options"] !== undefined ? String(data["Options"]) : undefined,
    RefID: data["RefID"] !== undefined ? encodeBase64(data["RefID"]) : undefined,
    Size: data["Size"] !== undefined ? String(data["Size"]) : undefined,
  };
}

function deserializeBlobstoreBlobRef(data: any): BlobstoreBlobRef {
  return {
    ...data,
    BlobID: data["BlobID"] !== undefined ? decodeBase64(data["BlobID"] as string) : undefined,
    Options: data["Options"] !== undefined ? BigInt(data["Options"]) : undefined,
    RefID: data["RefID"] !== undefined ? decodeBase64(data["RefID"] as string) : undefined,
    Size: data["Size"] !== undefined ? BigInt(data["Size"]) : undefined,
  };
}

/**
 * Additional data for Blog/Posts
 */
export interface BlogPerDocData {
  /**
   * used for blogurl crowding.
   */
  blogurlFp?: bigint;
  /**
   * This score captures how spammy the client is that the micropost was
   * created with. The higher the score the worse.
   */
  clientSpamminess?: number;
  /**
   * For the threaded conversation view. Only populated in docs with provider
   * type SYNTHETIC_CONVERSATION_DOC.
   */
  convTree?: BlogsearchConversationTree;
  copycatScore?: number;
  docQualityScore?: number;
  /**
   * A syntactic reshare is a document that is * created from an original and
   * shared with friends and * we detect this resharing property by
   * syntactically parsing the doc. . For example, a retweet is an example of a
   * syntactic_reshare because we can detect that it's a reshare by grepping for
   * "RT @".
   */
  isSyntacticReshare?: boolean;
  /**
   * Experimental data for quality experiments. This will NOT be populated in
   * prod, but we will use this for experiments.
   */
  microblogQualityExptData?: Proto2BridgeMessageSet;
  /**
   * For replies/reshares. num_mentions = number of times the pattern @foo
   * appears in the document.
   */
  numMentions?: number;
  outlinks?: BlogPerDocDataOutlinks[];
  /**
   * The fingerprint for the body text of the microblog post. It is copied from
   * MicroBlogPost.post_content_fingerprint.
   */
  postContentFingerprint?: number;
  qualityScore?: number;
  /**
   * Blog scoring signals.
   */
  spamScore?: number;
  universalWhitelisted?: boolean;
  /**
   * User and doc quality scores for updates (aka microposts).
   */
  userQualityScore?: number;
}

function serializeBlogPerDocData(data: any): BlogPerDocData {
  return {
    ...data,
    blogurlFp: data["blogurlFp"] !== undefined ? String(data["blogurlFp"]) : undefined,
    convTree: data["convTree"] !== undefined ? serializeBlogsearchConversationTree(data["convTree"]) : undefined,
    outlinks: data["outlinks"] !== undefined ? data["outlinks"].map((item: any) => (serializeBlogPerDocDataOutlinks(item))) : undefined,
  };
}

function deserializeBlogPerDocData(data: any): BlogPerDocData {
  return {
    ...data,
    blogurlFp: data["blogurlFp"] !== undefined ? BigInt(data["blogurlFp"]) : undefined,
    convTree: data["convTree"] !== undefined ? deserializeBlogsearchConversationTree(data["convTree"]) : undefined,
    outlinks: data["outlinks"] !== undefined ? data["outlinks"].map((item: any) => (deserializeBlogPerDocDataOutlinks(item))) : undefined,
  };
}

/**
 * Resolved url and site spamscore for outlinks in updates (aka microposts).
 */
export interface BlogPerDocDataOutlinks {
  /**
   * Representative id for an equivalence class of URLs. E.g.
   * http://youtube.com/watch?v=12 and
   * http://youtube.com/watch?v=12&feature=related have the same aggregation id
   * since they're effectively the same webpage
   */
  aggregationFp?: bigint;
  resolvedUrl?: string;
  siteSpamScore?: number;
  title?: string;
}

function serializeBlogPerDocDataOutlinks(data: any): BlogPerDocDataOutlinks {
  return {
    ...data,
    aggregationFp: data["aggregationFp"] !== undefined ? String(data["aggregationFp"]) : undefined,
  };
}

function deserializeBlogPerDocDataOutlinks(data: any): BlogPerDocDataOutlinks {
  return {
    ...data,
    aggregationFp: data["aggregationFp"] !== undefined ? BigInt(data["aggregationFp"]) : undefined,
  };
}

export interface BlogsearchConversationNode {
  /**
   * The username of the author of the microblog post represented by this node.
   */
  authorName?: string;
  /**
   * A list of docids of child nodes.
   */
  children?: string[];
  /**
   * The creation date of the doc.
   */
  date?: bigint;
  /**
   * Docid of the microblog post represented by this node.
   */
  docid?: string;
  /**
   * The docid of the parent node. The root of the tree will leave this empty.
   */
  parent?: string;
}

function serializeBlogsearchConversationNode(data: any): BlogsearchConversationNode {
  return {
    ...data,
    date: data["date"] !== undefined ? String(data["date"]) : undefined,
  };
}

function deserializeBlogsearchConversationNode(data: any): BlogsearchConversationNode {
  return {
    ...data,
    date: data["date"] !== undefined ? BigInt(data["date"]) : undefined,
  };
}

export interface BlogsearchConversationTree {
  /**
   * The id of this conversation.
   */
  convId?: string;
  /**
   * The nodes in this conversation. No particular order is assumed.
   */
  nodes?: BlogsearchConversationNode[];
}

function serializeBlogsearchConversationTree(data: any): BlogsearchConversationTree {
  return {
    ...data,
    nodes: data["nodes"] !== undefined ? data["nodes"].map((item: any) => (serializeBlogsearchConversationNode(item))) : undefined,
  };
}

function deserializeBlogsearchConversationTree(data: any): BlogsearchConversationTree {
  return {
    ...data,
    nodes: data["nodes"] !== undefined ? data["nodes"].map((item: any) => (deserializeBlogsearchConversationNode(item))) : undefined,
  };
}

/**
 * Information to indicate BG availability for businesses. This message is
 * filled from Topic Server and stored in the GSR in Superroot.
 */
export interface BlueGingerClientVisibleProtoBlueGingerSupportedServices {
  /**
   * List of supported modules for a business.
   */
  modules?: BlueGingerClientVisibleProtoBlueGingerSupportedServicesBlueGingerModule[];
}

export interface BlueGingerClientVisibleProtoBlueGingerSupportedServicesBlueGingerModule {
  /**
   * Module name, e.g. hairdresser_reservation. from
   * quality/views/extraction/kcube/bg/modules/modules.bzl.
   */
  name?: string;
  /**
   * Services of this module that are supported by the business, e.g. haircuts.
   */
  services?: string[];
  useCase?:  | "UNKNOWN_USE_CASE" | "OPENING_HOURS" | "ON_DEMAND_OPENING_HOURS" | "GEO_DATA_EXTRACTION" | "OPERATING_MODE_EXTRACTION" | "RESTAURANT_RESERVATION" | "MASSAGE_RESERVATION" | "HAIRDRESSER_RESERVATION" | "NAIL_SALON_RESERVATION" | "RUNNING_LATE" | "FOOD_ORDERING" | "LOCAL_INVENTORY_CHECK" | "ON_DEMAND_LOCAL_INVENTORY" | "WAITLIST" | "CHECK_WAIT" | "CHEFBOT" | "ADS_CALL_CENTER_AUTHENTICATION" | "PLAYSTORE" | "TAKING_RESTAURANT_RESERVATIONS" | "CALL_CENTER_DEMO" | "ASSISTED_CALL_DEMO" | "BUSINESS_OPT_IN" | "CALLJOY_PILOT" | "ASSISTANT_REMINDERS_DEMO" | "HAPPY_BIRTHDAY" | "ASSISTED_IVR" | "DUPLEX_FOR_BUSINESS_PILOT" | "SAY_THE_SAME_THING" | "COVID_FAQ" | "VANCOUVER" | "MEENAPLEX" | "REMOVED_USE_CASE_6" | "SEMI_DELEGATED_CALLING" | "HARDWARE_SETUP" | "DUMDA_BOT" | "SMART_REPLY" | "DUPLEX_ZERO" | "SPAM_FILTER" | "TEXT" | "IVR_CRAWLING" | "VOICEMAIL" | "INBOUND_SMB" | "CCAI_DEMO" | "DIALOGFLOW_DELEGATION" | "AD_LEAD_VERIFICATION" | "GET_HUMAN" | "CHECK_INSURANCE_ACCEPTANCE";
}

/**
 * Per-doc data for the web page about the cited book Approximate size is on
 * average ~10bytes
 */
export interface BookCitationPerDocData {
  /**
   * the book id for the main citation
   */
  bookId?: bigint;
  /**
   * the discretized citation score for the main book. we map the raw score
   * 1.0-20.0 to 0 - 127
   */
  discretizedCitationScore?: number;
  /**
   * Is there a preview or excerpt of the book on this document?
   */
  previewable?: boolean;
  /**
   * book id for the second citation if we can't separate the two top citations
   * (they are too close).
   */
  secondBookId?: bigint;
  /**
   * the discretized score for the second citation
   */
  secondDiscretizedCitationScore?: number;
}

function serializeBookCitationPerDocData(data: any): BookCitationPerDocData {
  return {
    ...data,
    bookId: data["bookId"] !== undefined ? String(data["bookId"]) : undefined,
    secondBookId: data["secondBookId"] !== undefined ? String(data["secondBookId"]) : undefined,
  };
}

function deserializeBookCitationPerDocData(data: any): BookCitationPerDocData {
  return {
    ...data,
    bookId: data["bookId"] !== undefined ? BigInt(data["bookId"]) : undefined,
    secondBookId: data["secondBookId"] !== undefined ? BigInt(data["secondBookId"]) : undefined,
  };
}

/**
 * We divide up a week into individual open intervals. If any are present then
 * they must be arranged in strictly increasing order, with non-empty spaces
 * between successive intervals, and all times between 0 and 604800, the number
 * of seconds in a week.
 */
export interface BusinessHours {
  dayopen?: number;
  interval?: BusinessHoursInterval[];
}

export interface BusinessHoursInterval {
  /**
   * The interval ends at the start of this second
   */
  end?: number;
  /**
   * Time in seconds since Midnight-Monday-Morn
   */
  start?: number;
}

/**
 * Token to be exposed and stored by the bot
 */
export interface ChatBotPlatformBotSendToken {
  /**
   * Time since epoch (micros) that this will expire
   */
  expiryTimeMicros?: bigint;
  /**
   * Encrypted InternalSendToken
   */
  sendToken?: Uint8Array;
}

function serializeChatBotPlatformBotSendToken(data: any): ChatBotPlatformBotSendToken {
  return {
    ...data,
    expiryTimeMicros: data["expiryTimeMicros"] !== undefined ? String(data["expiryTimeMicros"]) : undefined,
    sendToken: data["sendToken"] !== undefined ? encodeBase64(data["sendToken"]) : undefined,
  };
}

function deserializeChatBotPlatformBotSendToken(data: any): ChatBotPlatformBotSendToken {
  return {
    ...data,
    expiryTimeMicros: data["expiryTimeMicros"] !== undefined ? BigInt(data["expiryTimeMicros"]) : undefined,
    sendToken: data["sendToken"] !== undefined ? decodeBase64(data["sendToken"] as string) : undefined,
  };
}

export interface ChatBotPlatformFireballId {
  /**
   * When used as a user ID, it's the phone number of the sender. When used as
   * a session ID: For group conversation, it is the group ID. For 1 to 1, it is
   * the receiver or sender phone number. For 1 to bot, it is the receiver phone
   * number or empty.
   */
  id?: GoogleInternalCommunicationsInstantmessagingV1Id;
}

function serializeChatBotPlatformFireballId(data: any): ChatBotPlatformFireballId {
  return {
    ...data,
    id: data["id"] !== undefined ? serializeGoogleInternalCommunicationsInstantmessagingV1Id(data["id"]) : undefined,
  };
}

function deserializeChatBotPlatformFireballId(data: any): ChatBotPlatformFireballId {
  return {
    ...data,
    id: data["id"] !== undefined ? deserializeGoogleInternalCommunicationsInstantmessagingV1Id(data["id"]) : undefined,
  };
}

/**
 * Per-URL porn scores for the URLs associated with the corresponding image.
 */
export interface ClassifierPornAggregatedUrlPornScores {
  averageUrlPornScore?: number;
  urlCount?: number;
}

/**
 * Next ID: 6
 */
export interface ClassifierPornClassifierData {
  classification?: ClassifierPornClassifierDataClassification[];
  /**
   * Records whether the image linker is run already. This is only used for
   * Alexandria but NOT for Segindexer.
   */
  imageBasedDetectionDone?: boolean;
  timestamp?: bigint;
}

function serializeClassifierPornClassifierData(data: any): ClassifierPornClassifierData {
  return {
    ...data,
    timestamp: data["timestamp"] !== undefined ? String(data["timestamp"]) : undefined,
  };
}

function deserializeClassifierPornClassifierData(data: any): ClassifierPornClassifierData {
  return {
    ...data,
    timestamp: data["timestamp"] !== undefined ? BigInt(data["timestamp"]) : undefined,
  };
}

export interface ClassifierPornClassifierDataClassification {
  label?: string;
  score?: number;
}

/**
 * Next ID: 3
 */
export interface ClassifierPornDocumentData {
  classifierdata?: ClassifierPornClassifierData;
  sitedata?: ClassifierPornSiteData;
}

function serializeClassifierPornDocumentData(data: any): ClassifierPornDocumentData {
  return {
    ...data,
    classifierdata: data["classifierdata"] !== undefined ? serializeClassifierPornClassifierData(data["classifierdata"]) : undefined,
    sitedata: data["sitedata"] !== undefined ? serializeClassifierPornSiteData(data["sitedata"]) : undefined,
  };
}

function deserializeClassifierPornDocumentData(data: any): ClassifierPornDocumentData {
  return {
    ...data,
    classifierdata: data["classifierdata"] !== undefined ? deserializeClassifierPornClassifierData(data["classifierdata"]) : undefined,
    sitedata: data["sitedata"] !== undefined ? deserializeClassifierPornSiteData(data["sitedata"]) : undefined,
  };
}

/**
 * Generic output for one vertical.
 */
export interface ClassifierPornQueryClassifierOutput {
  /**
   * This field is only filled for the CSAI vertical.
   */
  csaiClassification?:  | "NOT_PROTECTED" | "PROTECTED" | "STRONGLY_PROTECTED";
  /**
   * DO NOT USE: This field is temporary and should be used only for the CSAI
   * Onebox. This field is the result of the regular expression classifier alone
   * as opposed to a combination with Seti classifier as in csai_classification
   * field.
   */
  csaiRegexpHighConfidenceClassification?:  | "NOT_PROTECTED" | "PROTECTED" | "STRONGLY_PROTECTED";
  /**
   * Human-readable debug information about the classification. This field is
   * only set if output_debug is set in the classification input.
   */
  debug?: string;
  /**
   * The bit that shows if this classifier outputs positive classification for
   * the input query. Set by thresholding with a recommended threshold.
   */
  isPositive?: boolean;
  /**
   * The score that the classifier assigned to the input query. This is filled
   * by all verticals.
   */
  score?: number;
}

/**
 * Multi-label classification output. It contains the output for each vertical.
 * The output for some verticals can be empty, in case that vertical is not
 * supported by the classifier or if the set of verticals was restricted using
 * MultiLabelClassifierInput.verticals.
 */
export interface ClassifierPornQueryMultiLabelClassifierOutput {
  csai?: ClassifierPornQueryClassifierOutput;
  fringe?: ClassifierPornQueryClassifierOutput;
  medical?: ClassifierPornQueryClassifierOutput;
  offensive?: ClassifierPornQueryClassifierOutput;
  porn?: ClassifierPornQueryClassifierOutput;
  spoof?: ClassifierPornQueryClassifierOutput;
  violence?: ClassifierPornQueryClassifierOutput;
  vulgar?: ClassifierPornQueryClassifierOutput;
}

/**
 * QuerySats contains the information about the queries that users typed to
 * search for this image.
 */
export interface ClassifierPornQueryStats {
  /**
   * A query text porn score for the queries which have clicks to the image:
   * query_text_porn_score := sum(clicks(query) * text_porn_score(query)) /
   * sum(clicks(query))
   */
  queryTextPornScore?: number;
  totalClicks?: number;
}

/**
 * ReferrerCounts stores how many referrers an images has and how many of them
 * were classified as porn and as adult/softporn respectively. Note that a
 * referrer is usually a landing page, but as of March 2011 this also includes
 * referrers which an image can 'inherit' by propagating counts from near
 * duplicate images.
 */
export interface ClassifierPornReferrerCounts {
  adult?: number;
  /**
   * Number of referrers which are classified as porn and as adult.
   */
  porn?: number;
  /**
   * Total number of referrers.
   */
  total?: number;
}

/**
 * Next ID: 52
 */
export interface ClassifierPornSiteData {
  /**
   * The average pedo page score for the site.
   */
  avgPedoPageScore?: number;
  finalPedoSiteScore?: number;
  /**
   * The number of pages that were used to compute the scores and ratios.
   */
  numberOfPages?: bigint;
  /**
   * The number of pages with pedo restrict.
   */
  numberOfPedoPages?: bigint;
  /**
   * Sitechunk used to compute the signals. The field is present only for data
   * created after December 2022.
   */
  site?: string;
  /**
   * The ratio of porn/softporn of the site this page belongs to.
   */
  sitePornRatio?: number;
  siteSoftpornRatio?: number;
  versionedscore?: ClassifierPornSiteDataVersionedScore[];
  violenceStats?: ClassifierPornSiteViolenceStats;
}

function serializeClassifierPornSiteData(data: any): ClassifierPornSiteData {
  return {
    ...data,
    numberOfPages: data["numberOfPages"] !== undefined ? String(data["numberOfPages"]) : undefined,
    numberOfPedoPages: data["numberOfPedoPages"] !== undefined ? String(data["numberOfPedoPages"]) : undefined,
    violenceStats: data["violenceStats"] !== undefined ? serializeClassifierPornSiteViolenceStats(data["violenceStats"]) : undefined,
  };
}

function deserializeClassifierPornSiteData(data: any): ClassifierPornSiteData {
  return {
    ...data,
    numberOfPages: data["numberOfPages"] !== undefined ? BigInt(data["numberOfPages"]) : undefined,
    numberOfPedoPages: data["numberOfPedoPages"] !== undefined ? BigInt(data["numberOfPedoPages"]) : undefined,
    violenceStats: data["violenceStats"] !== undefined ? deserializeClassifierPornSiteViolenceStats(data["violenceStats"]) : undefined,
  };
}

/**
 * The site porn score of the site to which the page of interest belongs to.
 * Multiple versions are kept across large changes for some time. The Version-4
 * score is the average Universal Page Probability of all the site's pages, and
 * will come with populated verticals4_score and site_rule (if any rule fires)
 * fields. When using this score it is recommended to subscribe to the following
 * mailing list: g/safesearch-announce.
 */
export interface ClassifierPornSiteDataVersionedScore {
  score?: number;
  siteRule?:  | "HIGH_PORN_FRACTION_RULE" | "DEPRECATED_USER_GENERATED_CONTENT_RULE" | "DEPRECATED_SITES_WITH_IGNORED_SCORES_LIST"[];
  version?: number;
  /**
   * Please talk to safesearch@ before relying on any of these internal fields:
   */
  verticals4Score?: number;
}

/**
 * Next ID: 6
 */
export interface ClassifierPornSiteViolenceStats {
  meanFinalViolenceScore?: number;
  numberOfImages?: bigint;
  numberOfVideos?: bigint;
  videoViolenceScore?: number;
}

function serializeClassifierPornSiteViolenceStats(data: any): ClassifierPornSiteViolenceStats {
  return {
    ...data,
    numberOfImages: data["numberOfImages"] !== undefined ? String(data["numberOfImages"]) : undefined,
    numberOfVideos: data["numberOfVideos"] !== undefined ? String(data["numberOfVideos"]) : undefined,
  };
}

function deserializeClassifierPornSiteViolenceStats(data: any): ClassifierPornSiteViolenceStats {
  return {
    ...data,
    numberOfImages: data["numberOfImages"] !== undefined ? BigInt(data["numberOfImages"]) : undefined,
    numberOfVideos: data["numberOfVideos"] !== undefined ? BigInt(data["numberOfVideos"]) : undefined,
  };
}

/**
 * The basic message that contains a single decision output of go/deeptagger.
 */
export interface CommerceDatastoreDeepTag {
  /**
   * The confidence of the tag, encoded to 14 bits (range [0, 16383]). Due to
   * modeling details, a large number of tags become trustworthy with confidence
   * greater than 0.001, so two bytes of precision are required.
   */
  confidence?: number;
  /**
   * A Deep Tag enum in uint32 form.
   */
  tag?: number;
}

/**
 * Image-level deep tags: essentially equivalent to the proto above but
 * containing tags that are computed at the image level. These image signals are
 * maintained by the Visual Shopping team (visual-shopping@). *** If you do use
 * the signals, please add an entry in go/ShoppingImageAttributeClients to be
 * notified for model upgrade. *** We recommend our clients against using the
 * raw confidence value directly. Instead, the clients should use the library,
 * cs/ads/shopping/visual/deeptags/public/single_tag.h and
 * cs/ads/shopping/visual/deeptags/public/single_scored_tag.h to specify an
 * operating point in terms of precision or recall. See the following code
 * example:
 * http://google3/shopping/visual/explore_looks/looks_offline_pipeline.cc?l=268&rcl=304165166
 * *** `model_outputs` is a repeated field. Please check `version` to get the
 * model you desire to use, instead of indexing the model_outputs directly e.g.
 * model_outputs(0). We will remove the old versions in the future and this will
 * lead to incorrect model. *** Models: As of Q2 2020, we have two models
 * running within Shopping: model one only has the overlay tag, which we are
 * deprecating, and model two has the tags specified in
 * go/VisualShoppingImageAttributes.
 */
export interface CommerceDatastoreImageDeepTags {
  /**
   * The set of outputs for a series of model versions. The size of this field
   * should not extend beyond 4 at any time: two versions for slow-update track
   * dependencies, and two versions for fast-update track dependencies.
   */
  modelOutputs?: CommerceDatastoreImageDeepTagsModelOutput[];
}

export interface CommerceDatastoreImageDeepTagsModelOutput {
  backgroundType?: CommerceDatastoreDeepTag;
  collage?: CommerceDatastoreDeepTag;
  /**
   * We are looking to deploy a model for the Ads team to identify images with
   * bad cropping. The model will be for Ads only and we will not populate the
   * cropping field in CDS.
   */
  cropping?: CommerceDatastoreDeepTag;
  modelType?: CommerceDatastoreDeepTag;
  /**
   * Tag corresponds to the shopping non-family safe (nfs) image signal.
   */
  nfs?: CommerceDatastoreDeepTag;
  objectCount?: CommerceDatastoreDeepTag;
  /**
   * Tag corresponding to unwanted text overlay (watermarks, logos, promotional
   * elements, artifacts, etc).
   */
  overlay?: CommerceDatastoreDeepTag;
  selfie?: CommerceDatastoreDeepTag;
  /**
   * Tag corresponding to the text overlay classifier (watermarks, logos,
   * promotional elements, artifacts, etc).
   */
  textOverlay?: CommerceDatastoreDeepTag[];
  version?: number;
}

/**
 * Protocol record used for collecting together all information about a
 * document. Please consult go/dj-explorer for two basic questions about
 * `CompositeDoc`: - Where should I look up certain information (e.g: pagerank,
 * language)? - What does each field in CompositeDoc mean and who should I
 * contact if I have questions? To add a new field into CompositeDoc, or change
 * existing field's size significantly, please file a ticket at go/dj-new-field,
 * fill in necessary information and get approved by docjoin-access@ team. Next
 * id: 191
 */
export interface CompositeDoc {
  /**
   * Contains necessary information to enforce row level Docjoin access
   * control.
   */
  accessRequirements?: IndexingPrivacyAccessAccessRequirements;
  additionalchecksums?: CompositeDocAdditionalChecksums;
  alternatename?: CompositeDocAlternateName[];
  anchors?: Anchors;
  anchorStats?: IndexingDocjoinerAnchorStatistics;
  /**
   * This field is present iff the page has a bad SSL certificate itself or in
   * its redirect chain.
   */
  badSslCertificate?: IndexingBadSSLCertificate;
  /**
   * Visible content checksum as computed by
   * repository::parsehandler::checksum::Checksum96bitsParseHandler. The value
   * is a Fprint96 in "key format" (i.e., by Fprint96::AsKey()).
   */
  ContentChecksum96?: Uint8Array;
  cseId?: QualityProseCSEUrlInfo[];
  /**
   * URL should only be selected for CSE Index if it's pagerank is higher than
   * cse_pagerank_cutoff.
   */
  csePagerankCutoff?: number;
  /**
   * Contains the tracking version of various data fields in CompositeDoc.
   */
  dataVersion?: IndexingDocjoinerDataVersion;
  doc?: GDocumentBase;
  /**
   * A generic container to hold document annotations and signals. For a full
   * list of extensions live today, see go/wde.
   */
  docAttachments?: Proto2BridgeMessageSet;
  /**
   * Info about "selected" images associated with the document for which we
   * (already) have ImageData. For each image URL, some fixed number of
   * documents are selected as web referrers for the image URL, and within those
   * selected documents, we say the image is "selected". Within the remaining
   * documents, we say the image is "rejected". Note that this distinction is
   * slightly different from selected for indexing. Only images within
   * doc_images where is_indexed_by_imagesearch is true will be selected for
   * indexing. You can find the rejected images at
   * composite_doc.doc_attachments().get(). You can find images that are
   * selected, but for which we have no ImageData (yet) at
   * composite_doc.image_indexing_info().selected_not_indexed_image_link()
   */
  docImages?: ImageData[];
  /**
   * This message set is used for data pushed into the index using the signals
   * framework that is never to be used in Mustang or TG Continuum
   * scoring/snippeting code. Any protocol buffer stored in this message set is
   * automatically returned in a docinfo response - it ends up in the "info"
   * message set in the WWWSnippetResponse, so it can be used in post-doc
   * twiddlers and for display in GWS with no code changes in Mustang or
   * Teragoogle.
   */
  docinfoPassthroughAttachments?: Proto2BridgeMessageSet;
  /**
   * Info about videos embedded in the document.
   */
  docVideos?: ImageRepositoryVideoProperties[];
  /**
   * Data produced by the embedded-content system. This is a thin message,
   * containing only embedded_links_info data for the embedder and
   * JavaScript/CSS embedded links (the embedded-content bigtable also contains
   * snapshots, compressed document trees and all embedded link types). Provided
   * using the index signal API.
   */
  embeddedContentInfo?: IndexingEmbeddedContentEmbeddedContentInfo;
  extradup?: CompositeDocExtraDup[];
  forwardingdup?: CompositeDocForwardingDup[];
  includedcontent?: CompositeDocIncludedContent[];
  indexinginfo?: CompositeDocIndexingInfo;
  /**
   * Serialized indexing intermediate data.
   */
  indexingIntermediate?: Uint8Array;
  /**
   * This field associates a document to particular labels and assigns
   * confidence values to them.
   */
  labelData?: QualityLabelsGoogleLabelData;
  liveexperimentinfo?: CompositeDocLiveExperimentInfo;
  localinfo?: LocalWWWInfo;
  /**
   * Localized alternate names are similar to alternate names, except that it
   * is associated with a language different from its canonical. This is the
   * subset of webmaster-provided localized alternate names being in the dup
   * cluster of this document. Used during serving for swapping in the URL based
   * on regional and language preferences of the user.
   */
  localizedAlternateName?: IndexingConverterLocalizedAlternateName[];
  localizedvariations?: CompositeDocLocalizedVariations;
  /**
   * Only present in partial cdocs.
   */
  partialUpdateInfo?: CompositeDocPartialUpdateInfo;
  perDocData?: PerDocData;
  /**
   * Porn related data used for image and web search porn classification as
   * well as for diagnostics purposes.
   */
  porninfo?: ClassifierPornDocumentData;
  properties?: DocProperties;
  /**
   * Contains information necessary to perform policy decision on the usage of
   * the data assosiated with this cdoc.
   */
  ptoken?: PtokenPToken;
  qualitysignals?: CompositeDocQualitySignals;
  /**
   * Information about the most recent creation and expiration of this domain.
   * It's extracted from domainedge signal.
   */
  registrationinfo?: RegistrationInfo;
  /**
   * If present, indicates that some content was inserted, deleted, or replaced
   * in the document's content (in CompositeDoc::doc::Content::Representation),
   * and stores information about what was inserted, deleted, or replaced.
   */
  richcontentData?: IndexingConverterRichContentData;
  /**
   * rich snippet extracted from the content of a document.
   */
  richsnippet?: RichsnippetsPageMap;
  robotsinfolist?: CompositeDocRobotsInfoList;
  /**
   * to copy to per-doc
   */
  scaledIndyRank?: number;
  /**
   * Sitelinks: a collection of interesting links a user might be interested
   * in, given they are interested in this document. WARNING: this is different
   * from the crawler Sitemaps (see SitemapsSignals in the attachments).
   */
  sitemap?: Sitemap;
  /**
   * Row timestamp in CDoc storage.
   */
  storageRowTimestampMicros?: bigint;
  subindexid?:  | "LTG_CANDIDATE" | "NOSUBINDEX" | "BASE" | "CSEINDEX_EXTENDED" | "DAILY" | "TIMBIT_PROTECTED" | "LANDFILL1" | "LANDFILL2" | "LANDFILL3" | "LANDFILL_BLOGSEARCH" | "LANDFILL_SOCIAL" | "INSTANT" | "UNIFIED_LANDFILL" | "BLOGSEARCH_DYNAMIC_ASSIMILATED" | "BLOGSEARCH_EXTENDED" | "MOFFETT" | "UNSELECTED_DOCUMENTS" | "AQUARIUS" | "WEBSEARCH_FRESH" | "WEBSEARCH1" | "WEBSEARCH2" | "WEBSEARCH3" | "UNIFIED_ZEPPELIN_HIGH_QUALITY" | "ASIANREGIONAL" | "EMEAREGIONAL" | "CSEINDEX" | "BASEREGIONAL" | "BLACKHOLE" | "XBASE" | "FRESHBASE" | "XASIANREGIONAL" | "XEMEAREGIONAL" | "XBASEREGIONAL" | "BLIMPIE" | "BLIMPIEPP" | "GOODYEAR" | "GOODYEARPP" | "QUASAR" | "ZEPPELIN1" | "ZEPPELIN2" | "ZEPPELIN3" | "ZEPPELIN_STAGING" | "PULSAR" | "TIMBIT" | "LANDFILL_CSE" | "UNIFIED_ZEPPELIN"[];
  syntacticDate?: QualityTimebasedSyntacticDate;
  /**
   * WARNING!!! "url" field in CompositeDoc is optional, and is usually
   * missing: e.g., Docjoin CompositeDoc's don't have CompositeDoc::url.
   * has_url() checking is often useful. So don't rely on CompositeDoc::url
   * unless you're sure otherwise. Usually you want to use
   * CompositeDoc::doc::url instead.
   */
  url?: string;
  /**
   * Date in the url extracted by quality/snippets/urldate/date-in-url.cc This
   * is given as midnight GMT on the date in question.
   */
  urldate?: bigint;
}

function serializeCompositeDoc(data: any): CompositeDoc {
  return {
    ...data,
    additionalchecksums: data["additionalchecksums"] !== undefined ? serializeCompositeDocAdditionalChecksums(data["additionalchecksums"]) : undefined,
    alternatename: data["alternatename"] !== undefined ? data["alternatename"].map((item: any) => (serializeCompositeDocAlternateName(item))) : undefined,
    anchors: data["anchors"] !== undefined ? serializeAnchors(data["anchors"]) : undefined,
    anchorStats: data["anchorStats"] !== undefined ? serializeIndexingDocjoinerAnchorStatistics(data["anchorStats"]) : undefined,
    badSslCertificate: data["badSslCertificate"] !== undefined ? serializeIndexingBadSSLCertificate(data["badSslCertificate"]) : undefined,
    ContentChecksum96: data["ContentChecksum96"] !== undefined ? encodeBase64(data["ContentChecksum96"]) : undefined,
    dataVersion: data["dataVersion"] !== undefined ? serializeIndexingDocjoinerDataVersion(data["dataVersion"]) : undefined,
    doc: data["doc"] !== undefined ? serializeGDocumentBase(data["doc"]) : undefined,
    docImages: data["docImages"] !== undefined ? data["docImages"].map((item: any) => (serializeImageData(item))) : undefined,
    docVideos: data["docVideos"] !== undefined ? data["docVideos"].map((item: any) => (serializeImageRepositoryVideoProperties(item))) : undefined,
    embeddedContentInfo: data["embeddedContentInfo"] !== undefined ? serializeIndexingEmbeddedContentEmbeddedContentInfo(data["embeddedContentInfo"]) : undefined,
    extradup: data["extradup"] !== undefined ? data["extradup"].map((item: any) => (serializeCompositeDocExtraDup(item))) : undefined,
    forwardingdup: data["forwardingdup"] !== undefined ? data["forwardingdup"].map((item: any) => (serializeCompositeDocForwardingDup(item))) : undefined,
    includedcontent: data["includedcontent"] !== undefined ? data["includedcontent"].map((item: any) => (serializeCompositeDocIncludedContent(item))) : undefined,
    indexinginfo: data["indexinginfo"] !== undefined ? serializeCompositeDocIndexingInfo(data["indexinginfo"]) : undefined,
    indexingIntermediate: data["indexingIntermediate"] !== undefined ? encodeBase64(data["indexingIntermediate"]) : undefined,
    labelData: data["labelData"] !== undefined ? serializeQualityLabelsGoogleLabelData(data["labelData"]) : undefined,
    liveexperimentinfo: data["liveexperimentinfo"] !== undefined ? serializeCompositeDocLiveExperimentInfo(data["liveexperimentinfo"]) : undefined,
    localinfo: data["localinfo"] !== undefined ? serializeLocalWWWInfo(data["localinfo"]) : undefined,
    localizedAlternateName: data["localizedAlternateName"] !== undefined ? data["localizedAlternateName"].map((item: any) => (serializeIndexingConverterLocalizedAlternateName(item))) : undefined,
    localizedvariations: data["localizedvariations"] !== undefined ? serializeCompositeDocLocalizedVariations(data["localizedvariations"]) : undefined,
    partialUpdateInfo: data["partialUpdateInfo"] !== undefined ? serializeCompositeDocPartialUpdateInfo(data["partialUpdateInfo"]) : undefined,
    perDocData: data["perDocData"] !== undefined ? serializePerDocData(data["perDocData"]) : undefined,
    porninfo: data["porninfo"] !== undefined ? serializeClassifierPornDocumentData(data["porninfo"]) : undefined,
    properties: data["properties"] !== undefined ? serializeDocProperties(data["properties"]) : undefined,
    qualitysignals: data["qualitysignals"] !== undefined ? serializeCompositeDocQualitySignals(data["qualitysignals"]) : undefined,
    richcontentData: data["richcontentData"] !== undefined ? serializeIndexingConverterRichContentData(data["richcontentData"]) : undefined,
    richsnippet: data["richsnippet"] !== undefined ? serializeRichsnippetsPageMap(data["richsnippet"]) : undefined,
    robotsinfolist: data["robotsinfolist"] !== undefined ? serializeCompositeDocRobotsInfoList(data["robotsinfolist"]) : undefined,
    sitemap: data["sitemap"] !== undefined ? serializeSitemap(data["sitemap"]) : undefined,
    storageRowTimestampMicros: data["storageRowTimestampMicros"] !== undefined ? String(data["storageRowTimestampMicros"]) : undefined,
    syntacticDate: data["syntacticDate"] !== undefined ? serializeQualityTimebasedSyntacticDate(data["syntacticDate"]) : undefined,
    urldate: data["urldate"] !== undefined ? String(data["urldate"]) : undefined,
  };
}

function deserializeCompositeDoc(data: any): CompositeDoc {
  return {
    ...data,
    additionalchecksums: data["additionalchecksums"] !== undefined ? deserializeCompositeDocAdditionalChecksums(data["additionalchecksums"]) : undefined,
    alternatename: data["alternatename"] !== undefined ? data["alternatename"].map((item: any) => (deserializeCompositeDocAlternateName(item))) : undefined,
    anchors: data["anchors"] !== undefined ? deserializeAnchors(data["anchors"]) : undefined,
    anchorStats: data["anchorStats"] !== undefined ? deserializeIndexingDocjoinerAnchorStatistics(data["anchorStats"]) : undefined,
    badSslCertificate: data["badSslCertificate"] !== undefined ? deserializeIndexingBadSSLCertificate(data["badSslCertificate"]) : undefined,
    ContentChecksum96: data["ContentChecksum96"] !== undefined ? decodeBase64(data["ContentChecksum96"] as string) : undefined,
    dataVersion: data["dataVersion"] !== undefined ? deserializeIndexingDocjoinerDataVersion(data["dataVersion"]) : undefined,
    doc: data["doc"] !== undefined ? deserializeGDocumentBase(data["doc"]) : undefined,
    docImages: data["docImages"] !== undefined ? data["docImages"].map((item: any) => (deserializeImageData(item))) : undefined,
    docVideos: data["docVideos"] !== undefined ? data["docVideos"].map((item: any) => (deserializeImageRepositoryVideoProperties(item))) : undefined,
    embeddedContentInfo: data["embeddedContentInfo"] !== undefined ? deserializeIndexingEmbeddedContentEmbeddedContentInfo(data["embeddedContentInfo"]) : undefined,
    extradup: data["extradup"] !== undefined ? data["extradup"].map((item: any) => (deserializeCompositeDocExtraDup(item))) : undefined,
    forwardingdup: data["forwardingdup"] !== undefined ? data["forwardingdup"].map((item: any) => (deserializeCompositeDocForwardingDup(item))) : undefined,
    includedcontent: data["includedcontent"] !== undefined ? data["includedcontent"].map((item: any) => (deserializeCompositeDocIncludedContent(item))) : undefined,
    indexinginfo: data["indexinginfo"] !== undefined ? deserializeCompositeDocIndexingInfo(data["indexinginfo"]) : undefined,
    indexingIntermediate: data["indexingIntermediate"] !== undefined ? decodeBase64(data["indexingIntermediate"] as string) : undefined,
    labelData: data["labelData"] !== undefined ? deserializeQualityLabelsGoogleLabelData(data["labelData"]) : undefined,
    liveexperimentinfo: data["liveexperimentinfo"] !== undefined ? deserializeCompositeDocLiveExperimentInfo(data["liveexperimentinfo"]) : undefined,
    localinfo: data["localinfo"] !== undefined ? deserializeLocalWWWInfo(data["localinfo"]) : undefined,
    localizedAlternateName: data["localizedAlternateName"] !== undefined ? data["localizedAlternateName"].map((item: any) => (deserializeIndexingConverterLocalizedAlternateName(item))) : undefined,
    localizedvariations: data["localizedvariations"] !== undefined ? deserializeCompositeDocLocalizedVariations(data["localizedvariations"]) : undefined,
    partialUpdateInfo: data["partialUpdateInfo"] !== undefined ? deserializeCompositeDocPartialUpdateInfo(data["partialUpdateInfo"]) : undefined,
    perDocData: data["perDocData"] !== undefined ? deserializePerDocData(data["perDocData"]) : undefined,
    porninfo: data["porninfo"] !== undefined ? deserializeClassifierPornDocumentData(data["porninfo"]) : undefined,
    properties: data["properties"] !== undefined ? deserializeDocProperties(data["properties"]) : undefined,
    qualitysignals: data["qualitysignals"] !== undefined ? deserializeCompositeDocQualitySignals(data["qualitysignals"]) : undefined,
    richcontentData: data["richcontentData"] !== undefined ? deserializeIndexingConverterRichContentData(data["richcontentData"]) : undefined,
    richsnippet: data["richsnippet"] !== undefined ? deserializeRichsnippetsPageMap(data["richsnippet"]) : undefined,
    robotsinfolist: data["robotsinfolist"] !== undefined ? deserializeCompositeDocRobotsInfoList(data["robotsinfolist"]) : undefined,
    sitemap: data["sitemap"] !== undefined ? deserializeSitemap(data["sitemap"]) : undefined,
    storageRowTimestampMicros: data["storageRowTimestampMicros"] !== undefined ? BigInt(data["storageRowTimestampMicros"]) : undefined,
    syntacticDate: data["syntacticDate"] !== undefined ? deserializeQualityTimebasedSyntacticDate(data["syntacticDate"]) : undefined,
    urldate: data["urldate"] !== undefined ? BigInt(data["urldate"]) : undefined,
  };
}

/**
 * Additional checksums of the document.
 */
export interface CompositeDocAdditionalChecksums {
  /**
   * Same as ContentChecksum96 but without transient boilerplate.
   */
  NoTransientChecksum96?: Uint8Array;
  /**
   * Deprecated. Use simhash_v2 and simhash_v2_significance instead.
   */
  SimHash?: bigint;
  SimHashIsTrusted?: boolean;
  /**
   * Simhash-v2 is generated by SimHashParseHandler, designed as a complete
   * replacement of simhash-v1 (a.k.a. the original simhash above) from
   * ApproxDupsParseHandler. Simhash-v2 uses a revised algorithm so that it is
   * expected to work better in most cases than simhash-v1. They coexist in
   * current transition period, then simhash-v1 will be retired.
   */
  simhashV2?: bigint;
  /**
   * Simhash-v2-significance is used to describe the confidence about the
   * corresponding simhash-v2 value. It is defined as the average absolute
   * difference from zero of all internal state components when finalizing a
   * simhash-v2 value in HashMultiSetDotCauchy. We used to compare the
   * significance against some pre-defined threshold (default: 20) to get a
   * boolean value "trusted_simhash_v2". However, it is possible that this field
   * is missing while "simhash_v2" is present, in such case (1) Use
   * "SimHashIsTrusted" instead if it is present, AND/OR (2) Assume "simhash_v2"
   * is trusted if its value is non-zero.
   */
  simhashV2Significance?: number;
}

function serializeCompositeDocAdditionalChecksums(data: any): CompositeDocAdditionalChecksums {
  return {
    ...data,
    NoTransientChecksum96: data["NoTransientChecksum96"] !== undefined ? encodeBase64(data["NoTransientChecksum96"]) : undefined,
    SimHash: data["SimHash"] !== undefined ? String(data["SimHash"]) : undefined,
    simhashV2: data["simhashV2"] !== undefined ? String(data["simhashV2"]) : undefined,
  };
}

function deserializeCompositeDocAdditionalChecksums(data: any): CompositeDocAdditionalChecksums {
  return {
    ...data,
    NoTransientChecksum96: data["NoTransientChecksum96"] !== undefined ? decodeBase64(data["NoTransientChecksum96"] as string) : undefined,
    SimHash: data["SimHash"] !== undefined ? BigInt(data["SimHash"]) : undefined,
    simhashV2: data["simhashV2"] !== undefined ? BigInt(data["simhashV2"]) : undefined,
  };
}

/**
 * Alternate names are some urls that we would like to associate with documents
 * in addition to canonicals. Sometimes we may want to serve these
 * alternatenames instead of canonicals. Alternames in CompositeDoc should come
 * from WebMirror pipeline.
 */
export interface CompositeDocAlternateName {
  /**
   * Fp96 of webmirror equivalence class as of last time this was exported.
   */
  ecnFp?: Uint8Array;
  Url?: string;
  /**
   * See webutil/urlencoding
   */
  UrlEncoding?: number;
}

function serializeCompositeDocAlternateName(data: any): CompositeDocAlternateName {
  return {
    ...data,
    ecnFp: data["ecnFp"] !== undefined ? encodeBase64(data["ecnFp"]) : undefined,
  };
}

function deserializeCompositeDocAlternateName(data: any): CompositeDocAlternateName {
  return {
    ...data,
    ecnFp: data["ecnFp"] !== undefined ? decodeBase64(data["ecnFp"] as string) : undefined,
  };
}

/**
 * The top non-forwarding dups of the canonical url.
 */
export interface CompositeDocExtraDup {
  /**
   * Fp96 of webmirror equivalence class as of last time this was exported.
   */
  ecnFp?: Uint8Array;
  /**
   * The url of the non-forwarding dup.
   */
  url?: string;
}

function serializeCompositeDocExtraDup(data: any): CompositeDocExtraDup {
  return {
    ...data,
    ecnFp: data["ecnFp"] !== undefined ? encodeBase64(data["ecnFp"]) : undefined,
  };
}

function deserializeCompositeDocExtraDup(data: any): CompositeDocExtraDup {
  return {
    ...data,
    ecnFp: data["ecnFp"] !== undefined ? decodeBase64(data["ecnFp"] as string) : undefined,
  };
}

/**
 * The top forwarding dups of the canonical url. (note: it may actually include
 * some dups that are NOT used for forwarding data but for making "info:"
 * complete)
 */
export interface CompositeDocForwardingDup {
  /**
   * The name of the url's webmirror equivalence class.
   */
  ecn?: Uint8Array;
  ecnFp?: Uint8Array;
  /**
   * The purpose(s) of the forwarding dup indicating if it is used for
   * forwarding signal/anchors generally, or only for forwarding some specific
   * signal (e.g. navboost), or for some other purposes (e.g., not for
   * forwarding any data but for making "info:" complete). See
   * indexing/dups/public/dups.h for more details.
   */
  purposes?: number;
  /**
   * Raw pagerank of the url.
   */
  rawPagerank?: number;
  /**
   * The webmirror repid of the forwarding dup.
   */
  repid?: Uint8Array;
  /**
   * The url of the forwarding dup.
   */
  url?: string;
  /**
   * The encoding of the url (see webutil/urlencoding for details).
   */
  urlencoding?: number;
}

function serializeCompositeDocForwardingDup(data: any): CompositeDocForwardingDup {
  return {
    ...data,
    ecn: data["ecn"] !== undefined ? encodeBase64(data["ecn"]) : undefined,
    ecnFp: data["ecnFp"] !== undefined ? encodeBase64(data["ecnFp"]) : undefined,
    repid: data["repid"] !== undefined ? encodeBase64(data["repid"]) : undefined,
  };
}

function deserializeCompositeDocForwardingDup(data: any): CompositeDocForwardingDup {
  return {
    ...data,
    ecn: data["ecn"] !== undefined ? decodeBase64(data["ecn"] as string) : undefined,
    ecnFp: data["ecnFp"] !== undefined ? decodeBase64(data["ecnFp"] as string) : undefined,
    repid: data["repid"] !== undefined ? decodeBase64(data["repid"] as string) : undefined,
  };
}

export interface CompositeDocIncludedContent {
  includedDoc?: GDocumentBase;
  linkUrl?: string;
  perDocData?: PerDocData;
  properties?: DocProperties;
  /**
   * Indicate how this content came to be included. Legal values are
   * constructed by bitwise-OR-ing values from the included_content::SourceType
   * enum. Default SourceTypeBitfield = included_content::INCLUDED_FRAME
   */
  SourceTypeBitfield?: bigint;
}

function serializeCompositeDocIncludedContent(data: any): CompositeDocIncludedContent {
  return {
    ...data,
    includedDoc: data["includedDoc"] !== undefined ? serializeGDocumentBase(data["includedDoc"]) : undefined,
    perDocData: data["perDocData"] !== undefined ? serializePerDocData(data["perDocData"]) : undefined,
    properties: data["properties"] !== undefined ? serializeDocProperties(data["properties"]) : undefined,
    SourceTypeBitfield: data["SourceTypeBitfield"] !== undefined ? String(data["SourceTypeBitfield"]) : undefined,
  };
}

function deserializeCompositeDocIncludedContent(data: any): CompositeDocIncludedContent {
  return {
    ...data,
    includedDoc: data["includedDoc"] !== undefined ? deserializeGDocumentBase(data["includedDoc"]) : undefined,
    perDocData: data["perDocData"] !== undefined ? deserializePerDocData(data["perDocData"]) : undefined,
    properties: data["properties"] !== undefined ? deserializeDocProperties(data["properties"]) : undefined,
    SourceTypeBitfield: data["SourceTypeBitfield"] !== undefined ? BigInt(data["SourceTypeBitfield"]) : undefined,
  };
}

/**
 * Contains information *mostly* used within indexing (e.g. not used for
 * building the production serving shards). Most of this data is generated only
 * in Alexandria, however there are exceptions.
 */
export interface CompositeDocIndexingInfo {
  /**
   * To hold extra info for building a final cdoc from raw cdoc and goldmine
   * annotations.
   */
  cdocBuildInfo?: IndexingDocjoinerCDocBuildInfo;
  /**
   * Whether current page is under content protection, i.e. a page has been
   * crawled as an error page, but we preserve its last known good content and
   * keep its crawl_status as converter.CrawlStatus::CONTENT.
   */
  contentProtected?: boolean;
  /**
   * If set, indicates that the crawl status was converted to ROBOTED for the
   * reason specified by the enum value in
   * converter.RobotedReasons.ConvertToRobotedReasons. See
   * indexing/converter/proto/converter.proto for details. If unset, then the
   * document was not converted to roboted, and if the document crawl status is
   * ROBOTED, then the document is disallowed (at least to Google) in
   * robots.txt.
   */
  convertToRobotedReason?: number;
  /**
   * One of the enum values in converter.CrawlStatus.State (see
   * indexing/converter/proto/converter.proto for details). Default is
   * converter.CrawlStatus::CONTENT. The document is roboted if the value is
   * converter.CrawlStatus::ROBOTED.
   */
  crawlStatus?: number;
  demotionTags?:  | "DEMOTION_TYPE_NONE" | "DEMOTION_TYPE_BADURLS_DEMOTE"[];
  /**
   * One of the enum values in converter.ErrorPageType (see
   * indexing/converter/proto/error-page-detector-enum.proto for detail).
   * Default is converter::ERROR_PAGE_NONE.
   */
  errorType?: number;
  freshdocsCorpora?:  | "WEB" | "REALTIME" | "CSE" | "CSE_PREMIUM" | "BUSTER_IMAGES" | "NEWS" | "VIDEO" | "YOUTUBE" | "WEB_INSTANT" | "WEB_DAILY" | "CACHE_COLON"[];
  /**
   * The host id of the document. Used chiefly to determine whether the
   * document is part of a parked domain.
   */
  hostid?: bigint;
  /**
   * A short descriptive string to help identify the IE application or setup
   * where this CDoc is generated. For example: websearch_m3 This field is for
   * debuggability purposes.
   */
  ieIdentifier?: string;
  /**
   * Indexing info about images (i.e. image links missing image data, etc).
   */
  imageIndexingInfo?: ImageSearchImageIndexingInfo;
  /**
   * The timestamp (the time since the Epoch, in microseconds) when the docjoin
   * is exported from indexing. The main purpose of this field is to identify
   * different versions of the same document.
   */
  indexingTs?: bigint;
  /**
   * Page is deleted when indexing choice flips between different corpora (e.g.
   * desktop, mobile, archive, scholar, etc.) for the same URL. It's only set
   * for deletion cdocs. Downstreams using URL as key should ignore the current
   * deletion if the field is set.
   */
  isSiblingDeletion?: boolean;
  /**
   * If set, the timestamp in microseconds when the URL stopped being
   * canonical. This should never be set for exported canonical documents. This
   * field is used by dups during canonical flip, and by webmain when doc
   * selection switched between desktop and mobile. Union respects this
   * timestamp to prevent old doc being deleted until the new doc is picked up
   */
  noLongerCanonicalTimestamp?: bigint;
  /**
   * This score is calculated by re-mapping the back onto the partition's score
   * distribution, such that the score represents the score of the equivalently
   * ranked organically-selected document.
   */
  normalizedClickScore?: number;
  /**
   * The raw navboost count for the canonical url without aggregating the
   * navboost from dup urls. This field is used when building forwarding map.
   */
  rawNavboost?: number;
  /**
   * The timestamp (the time since the Epoch, in microseconds) to represent doc
   * version, which is used in the downstream processing after Raffia. If it's
   * not set, indexing_ts will be used as row_timestamp. The timestamp is
   * generally set by reprocessing to set slightly newer indexing_ts such that
   * the system can respect the reprocessed version to overwrite old data in
   * storage.
   */
  rowTimestamp?: bigint;
  /**
   * Selection tier rank is a language normalized score ranging from 0-1 over
   * the serving tier (Base, Zeppelins, Landfills) for this document.
   */
  selectionTierRank?: number;
  /**
   * The tracing ids is to label the version of url for url status tracking.
   * This repeated field will carry at most 10 tracing id. See more details in
   * go/rich-tracing-design There will be less than 2% base+uz cdocs carrying
   * this field. The major sources of tracing ids include: * Indexing API pushed
   * urls * Index Metrics sampling urls The tracing ids will be written into
   * cdocs by Webmain Ramifier. The consumer of the tracing ids is Union serving
   * notification collector see more at go/serving-notification-from-union
   */
  tracingId?: string[];
  /**
   * Changerate information for this doc (see
   * crawler/changerate/changerate.proto for details).
   */
  urlChangerate?: CrawlerChangerateUrlChangerate;
  /**
   * Url change history for this doc (see crawler/changerate/changerate.proto
   * for details). Note if a doc has more than 20 changes, we only keep the last
   * 20 changes here to avoid adding to much data in its docjoin.
   */
  urlHistory?: CrawlerChangerateUrlHistory;
  /**
   * UrlPatternSignals for this doc, used to compute document score in LTG (see
   * indexing/signal_aggregator/proto/signal-aggregator.proto for details).
   */
  urlPatternSignals?: IndexingSignalAggregatorUrlPatternSignals;
  /**
   * Indexing info about videos.
   */
  videoIndexingInfo?: ImageRepositoryVideoIndexingInfo;
}

function serializeCompositeDocIndexingInfo(data: any): CompositeDocIndexingInfo {
  return {
    ...data,
    hostid: data["hostid"] !== undefined ? String(data["hostid"]) : undefined,
    indexingTs: data["indexingTs"] !== undefined ? String(data["indexingTs"]) : undefined,
    noLongerCanonicalTimestamp: data["noLongerCanonicalTimestamp"] !== undefined ? String(data["noLongerCanonicalTimestamp"]) : undefined,
    rowTimestamp: data["rowTimestamp"] !== undefined ? String(data["rowTimestamp"]) : undefined,
    urlHistory: data["urlHistory"] !== undefined ? serializeCrawlerChangerateUrlHistory(data["urlHistory"]) : undefined,
    urlPatternSignals: data["urlPatternSignals"] !== undefined ? serializeIndexingSignalAggregatorUrlPatternSignals(data["urlPatternSignals"]) : undefined,
  };
}

function deserializeCompositeDocIndexingInfo(data: any): CompositeDocIndexingInfo {
  return {
    ...data,
    hostid: data["hostid"] !== undefined ? BigInt(data["hostid"]) : undefined,
    indexingTs: data["indexingTs"] !== undefined ? BigInt(data["indexingTs"]) : undefined,
    noLongerCanonicalTimestamp: data["noLongerCanonicalTimestamp"] !== undefined ? BigInt(data["noLongerCanonicalTimestamp"]) : undefined,
    rowTimestamp: data["rowTimestamp"] !== undefined ? BigInt(data["rowTimestamp"]) : undefined,
    urlHistory: data["urlHistory"] !== undefined ? deserializeCrawlerChangerateUrlHistory(data["urlHistory"]) : undefined,
    urlPatternSignals: data["urlPatternSignals"] !== undefined ? deserializeIndexingSignalAggregatorUrlPatternSignals(data["urlPatternSignals"]) : undefined,
  };
}

/**
 * Contains information needed for end-to-end live experiments. For a cdoc
 * generated by production pipeline, it includes experiment IDs that have
 * selected current document. For a cdoc generated by experiment pipeline, it
 * includes current experiment ID.
 */
export interface CompositeDocLiveExperimentInfo {
  /**
   * List of necessary information for each live experiments.
   */
  perLiveExperimentInfo?: CompositeDocLiveExperimentInfoPerLiveExperimentInfo[];
}

function serializeCompositeDocLiveExperimentInfo(data: any): CompositeDocLiveExperimentInfo {
  return {
    ...data,
    perLiveExperimentInfo: data["perLiveExperimentInfo"] !== undefined ? data["perLiveExperimentInfo"].map((item: any) => (serializeCompositeDocLiveExperimentInfoPerLiveExperimentInfo(item))) : undefined,
  };
}

function deserializeCompositeDocLiveExperimentInfo(data: any): CompositeDocLiveExperimentInfo {
  return {
    ...data,
    perLiveExperimentInfo: data["perLiveExperimentInfo"] !== undefined ? data["perLiveExperimentInfo"].map((item: any) => (deserializeCompositeDocLiveExperimentInfoPerLiveExperimentInfo(item))) : undefined,
  };
}

/**
 * Contains information for a live experiment.
 */
export interface CompositeDocLiveExperimentInfoPerLiveExperimentInfo {
  /**
   * ID of a live experiment.
   */
  experimentId?: string;
  /**
   * Partial CDoc for a live experiment.
   */
  partialCdoc?: CompositeDoc;
}

function serializeCompositeDocLiveExperimentInfoPerLiveExperimentInfo(data: any): CompositeDocLiveExperimentInfoPerLiveExperimentInfo {
  return {
    ...data,
    partialCdoc: data["partialCdoc"] !== undefined ? serializeCompositeDoc(data["partialCdoc"]) : undefined,
  };
}

function deserializeCompositeDocLiveExperimentInfoPerLiveExperimentInfo(data: any): CompositeDocLiveExperimentInfoPerLiveExperimentInfo {
  return {
    ...data,
    partialCdoc: data["partialCdoc"] !== undefined ? deserializeCompositeDoc(data["partialCdoc"]) : undefined,
  };
}

export interface CompositeDocLocalizedVariations {
  /**
   * A subset of computed variations, only the members which are dups to the
   * main url. Used during serving for swapping in the URL based on regional and
   * language preferences of the user.
   */
  dupsComputedAlternateNames?: IndexingDupsComputedLocalizedAlternateNamesLocaleEntry[];
  /**
   * All localized alternate names provided by the webmaster (canonical and
   * dups, indexed and not-indexed). Used on the ranking side for swapping out
   * results based on the webmaster preference.
   */
  webmasterAlternateNames?: IndexingConverterLocalizedAlternateName[];
}

function serializeCompositeDocLocalizedVariations(data: any): CompositeDocLocalizedVariations {
  return {
    ...data,
    dupsComputedAlternateNames: data["dupsComputedAlternateNames"] !== undefined ? data["dupsComputedAlternateNames"].map((item: any) => (serializeIndexingDupsComputedLocalizedAlternateNamesLocaleEntry(item))) : undefined,
    webmasterAlternateNames: data["webmasterAlternateNames"] !== undefined ? data["webmasterAlternateNames"].map((item: any) => (serializeIndexingConverterLocalizedAlternateName(item))) : undefined,
  };
}

function deserializeCompositeDocLocalizedVariations(data: any): CompositeDocLocalizedVariations {
  return {
    ...data,
    dupsComputedAlternateNames: data["dupsComputedAlternateNames"] !== undefined ? data["dupsComputedAlternateNames"].map((item: any) => (deserializeIndexingDupsComputedLocalizedAlternateNamesLocaleEntry(item))) : undefined,
    webmasterAlternateNames: data["webmasterAlternateNames"] !== undefined ? data["webmasterAlternateNames"].map((item: any) => (deserializeIndexingConverterLocalizedAlternateName(item))) : undefined,
  };
}

/**
 * Contains information about the partial updates present in a partial
 * CompositeDoc.
 */
export interface CompositeDocPartialUpdateInfo {
  /**
   * List of goldmine annotator updates present in the enclosing partial cdoc.
   */
  goldmineAnnotatorNames?: string[];
  /**
   * List of images signal updates present in the enclosing partial cdoc.
   * Images signal name for a images signal is the unique name for the signal
   * according to SignalSpec.
   */
  imagesSignalNames?: string[];
  /**
   * Contains last full indexing information for partial updates.
   */
  lastFullIndexingInfo?: CompositeDocPartialUpdateInfoLastFullIndexingInfo[];
  /**
   * Which tier we should do cdoc lookup to merge partial cdocs. This uses the
   * integer value of indexing.selection.CorpusId. NOT intended for other usage.
   */
  shouldLookupDocjoinsTier?: number;
  /**
   * List of signal updates present in the enclosing partial cdoc. Signal name
   * for a signal is unique name for the signal according to SignalSpec.
   */
  signalNames?: string[];
}

function serializeCompositeDocPartialUpdateInfo(data: any): CompositeDocPartialUpdateInfo {
  return {
    ...data,
    lastFullIndexingInfo: data["lastFullIndexingInfo"] !== undefined ? data["lastFullIndexingInfo"].map((item: any) => (serializeCompositeDocPartialUpdateInfoLastFullIndexingInfo(item))) : undefined,
  };
}

function deserializeCompositeDocPartialUpdateInfo(data: any): CompositeDocPartialUpdateInfo {
  return {
    ...data,
    lastFullIndexingInfo: data["lastFullIndexingInfo"] !== undefined ? data["lastFullIndexingInfo"].map((item: any) => (deserializeCompositeDocPartialUpdateInfoLastFullIndexingInfo(item))) : undefined,
  };
}

/**
 * Last full indexing information for the partial CDoc.
 */
export interface CompositeDocPartialUpdateInfoLastFullIndexingInfo {
  /**
   * The corpus of last full updates.
   */
  corpus?:  | "RAFFIA_WEBSEARCH" | "RAFFIA_FASTPATH_DAILY" | "RAFFIA_FASTPATH_INSTANT";
  /**
   * Last full update indexing timestamp in microseconds.
   */
  lastFullIndexingTsMicros?: bigint;
}

function serializeCompositeDocPartialUpdateInfoLastFullIndexingInfo(data: any): CompositeDocPartialUpdateInfoLastFullIndexingInfo {
  return {
    ...data,
    lastFullIndexingTsMicros: data["lastFullIndexingTsMicros"] !== undefined ? String(data["lastFullIndexingTsMicros"]) : undefined,
  };
}

function deserializeCompositeDocPartialUpdateInfoLastFullIndexingInfo(data: any): CompositeDocPartialUpdateInfoLastFullIndexingInfo {
  return {
    ...data,
    lastFullIndexingTsMicros: data["lastFullIndexingTsMicros"] !== undefined ? BigInt(data["lastFullIndexingTsMicros"]) : undefined,
  };
}

/**
 * Note: This is a misleading name as of 2022/10/14. The field is still set and
 * has meaningful data, but no longer holds quality signals. All the data are
 * freshness-related and they're not particularly sensitive.
 */
export interface CompositeDocQualitySignals {
  /**
   * Contains a date used for the "Date Last Modified" toolbelt restrict mode.
   * Note: this date is a combined date and is different from the pure
   * shingle-based signal stored in contentage.last_significant_update field.
   */
  lastSignificantUpdate?: QualityTimebasedLastSignificantUpdate;
  pagetype?: QualityTimebasedPageType;
}

function serializeCompositeDocQualitySignals(data: any): CompositeDocQualitySignals {
  return {
    ...data,
    lastSignificantUpdate: data["lastSignificantUpdate"] !== undefined ? serializeQualityTimebasedLastSignificantUpdate(data["lastSignificantUpdate"]) : undefined,
  };
}

function deserializeCompositeDocQualitySignals(data: any): CompositeDocQualitySignals {
  return {
    ...data,
    lastSignificantUpdate: data["lastSignificantUpdate"] !== undefined ? deserializeQualityTimebasedLastSignificantUpdate(data["lastSignificantUpdate"]) : undefined,
  };
}

/**
 * List of robots info parsed for the user-agents other than the default used
 * to crawl this page.
 */
export interface CompositeDocRobotsInfoList {
  newsRobotsInfo?: IndexingConverterRobotsInfo;
}

function serializeCompositeDocRobotsInfoList(data: any): CompositeDocRobotsInfoList {
  return {
    ...data,
    newsRobotsInfo: data["newsRobotsInfo"] !== undefined ? serializeIndexingConverterRobotsInfo(data["newsRobotsInfo"]) : undefined,
  };
}

function deserializeCompositeDocRobotsInfoList(data: any): CompositeDocRobotsInfoList {
  return {
    ...data,
    newsRobotsInfo: data["newsRobotsInfo"] !== undefined ? deserializeIndexingConverterRobotsInfo(data["newsRobotsInfo"]) : undefined,
  };
}

/**
 * A message containing per doc signals that are compressed and included in
 * Mustang and TeraGoogle. For TeraGoogle, this message is included in
 * perdocdata which means it can be used in preliminary scoring. CAREFUL: For
 * TeraGoogle, this data resides in very limited serving memory (Flash storage)
 * for a huge number of documents. Next id: 42
 */
export interface CompressedQualitySignals {
  /**
   * anchor_mismatch_demotion: converted from QualityBoost.mismatched.boost.
   */
  anchorMismatchDemotion?: number;
  /**
   * authority promotion: converted from QualityBoost.authority.boost
   */
  authorityPromotion?: number;
  /**
   * baby_panda_demotion: converted from QualityBoost.rendered.boost.
   */
  babyPandaDemotion?: number;
  /**
   * New BabyPanda demotion, applied on top of Panda. This is meant to replace
   * |baby_panda_demotion|.
   */
  babyPandaV2Demotion?: number;
  /**
   * Impressions, unsquashed, host level, not to be used with compressed
   * ratios. Not to be used in Pattern Data.
   */
  crapsAbsoluteHostSignals?: number;
  crapsNewHostSignals?: bigint;
  crapsNewPatternSignals?: bigint;
  /**
   * For craps_[url|pattern]_signals, please avoid accessing these fields
   * directly, even in minor ways like checking has_craps_*. Instead, please use
   * methods from quality/navboost/craps/craps-lossy-compression.h or talk to
   * dice-team.
   */
  crapsNewUrlSignals?: bigint;
  crapsUnscaledIpPriorBadFraction?: number;
  /**
   * Page quality signals converted from fields in proto QualityBoost in
   * quality/q2/proto/quality-boost.proto. To save indexing space, we convert
   * the float values in [0, 1] to integers in range [0, 1023] (use 10 bits).
   * exact_match_domain_demotion: converted from QualityBoost.emd.boost.
   */
  exactMatchDomainDemotion?: number;
  /**
   * This field is *not* propagated to shards, but it's populated at serving
   * time by go/web-signal-joins (see b/207344056). See go/0DayLEs for details.
   * This is only meant to be used during LEs, it should *not* be used for
   * launches.
   */
  experimentalNsrTeamData?: QualityNsrExperimentalNsrTeamData;
  /**
   * This field is *not* propagated to shards, but it's populated at serving
   * time by go/web-signal-joins (see b/207344056). See go/0DayLEs for details.
   * This is only meant to be used during LEs, it should *not* be used for
   * launches.
   */
  experimentalNsrTeamWsjData?: QualityNsrExperimentalNsrTeamWSJData[];
  /**
   * This field is *not* propagated to shards. It is meant to be populated at
   * serving time using one of the versions present in the
   * `experimental_nsr_team_wsj_data` field above (using the
   * `ExperimentalNsrTeamDataOverridesParams` opti to populate it; see
   * http://source/search?q=ExperimentalNsrTeamDataOverridesParams%20file:ascorer.proto).
   * The purpose of this field is to be read by an experimental Q* component, in
   * order to quickly run LEs with new delta components. See go/0DayLEs for
   * details.
   */
  experimentalQstarDeltaSignal?: number;
  /**
   * This field is *not* propagated to shards. It is meant to be populated at
   * serving time using one of the versions present in the
   * `experimental_nsr_team_wsj_data` field above (using the
   * `ExperimentalNsrTeamDataOverridesParams` opti to populate it; see
   * http://source/search?q=ExperimentalNsrTeamDataOverridesParams%20file:ascorer.proto).
   * The purpose of this field is to be read by an experimental Q* component, in
   * order to quickly run LEs with new components. See go/0DayLEs for details.
   */
  experimentalQstarSignal?: number;
  /**
   * This field is *not* propagated to shards. It is meant to be populated at
   * serving time using one of the versions present in the
   * `experimental_nsr_team_wsj_data` field above (using the
   * `ExperimentalNsrTeamDataOverridesParams` opti to populate it; see
   * http://source/search?q=ExperimentalNsrTeamDataOverridesParams%20file:ascorer.proto).
   * The purpose of this field is to be read by an experimental Q* component, in
   * order to quickly run LEs with new site components. See go/0DayLEs for
   * details.
   */
  experimentalQstarSiteSignal?: number;
  /**
   * S2V low quality score: converted from quality_nsr.NsrData, applied in
   * Qstar. See quality_nsr::util::ConvertNsrDataToLowQuality.
   */
  lowQuality?: number;
  /**
   * nav_demotion: converted from QualityBoost.nav_demoted.boost.
   */
  navDemotion?: number;
  /**
   * NSR confidence score: converted from quality_nsr.NsrData.
   */
  nsrConfidence?: number;
  /**
   * NSR override bid, used in Q* for emergency overrides.
   */
  nsrOverrideBid?: number;
  /**
   * Versioned NSR score to be used in continuous evaluation of the upcoming
   * NSR version and assess quality impact on various slices.
   */
  nsrVersionedData?: NSRVersionedItem[];
  /**
   * PairwiseQ data for QTJ. This field is *not* propagated to shards, but is
   * populated at serving time by go/web-signal-joins. See b/175762140
   */
  pairwiseqScoringData?: PairwiseQScoringData;
  /**
   * Versioned PairwiseQ score to be used in continuous evaluation of the
   * upcoming PairwiseQ versions and assess quality impact on various slices.
   */
  pairwiseqVersionedData?: PairwiseQVersionedItem[];
  /**
   * This is the encoding of Panda fields in the proto SiteQualityFeatures in
   * quality/q2/proto/site_quality_features.proto. The encoding/decoding is
   * performed using functions from quality_coati::coati_util.
   */
  pandaDemotion?: number;
  /**
   * Encoded page-level PQ signals.
   */
  pqData?: number;
  /**
   * Stripped page-level signals, not present in the encoded field 'pq_data'.
   */
  pqDataProto?: QualityNsrPQData;
  productReviewPDemotePage?: number;
  /**
   * Product review demotion/promotion confidences. (Times 1000 and floored)
   */
  productReviewPDemoteSite?: number;
  productReviewPPromotePage?: number;
  productReviewPPromoteSite?: number;
  /**
   * Fields product_review_p_review_page and product_review_p_uhq_page are for
   * promoting/demoting HQ/LQ review pages in NGS. See go/pr-boosts for details.
   * The possibility of a page being a review page.
   */
  productReviewPReviewPage?: number;
  /**
   * The possibility of a page being a high quality review page.
   */
  productReviewPUhqPage?: number;
  /**
   * Scam model score. Used as one of the web page quality qstar signals. Value
   * range from 0 to 1023.
   */
  scamness?: number;
  /**
   * serp demotion: applied in Qstar.
   */
  serpDemotion?: number;
  /**
   * site_authority: converted from quality_nsr.SiteAuthority, applied in
   * Qstar.
   */
  siteAuthority?: number;
  /**
   * Versioned TopicEmbeddings data to be populated later into superroot / used
   * directly in scorers.
   */
  topicEmbeddingsVersionedData?: QualityAuthorityTopicEmbeddingsVersionedItem[];
  /**
   * Unauthoritative score. Used as one of the web page quality qstar signals.
   */
  unauthoritativeScore?: number;
  /**
   * NSR for low-quality videos, converted from quality_nsr.NsrData.vlq_nsr.
   */
  vlqNsr?: number;
}

function serializeCompressedQualitySignals(data: any): CompressedQualitySignals {
  return {
    ...data,
    crapsNewHostSignals: data["crapsNewHostSignals"] !== undefined ? String(data["crapsNewHostSignals"]) : undefined,
    crapsNewPatternSignals: data["crapsNewPatternSignals"] !== undefined ? String(data["crapsNewPatternSignals"]) : undefined,
    crapsNewUrlSignals: data["crapsNewUrlSignals"] !== undefined ? String(data["crapsNewUrlSignals"]) : undefined,
    topicEmbeddingsVersionedData: data["topicEmbeddingsVersionedData"] !== undefined ? data["topicEmbeddingsVersionedData"].map((item: any) => (serializeQualityAuthorityTopicEmbeddingsVersionedItem(item))) : undefined,
  };
}

function deserializeCompressedQualitySignals(data: any): CompressedQualitySignals {
  return {
    ...data,
    crapsNewHostSignals: data["crapsNewHostSignals"] !== undefined ? BigInt(data["crapsNewHostSignals"]) : undefined,
    crapsNewPatternSignals: data["crapsNewPatternSignals"] !== undefined ? BigInt(data["crapsNewPatternSignals"]) : undefined,
    crapsNewUrlSignals: data["crapsNewUrlSignals"] !== undefined ? BigInt(data["crapsNewUrlSignals"]) : undefined,
    topicEmbeddingsVersionedData: data["topicEmbeddingsVersionedData"] !== undefined ? data["topicEmbeddingsVersionedData"].map((item: any) => (deserializeQualityAuthorityTopicEmbeddingsVersionedItem(item))) : undefined,
  };
}

/**
 * The following protobuf is used to store an attribution from one page to
 * (usually) one other page, giving credit for the content. This information is
 * used during ranking to promote the attributed page. This protobuf is copied
 * from a quality_contra::SelectedAttribution. See
 * //quality/contra/authorship/attribution and
 * https://qwiki.corp.google.com/display/Q/ContentTrackingContentAttribution.
 */
export interface ContentAttributions {
  /**
   * Selected outgoing attributions extracted on FreshDocs.
   */
  freshdocsOutgoing?: ContentAttributionsOutgoingAttribution[];
  /**
   * Selected outgoing attributions extracted via offline MR jobs.
   */
  offlineOutgoing?: ContentAttributionsOutgoingAttribution[];
  /**
   * Selected outgoing attributions extracted online on Alexandria.
   */
  onlineOutgoing?: ContentAttributionsOutgoingAttribution[];
}

function serializeContentAttributions(data: any): ContentAttributions {
  return {
    ...data,
    freshdocsOutgoing: data["freshdocsOutgoing"] !== undefined ? data["freshdocsOutgoing"].map((item: any) => (serializeContentAttributionsOutgoingAttribution(item))) : undefined,
    offlineOutgoing: data["offlineOutgoing"] !== undefined ? data["offlineOutgoing"].map((item: any) => (serializeContentAttributionsOutgoingAttribution(item))) : undefined,
    onlineOutgoing: data["onlineOutgoing"] !== undefined ? data["onlineOutgoing"].map((item: any) => (serializeContentAttributionsOutgoingAttribution(item))) : undefined,
  };
}

function deserializeContentAttributions(data: any): ContentAttributions {
  return {
    ...data,
    freshdocsOutgoing: data["freshdocsOutgoing"] !== undefined ? data["freshdocsOutgoing"].map((item: any) => (deserializeContentAttributionsOutgoingAttribution(item))) : undefined,
    offlineOutgoing: data["offlineOutgoing"] !== undefined ? data["offlineOutgoing"].map((item: any) => (deserializeContentAttributionsOutgoingAttribution(item))) : undefined,
    onlineOutgoing: data["onlineOutgoing"] !== undefined ? data["onlineOutgoing"].map((item: any) => (deserializeContentAttributionsOutgoingAttribution(item))) : undefined,
  };
}

/**
 * This is a copy of quality_contra::SelectedAttribution::SelectedInfo. The url
 * is converted to docid and other fields are copied directly.
 */
export interface ContentAttributionsOutgoingAttribution {
  bestEvidenceType?:  | "PAGE_LINK_TO" | "SITE_LINK_TO" | "SITE_OTHER_PAGE_LINK_TO" | "ORG_OTHER_SITE_LINK_TO" | "ORG_OTHER_PAGE_LINK_TO" | "SITE_SCORE_BASED" | "LOW_CONFIDENCE_LINK_TO" | "ANCHOR_ATTRIBUTION_TO" | "SITE_NAME_MENTION" | "SITE_NAME_MENTION_KEYWORDED" | "EVIDENCE_TYPE_END";
  docid?: bigint;
  properties?: number;
  usableForClustering?: boolean;
}

function serializeContentAttributionsOutgoingAttribution(data: any): ContentAttributionsOutgoingAttribution {
  return {
    ...data,
    docid: data["docid"] !== undefined ? String(data["docid"]) : undefined,
  };
}

function deserializeContentAttributionsOutgoingAttribution(data: any): ContentAttributionsOutgoingAttribution {
  return {
    ...data,
    docid: data["docid"] !== undefined ? BigInt(data["docid"]) : undefined,
  };
}

export interface ContentAwareCropsIndexing {
  /**
   * Compact representation for Mustang storage. See
   * image/search/utils/packed_crops.h for details on the packing format.
   */
  mustangBytes?: Uint8Array;
  mustangBytesVersion?: number;
}

function serializeContentAwareCropsIndexing(data: any): ContentAwareCropsIndexing {
  return {
    ...data,
    mustangBytes: data["mustangBytes"] !== undefined ? encodeBase64(data["mustangBytes"]) : undefined,
  };
}

function deserializeContentAwareCropsIndexing(data: any): ContentAwareCropsIndexing {
  return {
    ...data,
    mustangBytes: data["mustangBytes"] !== undefined ? decodeBase64(data["mustangBytes"] as string) : undefined,
  };
}

/**
 * Contains lexical metadata for a given reference. For example, this proto
 * will be used to store locale-specific Lexical mids for contact relationships
 * (e.g. /g/11gv0vypg4 is the mid for mother in english and /g/11gmy_gv87 is for
 * mother in french) as an extension to QRefAnnotation::other_metadata, when
 * available.
 */
export interface CopleyLexicalMetadata {
  /**
   * Mid for an entity that has lexical data (a LexiconEntry). See
   * https://g3doc.corp.google.com/nlp/generation/g3doc/lexical_data.md for for
   * more information about lexical data. This is the canonical mid for this
   * entity (eg. it would be for "mother" in EN even if user referred to "mom").
   */
  canonicalLexicalMid?: string;
}

/**
 * Represents a reference made by a user that refers to some personal entity.
 */
export interface CopleyPersonalReference {
  /**
   * The manner in which the entity was referenced (e.g. "my hotel", "the
   * airport").
   */
  personalReferenceType?:  | "PERSONAL_UNKNOWN_REFERENCE" | "PERSONAL_HOTEL_REFERENCE" | "PERSONAL_HOTEL_BOOKING_AGENT_REFERENCE" | "PERSONAL_RESTAURANT_REFERENCE" | "PERSONAL_RESTAURANT_BOOKING_AGENT_REFERENCE" | "PERSONAL_PARKING_REFERENCE" | "PERSONAL_FLIGHT_REFERENCE" | "PERSONAL_GENERIC_SOCIAL_EVENT_REFERENCE" | "PERSONAL_CONCERT_REFERENCE" | "PERSONAL_SPORTS_REFERENCE" | "PERSONAL_MOVIE_REFERENCE" | "PERSONAL_TOUR_REFERENCE" | "PERSONAL_HOME_REFERENCE" | "PERSONAL_WORK_REFERENCE" | "PERSONAL_MAPS_ALIAS_REFERENCE" | "PERSONAL_CONTACT_REFERENCE" | "PERSONAL_CONTACT_PERSON_REFERENCE" | "PERSONAL_CONTACT_LOCATION_REFERENCE" | "PERSONAL_FAMILY_MEMBER_REFERENCE" | "PERSONAL_CONTACT_BIRTHDAY_REFERENCE" | "PERSONAL_CONTACT_ADDRESS_REFERENCE" | "PERSONAL_RELATIONSHIP_REFERENCE" | "PERSONAL_RELATIONSHIP_PERSON_REFERENCE" | "PERSONAL_RELATIONSHIP_LOCATION_REFERENCE" | "PERSONAL_MEMORABLE_DATE_REFERENCE" | "PERSONAL_MEMORY_ANNIVERSARY_DATE_REFERENCE" | "PERSONAL_MEMORY_PAYDAY_DATE_REFERENCE" | "PERSONAL_MEMORY_WEDDING_DATE_REFERENCE" | "PERSONAL_MEMORY_BIRTHDAY_DATE_REFERENCE" | "PERSONAL_MEMORY_EXAM_DATE_REFERENCE" | "PERSONAL_MEMORY_MATHEXAM_DATE_REFERENCE" | "PERSONAL_MEMORY_OILCHANGE_DATE_REFERENCE" | "PERSONAL_MEMORY_GRADUATION_DATE_REFERENCE";
}

/**
 * General message used to store metadata about references to personal
 * entities, even if those entities cannot be resolved.
 */
export interface CopleyPersonalReferenceMetadata {
  /**
   * A list of all references made. Empty if no personal references exist.
   * Multiple references can be present when multiple references were made in a
   * single query, or the type of reference was ambiguous.
   */
  references?: CopleyPersonalReference[];
  /**
   * The strength of the personal reference. For example "my flight" may
   * receive a high reference_score, whereas "the airport" may receive a low
   * score.
   */
  referenceScore?: number;
  /**
   * Subreference metadata for all compound references on this span.
   */
  subreferenceMetadata?: CopleySubreferenceMetadata;
}

export interface CopleySourceTypeList {
  sourceTypeMetadata?: CopleySourceTypeMetadata[];
}

function serializeCopleySourceTypeList(data: any): CopleySourceTypeList {
  return {
    ...data,
    sourceTypeMetadata: data["sourceTypeMetadata"] !== undefined ? data["sourceTypeMetadata"].map((item: any) => (serializeCopleySourceTypeMetadata(item))) : undefined,
  };
}

function deserializeCopleySourceTypeList(data: any): CopleySourceTypeList {
  return {
    ...data,
    sourceTypeMetadata: data["sourceTypeMetadata"] !== undefined ? data["sourceTypeMetadata"].map((item: any) => (deserializeCopleySourceTypeMetadata(item))) : undefined,
  };
}

/**
 * Contains the source and type information related to a personal entity, for
 * example if it's an hotel or a restaurant (type) and if it comes from gmail,
 * calendar, etc. (source). Next ID: 13
 */
export interface CopleySourceTypeMetadata {
  /**
   * Annotation ID of a contact annotation, e.g. a relationship set via
   * Assistant. This ID is generated by People Write Server. It is used to
   * delete Contact Annotations via People API.
   */
  contactAnnotationId?: string;
  displayableName?: string;
  /**
   * Only used if personal_data_provenance == PERSONAL_SOURCE_GMAIL. Used to
   * create a link to the source email in the form:
   * mail.google.com/mail/u/0/?extsrc=sync&client=h&plid={email_identifier}
   */
  emailIdentifier?: string;
  /**
   * Populated for some footprints data sources; uniquely identifies the
   * footprint that generated the personal data that this provenance is attached
   * to.
   */
  eventId?: EventIdMessage;
  localDiscoverySettingsMetadata?: PersonalizationSettingsApiProtoLocalDiscoveryLocalDiscoverySettingsMetadata;
  personalDataProvenance?:  | "PERSONAL_SOURCE_UNKNOWN" | "PERSONAL_SOURCE_GMAIL" | "PERSONAL_SOURCE_CALENDAR" | "PERSONAL_SOURCE_MAPS_ALIAS" | "PERSONAL_SOURCE_FOCUS" | "PERSONAL_SOURCE_FOCUS_CONSISTENT" | "PERSONAL_SOURCE_FOCUS_TOP_N_CONTACTS" | "PERSONAL_SOURCE_ASSISTANT_CONTACT_AFFINITY" | "PERSONAL_SOURCE_ASSISTANT_MEMORY" | "PERSONAL_SOURCE_PWS" | "PERSONAL_SOURCE_HOUSEHOLD" | "PERSONAL_SOURCE_HULK_PLACES" | "PERSONAL_SOURCE_FOCUS_OWNER" | "PERSONAL_SOURCE_WHITEPAGES" | "PERSONAL_SOURCE_ASSISTANT_DEVICES" | "PERSONAL_SOURCE_TEACH_LEARN" | "PERSONAL_SOURCE_GELLER_ANSWERS" | "PERSONAL_SOURCE_LAMS_SETTINGS" | "PERSONAL_SOURCE_GAIA" | "PERSONAL_SOURCE_XTALK" | "PERSONAL_SOURCE_MOVIE_DIALOG" | "PERSONAL_SOURCE_MEDIA_HABITUAL_CACHE" | "PERSONAL_SOURCE_PERSONAL_TOPICSERVER" | "PERSONAL_SOURCE_PHOTO_LABELS" | "PERSONAL_SOURCE_PEOPLE_API" | "PERSONAL_SOURCE_CONTEXT_API" | "PERSONAL_SOURCE_MUSIC_PREFERRED_PROVIDER" | "PERSONAL_SOURCE_STASH" | "PERSONAL_SOURCE_SMART_HOME_DEVICES" | "PERSONAL_SOURCE_DEVICE_STATES" | "PERSONAL_SOURCE_HANDBAG_PERSONALIZED_WEBREF_ENTITIES" | "PERSONAL_GRAPH_PEOPLE_SIGNAL_POST_PROCESSING" | "PERSONAL_SOURCE_PERSONALIZED_PRONUNCIATIONS" | "PERSONAL_SOURCE_DEVICE_INSTALLED_APPS" | "PERSONAL_SOURCE_CONTACT_AGGREGATED_DATA" | "PERSONAL_SOURCE_DYNAMIC_ENTITY_INDEX" | "PERSONAL_SOURCE_STADIA" | "PERSONAL_SOURCE_COMMUNAL_GROUP" | "PERSONAL_SOURCE_LOCATION_SHARING" | "PERSONAL_SOURCE_MAPS_SEARCH" | "PERSONAL_SOURCE_MEDIA_USER_CONTEXT_INFO" | "PERSONAL_SOURCE_MEDIA_USER_ENTITIES" | "PERSONAL_SOURCE_DEVICE_SIGNED_IN_ACCOUNTS" | "PERSONAL_SOURCE_ASSISTANT_USER_PROFILES";
  personalDataType?:  | "PERSONAL_UNKNOWN" | "PERSONAL_HOTEL" | "PERSONAL_RESTAURANT" | "PERSONAL_PARKING" | "PERSONAL_FLIGHT" | "PERSONAL_SOCIAL_EVENT" | "PERSONAL_MAPS_ALIAS" | "PERSONAL_CONTACT" | "PERSONAL_PROFILE" | "PERSONAL_BILL" | "PERSONAL_CAR_RENTAL" | "PERSONAL_GENERIC_EVENT" | "PERSONAL_TRAIN" | "PERSONAL_BUS" | "PERSONAL_TAXI" | "PERSONAL_FERRY" | "PERSONAL_PHONE_NUMBER" | "PERSONAL_DEVICE" | "PERSONAL_PREFERENCE" | "PERSONAL_DIETARY_RESTRICTION" | "PERSONAL_MEDIA_HABITUAL_CACHE" | "PERSONAL_NEWS_PREFERENCE" | "PERSONAL_FAVORITE" | "PERSONAL_GAMER_CONTACT";
  provenanceCategory?:  | "PROVENANCE_CATEGORY_UNKNOWN" | "CORE_APPS_DATA"[];
  /**
   * Sensitivity applying to this copley annotation.
   */
  sensitivity?: KnowledgeAnswersSensitivitySensitivity;
}

function serializeCopleySourceTypeMetadata(data: any): CopleySourceTypeMetadata {
  return {
    ...data,
    eventId: data["eventId"] !== undefined ? serializeEventIdMessage(data["eventId"]) : undefined,
    sensitivity: data["sensitivity"] !== undefined ? serializeKnowledgeAnswersSensitivitySensitivity(data["sensitivity"]) : undefined,
  };
}

function deserializeCopleySourceTypeMetadata(data: any): CopleySourceTypeMetadata {
  return {
    ...data,
    eventId: data["eventId"] !== undefined ? deserializeEventIdMessage(data["eventId"]) : undefined,
    sensitivity: data["sensitivity"] !== undefined ? deserializeKnowledgeAnswersSensitivitySensitivity(data["sensitivity"]) : undefined,
  };
}

/**
 * Represents the most compound resolved entities and most nested unresolved
 * references for a span. Useful for punting.
 */
export interface CopleySubreferenceMetadata {
  /**
   * Resolved entities are sorted from highest resolution score to lowest.
   */
  mostCompoundResolvedEntities?: CopleySubreferenceResolution[];
  /**
   * This is a merged representation of the compound reference having the
   * most_compound_resolved_entities as an argument.
   */
  mostNestedUnresolvedReference?: CopleySubreferenceReference;
}

/**
 * Represents a reference that may be part of a larger compound reference. For
 * example, "my brother's birthday" will have a subreference that may have
 * references for "my brother".
 */
export interface CopleySubreferenceReference {
  /**
   * Type of reference. There may be multiple for a single reference (e.g.
   * relationship and contact).
   */
  personalReferenceTypes?:  | "PERSONAL_UNKNOWN_REFERENCE" | "PERSONAL_HOTEL_REFERENCE" | "PERSONAL_HOTEL_BOOKING_AGENT_REFERENCE" | "PERSONAL_RESTAURANT_REFERENCE" | "PERSONAL_RESTAURANT_BOOKING_AGENT_REFERENCE" | "PERSONAL_PARKING_REFERENCE" | "PERSONAL_FLIGHT_REFERENCE" | "PERSONAL_GENERIC_SOCIAL_EVENT_REFERENCE" | "PERSONAL_CONCERT_REFERENCE" | "PERSONAL_SPORTS_REFERENCE" | "PERSONAL_MOVIE_REFERENCE" | "PERSONAL_TOUR_REFERENCE" | "PERSONAL_HOME_REFERENCE" | "PERSONAL_WORK_REFERENCE" | "PERSONAL_MAPS_ALIAS_REFERENCE" | "PERSONAL_CONTACT_REFERENCE" | "PERSONAL_CONTACT_PERSON_REFERENCE" | "PERSONAL_CONTACT_LOCATION_REFERENCE" | "PERSONAL_FAMILY_MEMBER_REFERENCE" | "PERSONAL_CONTACT_BIRTHDAY_REFERENCE" | "PERSONAL_CONTACT_ADDRESS_REFERENCE" | "PERSONAL_RELATIONSHIP_REFERENCE" | "PERSONAL_RELATIONSHIP_PERSON_REFERENCE" | "PERSONAL_RELATIONSHIP_LOCATION_REFERENCE" | "PERSONAL_MEMORABLE_DATE_REFERENCE" | "PERSONAL_MEMORY_ANNIVERSARY_DATE_REFERENCE" | "PERSONAL_MEMORY_PAYDAY_DATE_REFERENCE" | "PERSONAL_MEMORY_WEDDING_DATE_REFERENCE" | "PERSONAL_MEMORY_BIRTHDAY_DATE_REFERENCE" | "PERSONAL_MEMORY_EXAM_DATE_REFERENCE" | "PERSONAL_MEMORY_MATHEXAM_DATE_REFERENCE" | "PERSONAL_MEMORY_OILCHANGE_DATE_REFERENCE" | "PERSONAL_MEMORY_GRADUATION_DATE_REFERENCE"[];
  /**
   * Highest reference score for any references merged in this span.
   */
  referenceScore?: number;
  /**
   * Only set for unresolved relationship references and can be used to get the
   * canonical word for the relationship (e.g. "mother") in TTS.
   */
  relationshipLexicalInfo?: CopleyLexicalMetadata;
}

/**
 * Represents a resolution that may be part of a larger compound reference. For
 * example, "my brother's birthday" will have a subreference that may have
 * resolutions for "my brother".
 */
export interface CopleySubreferenceResolution {
  /**
   * Can be used with PKG Service for looking up metadata about this entity at
   * fulfillment/GenX time.
   */
  mid?: string;
  /**
   * Name of the entity represented by this resolution.
   */
  name?: string;
  /**
   * A resolution score of 0 indicates that it did not resolve to a real
   * entity.
   */
  resolutionScore?: number;
}

export interface CorpusSelectionInfo {
  corpus?:  | "UNKNOWN" | "LENS";
  /**
   * Corpus specific score for an image
   */
  corpusScore?: number;
  /**
   * Whether an image was selected for indexing.
   */
  isSelectedForIndexing?: boolean;
  /**
   * Set of referrers indexed with the image.
   */
  referrerDocid?: bigint[];
  /**
   * Set of referrer urls indexed with the image.
   */
  referrerUrls?: string[];
}

function serializeCorpusSelectionInfo(data: any): CorpusSelectionInfo {
  return {
    ...data,
    referrerDocid: data["referrerDocid"] !== undefined ? data["referrerDocid"].map((item: any) => (String(item))) : undefined,
  };
}

function deserializeCorpusSelectionInfo(data: any): CorpusSelectionInfo {
  return {
    ...data,
    referrerDocid: data["referrerDocid"] !== undefined ? data["referrerDocid"].map((item: any) => (BigInt(item))) : undefined,
  };
}

export interface CountryClickDistribution {
  /**
   * To store confidence in the distribution in cases when total is not set.
   */
  confidence?: number;
  item?: CountryClickDistributionItem[];
  /**
   * To store total clicks on this page/domain.
   */
  total?: number;
}

export interface CountryClickDistributionItem {
  doubleValue?: number;
  name?: string;
  value?: number;
}

/**
 * If you add new fields to this message, do not use any tag value less than
 * the "Next free tag" below. The lower tag values might be missing in this
 * file, but they were used in past for some field, so cannot be used again.
 * Next free tag: 44
 */
export interface CountryCountryAttachment {
  /**
   * Store weighted click distribution for page level country-id
   * classification.
   */
  clickDistribution?: CountryClickDistribution;
  /**
   * Is true if the country attachment was computed through the UGC pipeline.
   */
  countryidFromUgc?: boolean;
  /**
   * A non critical field to store debug info for a country attachment. Used in
   * experiments and for debugging.
   */
  debug?: string;
  /**
   * Set to the signal source URLs when merging country signals in Alexandria
   * during sitemoves. Essentially if sites A and B move to C, and we merge A
   * and B's signal to C, in the countryattachment signal C will have URL A and
   * B as source_url. Only used for debugging and it doesn't show up in
   * docjoins.
   */
  debugSourceUrl?: string[];
  /**
   * Specifies the origin of `geo_locations`. Right now, it can either come
   * from deprecated Docloc system or the new Brainloc system when Docloc
   * doesn't have sufficient evidence.
   */
  documentLocationSource?:  | "UNSPECIFIED" | "DOCLOC" | "BRAINLOC" | "LOGLOC";
  existNextLevel?: boolean;
  /**
   * Booleans to keep track of where the country-id of the page came from.
   * These are used for debugging and/or unittests, and cleared in production.
   */
  fromLanguageFallback?: boolean;
  fromRestricts?: boolean;
  fromSgDomains?: boolean;
  fromTld?: boolean;
  fromUgc?: boolean;
  fromUrlPattern?: boolean;
  fromWmx?: boolean;
  /**
   * New MetroID: Now called GeoLocations since the locations could be
   * sublocalities, cities or states. GeoLocations are always more fine grained
   * than country. TODO (jayeshv): Once new MetroID/GeoLocations is launched
   * everywhere, deleted old MetroID related fields.
   */
  geoLocations?: CountryGeoLocations;
  global?: boolean;
  /**
   * Set to true if the local_countries field can be used for country restricts
   * as well.
   */
  isValidForCountryRestrict?: boolean;
  /**
   * two-letter(lower-case) countrycode, e.g. us countries that is local to
   */
  localCountries?: string[];
  /**
   * Fields that actually store the country id in docjoins. The format of this
   * data is defined in //i18n/identifiers/stableinternalregionconverter.cc.
   * Converter defined there can be used to convert it to RegionCode format.
   */
  localCountryCodes?: number[];
  /**
   * Metro locations: list of NavBoost feature V2 associated with a doc, along
   * with the enclosing province. Metro locations with new tags.
   */
  metroIdList?: CountryMetroNBFeature[];
  /**
   * Metro level data. metro_location_id stores geotokens for metro restricts.
   */
  metroLocationId?: string[];
  /**
   * Metro navboost: list of (NavBoost feature V2, navboost float) pairs.
   */
  metroNavboost?: CountryMetroNBFeature[];
  provinceGeotokenList?: CountryProvinceGeotoken[];
  /**
   * two-letter(lower-case) countrycode, e.g. us countries that is related to,
   * but not local to
   */
  relatedCountries?: string[];
  relatedCountryCodes?: number[];
  /**
   * List of two-letter(lower-case) countrycodes(e.g. us) valid for restricts.
   * Typically cloned out of local_countries if is_valid_for_country_restrict is
   * set to true.
   */
  restrictCountries?: string[];
  /**
   * [Experimental]: Top salient countries for a doc. If a country can not be
   * found on this field it can be considered that this doc is not relevant to
   * it.
   */
  salientCountries?: CountrySalientCountry[];
  salientCountrySet?: QualitySalientCountriesSalientCountrySet;
  /**
   * Domain name of keys in filtering metro reducer class, used only by the
   * intermediate mapreduces to produce filtered data.
   */
  sitename?: string;
  /**
   * Super global pages get lesser demotion than global pages. A document can
   * only be either global or super_global but not both.
   */
  superGlobal?: boolean;
  urlPatternBasedCountry?: number;
  /**
   * Language and country extracted using the URL pattern map.
   */
  urlPatternBasedLanguage?: number;
  /**
   * This is used to store the visible country id computed from logs data
   */
  userVisibleCountryFromLogs?: string;
  /**
   * This is the country id we show to users on the result page. This is kept
   * different from country demotion country id because we dont want to expose
   * our backoff and url based detection algorithm - also we want to be ultra
   * conservative in showing this.
   */
  userVisibleLocalCountry?: number;
  /**
   * If result is global, store weight above ideal, as a confidence signal.
   * Used in query localness, cleared in production CountryAttachment.
   */
  weightAboveIdealForLocalness?: number;
  /**
   * Country specified for a web-site through webmaster console.
   */
  wmxCountry?: string;
}

function serializeCountryCountryAttachment(data: any): CountryCountryAttachment {
  return {
    ...data,
    geoLocations: data["geoLocations"] !== undefined ? serializeCountryGeoLocations(data["geoLocations"]) : undefined,
  };
}

function deserializeCountryCountryAttachment(data: any): CountryCountryAttachment {
  return {
    ...data,
    geoLocations: data["geoLocations"] !== undefined ? deserializeCountryGeoLocations(data["geoLocations"]) : undefined,
  };
}

/**
 * Stores one location and all meta-data associated with that location.
 */
export interface CountryGeoLocation {
  /**
   * The radius (in miles) around the assigned location that the document gets
   * 50% of its clicks.
   */
  clickRadius50Percent?: number;
  /**
   * Confidence on the location. Ranges in [0.0, 1.0]. Cleared during index
   * creation.
   */
  confidence?: number;
  /**
   * Confidence mapped to [0, 100]. Converted to integer for efficient storage.
   * Populated during index creation.
   */
  confidencePercent?: number;
  /**
   * Used for compressed docloc data. In compressed data, instead of
   * location_info, only an integer ID for that LocationInfo is stored. A
   * separate lookup table is used to get full LocationInfo from the internal
   * ID.
   */
  internalId?: number;
  locationInfo?: CountryLocationInfo;
  /**
   * True if this location is assigned to one of the subpages, and not to the
   * page itself. If the total number of locations assigned to all the subpages
   * of a page is small (usually up to 5), then that page also gets assigned
   * those locations, and this flag is set for those locations.
   */
  propagatedFromASubpage?: boolean;
}

function serializeCountryGeoLocation(data: any): CountryGeoLocation {
  return {
    ...data,
    locationInfo: data["locationInfo"] !== undefined ? serializeCountryLocationInfo(data["locationInfo"]) : undefined,
  };
}

function deserializeCountryGeoLocation(data: any): CountryGeoLocation {
  return {
    ...data,
    locationInfo: data["locationInfo"] !== undefined ? deserializeCountryLocationInfo(data["locationInfo"]) : undefined,
  };
}

/**
 * List of locations assigned to a document.
 */
export interface CountryGeoLocations {
  geoLocation?: CountryGeoLocation[];
  /**
   * This will be set to true for documents which receive several clicks but
   * are not assigned any location because the click distribution is flat.
   * Typical examples are global sites like facebook.com, chains like
   * walmart.com, informational sites like wikipedia.org etc. This flag is not
   * propagated to deeper pages since this signal is meant to indicate that a
   * website or a part of website is conclusively non-local, so propagating this
   * information to deeper pages does not make sense. If this flag is set, then
   * the only possible geo_location will be the ones which are
   * propagated_from_a_subpage.
   */
  isNonLocationSpecific?: boolean;
  /**
   * Depth of the URL from it's nearest parent in GeoLocation data. Webpages
   * inherhit locations from their parent pages. For example, if foo.com/a is
   * assigned location L1, and foo.com/a/b is not assigned any location, then
   * http://www.foo.com/a/b inherits location L1 from it's nearest parent
   * foo.com/a in GeoLocation data. This attribute is the distance from the
   * nearest parent which is present in GeoLocation data. In this particular
   * case, it will be 1.
   */
  propagationDepthFromParent?: number;
}

function serializeCountryGeoLocations(data: any): CountryGeoLocations {
  return {
    ...data,
    geoLocation: data["geoLocation"] !== undefined ? data["geoLocation"].map((item: any) => (serializeCountryGeoLocation(item))) : undefined,
  };
}

function deserializeCountryGeoLocations(data: any): CountryGeoLocations {
  return {
    ...data,
    geoLocation: data["geoLocation"] !== undefined ? data["geoLocation"].map((item: any) => (deserializeCountryGeoLocation(item))) : undefined,
  };
}

/**
 * This represents one location.
 */
export interface CountryLocationInfo {
  /**
   * The latitude and longitude of the conceptual center of the location. For
   * cities, this would be the center of the downtown, or maybe the location of
   * city hall. For states and countries it might be the capital city. But there
   * are no guarantees and this may be any random point inside the location.
   */
  center?: GeostorePointProto;
  city?: string;
  /**
   * Human readable name hierarchy. Only the relevant fields will be present.
   * For example for city GeoLocations, sub_locality field will not be present.
   * Cleared during index creation.
   */
  country?: string;
  county?: string;
  /**
   * Oyster feature ID of the enclosing state. Cleared during index creation.
   */
  enclosingStateFeatureId?: GeostoreFeatureIdProto;
  /**
   * Oyster feature ID of the location. Cleared during index creation.
   */
  featureId?: GeostoreFeatureIdProto;
  state?: string;
  /**
   * 32 bit fingerprint of the feature id of the state of this location. For
   * cities and sub-localities it will be the enclosing state. For state
   * locations, it will be fingerprint of the feture-id of the location itself.
   * Populated during index creation.
   */
  stateIdFprint?: number;
  subLocality?: string;
  /**
   * Type of the location (sub-locality, city, state etc).
   */
  type?:  | "TYPE_ANY" | "TYPE_TRANSPORTATION" | "TYPE_ROUTE" | "TYPE_DEPRECATED_HIGHWAY_DO_NOT_USE" | "TYPE_HIGHWAY" | "TYPE_HIGHWAY_1" | "TYPE_HIGHWAY_2" | "TYPE_HIGHWAY_3" | "TYPE_HIGHWAY_4" | "TYPE_HIGHWAY_5" | "TYPE_HIGHWAY_6" | "TYPE_HIGHWAY_7" | "TYPE_HIGHWAY_8" | "TYPE_HIGHWAY_9" | "TYPE_BICYCLE_ROUTE" | "TYPE_TRAIL" | "TYPE_SEGMENT" | "TYPE_ROAD" | "TYPE_RAILWAY" | "TYPE_STANDARD_TRACK" | "TYPE_JR_TRACK" | "TYPE_NARROW_TRACK" | "TYPE_MONORAIL_TRACK" | "TYPE_SUBWAY_TRACK" | "TYPE_LIGHT_RAIL_TRACK" | "TYPE_BROAD_TRACK" | "TYPE_HIGH_SPEED_RAIL" | "TYPE_TROLLEY_TRACK" | "TYPE_FERRY" | "TYPE_FERRY_BOAT" | "TYPE_FERRY_TRAIN" | "TYPE_VIRTUAL_SEGMENT" | "TYPE_INTERSECTION" | "TYPE_TRANSIT" | "TYPE_TRANSIT_STATION" | "TYPE_BUS_STATION" | "TYPE_TRAMWAY_STATION" | "TYPE_TRAIN_STATION" | "TYPE_SUBWAY_STATION" | "TYPE_FERRY_TERMINAL" | "TYPE_AIRPORT" | "TYPE_AIRPORT_CIVIL" | "TYPE_AIRPORT_MILITARY" | "TYPE_AIRPORT_MIXED" | "TYPE_HELIPORT" | "TYPE_SEAPLANE_BASE" | "TYPE_AIRSTRIP" | "TYPE_CABLE_CAR_STATION" | "TYPE_GONDOLA_LIFT_STATION" | "TYPE_FUNICULAR_STATION" | "TYPE_SPECIAL_STATION" | "TYPE_HORSE_CARRIAGE_STATION" | "TYPE_MONORAIL_STATION" | "TYPE_SEAPORT" | "TYPE_TRANSIT_STOP" | "TYPE_TRANSIT_TRIP" | "TYPE_TRANSIT_DEPARTURE" | "TYPE_TRANSIT_LEG" | "TYPE_TRANSIT_LINE" | "TYPE_TRANSIT_AGENCY_DEPRECATED_VALUE" | "TYPE_TRANSIT_TRANSFER" | "TYPE_SEGMENT_PATH" | "TYPE_ROAD_SIGN" | "TYPE_INTERSECTION_GROUP" | "TYPE_PATHWAY" | "TYPE_RESTRICTION_GROUP" | "TYPE_TOLL_CLUSTER" | "TYPE_POLITICAL" | "TYPE_COUNTRY" | "TYPE_ADMINISTRATIVE_AREA" | "TYPE_ADMINISTRATIVE_AREA1" | "TYPE_US_STATE" | "TYPE_GB_COUNTRY" | "TYPE_JP_TODOUFUKEN" | "TYPE_ADMINISTRATIVE_AREA2" | "TYPE_GB_FORMER_POSTAL_COUNTY" | "TYPE_GB_TRADITIONAL_COUNTY" | "TYPE_ADMINISTRATIVE_AREA3" | "TYPE_ADMINISTRATIVE_AREA4" | "TYPE_ADMINISTRATIVE_AREA5" | "TYPE_ADMINISTRATIVE_AREA6" | "TYPE_ADMINISTRATIVE_AREA7" | "TYPE_ADMINISTRATIVE_AREA8" | "TYPE_ADMINISTRATIVE_AREA9" | "TYPE_COLLOQUIAL_AREA" | "TYPE_RESERVATION" | "TYPE_LOCALITY" | "TYPE_GB_POST_TOWN" | "TYPE_JP_GUN" | "TYPE_JP_SHIKUCHOUSON" | "TYPE_JP_SUB_SHIKUCHOUSON" | "TYPE_COLLOQUIAL_CITY" | "TYPE_SUBLOCALITY" | "TYPE_US_BOROUGH" | "TYPE_GB_DEPENDENT_LOCALITY" | "TYPE_JP_OOAZA" | "TYPE_JP_KOAZA" | "TYPE_JP_GAIKU" | "TYPE_GB_DOUBLE_DEPENDENT_LOCALITY" | "TYPE_JP_CHIBAN" | "TYPE_JP_EDABAN" | "TYPE_SUBLOCALITY1" | "TYPE_SUBLOCALITY2" | "TYPE_SUBLOCALITY3" | "TYPE_SUBLOCALITY4" | "TYPE_SUBLOCALITY5" | "TYPE_NEIGHBORHOOD" | "TYPE_CONSTITUENCY" | "TYPE_DESIGNATED_MARKET_AREA" | "TYPE_SCHOOL_DISTRICT" | "TYPE_LAND_PARCEL" | "TYPE_DISPUTED_AREA" | "TYPE_POLICE_JURISDICTION" | "TYPE_STATISTICAL_AREA" | "TYPE_CONSTITUENCY_FUTURE" | "TYPE_PARK" | "TYPE_GOLF_COURSE" | "TYPE_LOCAL_PARK" | "TYPE_NATIONAL_PARK" | "TYPE_US_NATIONAL_PARK" | "TYPE_US_NATIONAL_MONUMENT" | "TYPE_NATIONAL_FOREST" | "TYPE_PROVINCIAL_PARK" | "TYPE_PROVINCIAL_FOREST" | "TYPE_CAMPGROUNDS" | "TYPE_HIKING_AREA" | "TYPE_BUSINESS" | "TYPE_GOVERNMENT" | "TYPE_BORDER_CROSSING" | "TYPE_CITY_HALL" | "TYPE_COURTHOUSE" | "TYPE_EMBASSY" | "TYPE_LIBRARY" | "TYPE_SCHOOL" | "TYPE_UNIVERSITY" | "TYPE_EMERGENCY" | "TYPE_HOSPITAL" | "TYPE_PHARMACY" | "TYPE_POLICE" | "TYPE_FIRE" | "TYPE_DOCTOR" | "TYPE_DENTIST" | "TYPE_VETERINARIAN" | "TYPE_TRAVEL_SERVICE" | "TYPE_LODGING" | "TYPE_RESTAURANT" | "TYPE_GAS_STATION" | "TYPE_PARKING" | "TYPE_POST_OFFICE" | "TYPE_REST_AREA" | "TYPE_CASH_MACHINE" | "TYPE_CAR_RENTAL" | "TYPE_CAR_REPAIR" | "TYPE_SHOPPING" | "TYPE_GROCERY" | "TYPE_TOURIST_DESTINATION" | "TYPE_ECO_TOURIST_DESTINATION" | "TYPE_BIRD_WATCHING" | "TYPE_FISHING" | "TYPE_HUNTING" | "TYPE_NATURE_RESERVE" | "TYPE_TEMPLE" | "TYPE_CHURCH" | "TYPE_GURUDWARA" | "TYPE_HINDU_TEMPLE" | "TYPE_MOSQUE" | "TYPE_SYNAGOGUE" | "TYPE_STADIUM" | "TYPE_BAR" | "TYPE_MOVIE_RENTAL" | "TYPE_COFFEE" | "TYPE_GOLF" | "TYPE_BANK" | "TYPE_DOODLE" | "TYPE_GROUNDS" | "TYPE_AIRPORT_GROUNDS" | "TYPE_BUILDING_GROUNDS" | "TYPE_CEMETERY" | "TYPE_HOSPITAL_GROUNDS" | "TYPE_INDUSTRIAL" | "TYPE_MILITARY" | "TYPE_SHOPPING_CENTER" | "TYPE_SPORTS_COMPLEX" | "TYPE_UNIVERSITY_GROUNDS" | "TYPE_DEPRECATED_TARMAC" | "TYPE_ENCLOSED_TRAFFIC_AREA" | "TYPE_PARKING_LOT" | "TYPE_PARKING_GARAGE" | "TYPE_OFF_ROAD_AREA" | "TYPE_BORDER" | "TYPE_BUILDING" | "TYPE_GEOCODED_ADDRESS" | "TYPE_NATURAL_FEATURE" | "TYPE_TERRAIN" | "TYPE_SAND" | "TYPE_BEACH" | "TYPE_DUNE" | "TYPE_ROCKY" | "TYPE_ICE" | "TYPE_GLACIER" | "TYPE_BUILT_UP_AREA" | "TYPE_VEGETATION" | "TYPE_SHRUBBERY" | "TYPE_WOODS" | "TYPE_AGRICULTURAL" | "TYPE_GRASSLAND" | "TYPE_TUNDRA" | "TYPE_DESERT" | "TYPE_SALT_FLAT" | "TYPE_WATER" | "TYPE_OCEAN" | "TYPE_BAY" | "TYPE_BIGHT" | "TYPE_LAGOON" | "TYPE_SEA" | "TYPE_STRAIT" | "TYPE_INLET" | "TYPE_FJORD" | "TYPE_LAKE" | "TYPE_SEASONAL_LAKE" | "TYPE_RESERVOIR" | "TYPE_POND" | "TYPE_RIVER" | "TYPE_RAPIDS" | "TYPE_DISTRIBUTARY" | "TYPE_CONFLUENCE" | "TYPE_WATERFALL" | "TYPE_SPRING" | "TYPE_GEYSER" | "TYPE_HOT_SPRING" | "TYPE_SEASONAL_RIVER" | "TYPE_WADI" | "TYPE_ESTUARY" | "TYPE_WETLAND" | "TYPE_WATER_NAVIGATION" | "TYPE_FORD" | "TYPE_CANAL" | "TYPE_HARBOR" | "TYPE_CHANNEL" | "TYPE_REEF" | "TYPE_REEF_FLAT" | "TYPE_REEF_GROWTH" | "TYPE_REEF_EXTENT" | "TYPE_REEF_ROCK_SUBMERGED" | "TYPE_IRRIGATION" | "TYPE_DAM" | "TYPE_DRINKING_WATER" | "TYPE_CURRENT" | "TYPE_WATERING_HOLE" | "TYPE_TECTONIC" | "TYPE_WATERING_HOLE_DEPRECATED" | "TYPE_VOLCANO" | "TYPE_LAVA_FIELD" | "TYPE_FISSURE" | "TYPE_FAULT" | "TYPE_LAND_MASS" | "TYPE_CONTINENT" | "TYPE_ISLAND" | "TYPE_ATOLL" | "TYPE_OCEAN_ROCK_EXPOSED" | "TYPE_CAY" | "TYPE_PENINSULA" | "TYPE_ISTHMUS" | "TYPE_ELEVATED" | "TYPE_PEAK" | "TYPE_NUNATAK" | "TYPE_SPUR" | "TYPE_PASS" | "TYPE_PLATEAU" | "TYPE_RIDGE" | "TYPE_RAVINE" | "TYPE_CRATER" | "TYPE_KARST" | "TYPE_CLIFF" | "TYPE_VISTA" | "TYPE_DIGITAL_ELEVATION_MODEL" | "TYPE_UPLAND" | "TYPE_TERRACE" | "TYPE_SLOPE" | "TYPE_CONTOUR_LINE" | "TYPE_PAN" | "TYPE_UNSTABLE_HILLSIDE" | "TYPE_MOUNTAIN_RANGE" | "TYPE_UNDERSEA" | "TYPE_SUBMARINE_SEAMOUNT" | "TYPE_SUBMARINE_RIDGE" | "TYPE_SUBMARINE_GAP" | "TYPE_SUBMARINE_PLATEAU" | "TYPE_SUBMARINE_DEEP" | "TYPE_SUBMARINE_VALLEY" | "TYPE_SUBMARINE_BASIN" | "TYPE_SUBMARINE_SLOPE" | "TYPE_SUBMARINE_CLIFF" | "TYPE_SUBMARINE_PLAIN" | "TYPE_SUBMARINE_FRACTURE_ZONE" | "TYPE_CAVE" | "TYPE_ROCK" | "TYPE_ARCHIPELAGO" | "TYPE_POSTAL" | "TYPE_POSTAL_CODE" | "TYPE_POSTAL_CODE_PREFIX" | "TYPE_PREMISE" | "TYPE_SUB_PREMISE" | "TYPE_SUITE" | "TYPE_POST_TOWN" | "TYPE_POSTAL_ROUND" | "TYPE_META_FEATURE" | "TYPE_DATA_SOURCE" | "TYPE_LOCALE" | "TYPE_TIMEZONE" | "TYPE_BUSINESS_CHAIN" | "TYPE_PHONE_NUMBER_PREFIX" | "TYPE_PHONE_NUMBER_AREA_CODE" | "TYPE_BUSINESS_CORRIDOR" | "TYPE_ADDRESS_TEMPLATE" | "TYPE_TRANSIT_AGENCY" | "TYPE_FUTURE_GEOMETRY" | "TYPE_EVENT" | "TYPE_EARTHQUAKE" | "TYPE_HURRICANE" | "TYPE_WEATHER_CONDITION" | "TYPE_TRANSIENT" | "TYPE_ENTRANCE" | "TYPE_CARTOGRAPHIC" | "TYPE_HIGH_TENSION" | "TYPE_SKI_TRAIL" | "TYPE_SKI_LIFT" | "TYPE_SKI_BOUNDARY" | "TYPE_WATERSHED_BOUNDARY" | "TYPE_TARMAC" | "TYPE_WALL" | "TYPE_PICNIC_AREA" | "TYPE_PLAY_GROUND" | "TYPE_TRAIL_HEAD" | "TYPE_GOLF_TEEING_GROUND" | "TYPE_GOLF_PUTTING_GREEN" | "TYPE_GOLF_ROUGH" | "TYPE_GOLF_SAND_BUNKER" | "TYPE_GOLF_FAIRWAY" | "TYPE_GOLF_HOLE" | "TYPE_DEPRECATED_GOLF_SHOP" | "TYPE_CAMPING_SITE" | "TYPE_DESIGNATED_BARBECUE_PIT" | "TYPE_DESIGNATED_COOKING_AREA" | "TYPE_CAMPFIRE_PIT" | "TYPE_WATER_FOUNTAIN" | "TYPE_LITTER_RECEPTACLE" | "TYPE_LOCKER_AREA" | "TYPE_ANIMAL_ENCLOSURE" | "TYPE_CARTOGRAPHIC_LINE" | "TYPE_ESTABLISHMENT" | "TYPE_ESTABLISHMENT_GROUNDS" | "TYPE_ESTABLISHMENT_BUILDING" | "TYPE_ESTABLISHMENT_POI" | "TYPE_ESTABLISHMENT_SERVICE" | "TYPE_CELESTIAL" | "TYPE_ROAD_MONITOR" | "TYPE_PUBLIC_SPACES_AND_MONUMENTS" | "TYPE_STATUE" | "TYPE_TOWN_SQUARE" | "TYPE_LEVEL" | "TYPE_COMPOUND" | "TYPE_COMPOUND_GROUNDS" | "TYPE_COMPOUND_BUILDING" | "TYPE_COMPOUND_SECTION" | "TYPE_TERMINAL_POINT" | "TYPE_REGULATED_AREA" | "TYPE_LOGICAL_BORDER" | "TYPE_DO_NOT_USE_RESERVED_TO_CATCH_GENERATED_FILES" | "TYPE_UNKNOWN";
}

function serializeCountryLocationInfo(data: any): CountryLocationInfo {
  return {
    ...data,
    enclosingStateFeatureId: data["enclosingStateFeatureId"] !== undefined ? serializeGeostoreFeatureIdProto(data["enclosingStateFeatureId"]) : undefined,
    featureId: data["featureId"] !== undefined ? serializeGeostoreFeatureIdProto(data["featureId"]) : undefined,
  };
}

function deserializeCountryLocationInfo(data: any): CountryLocationInfo {
  return {
    ...data,
    enclosingStateFeatureId: data["enclosingStateFeatureId"] !== undefined ? deserializeGeostoreFeatureIdProto(data["enclosingStateFeatureId"]) : undefined,
    featureId: data["featureId"] !== undefined ? deserializeGeostoreFeatureIdProto(data["featureId"]) : undefined,
  };
}

/**
 * A metro feature, keyed by NavBoost feature id V2. This can be a metro id, a
 * boost, or extended in the future to add probabilities or weights.
 */
export interface CountryMetroNBFeature {
  /**
   * The enclosing_province_geotoken is a 32 bit fingerprint of the state
   * encosing the (metro) id. MetroId's can span multiple states. Enclosing
   * geotoken is filled in with the state name for disambiguation.
   * ProvinceGeotoken field is different as it indicates an "interest". Format:
   * 32 bit fingerprint(__state__country).
   */
  enclosingProvinceGeotoken?: number;
  /**
   * A 32 bit navboost v2 feature id encoding (country, language, metro).
   * NavBoosterUtils class (google3/quality/navboost/nav_booster_utils.h)
   * provides functions to decode this feature.
   */
  id?: number;
  /**
   * This is the multiplier to apply to the result for this locale & query.
   * NOTE: This is for serving purposes only and should not be populated in the
   * index.
   */
  navboost?: number;
}

/**
 * A 32 bit fingerprint of a state level geotoken. The geotoken is in the
 * following format: __state__country. These indicate a page is of interest to
 * these states/regions of a country. The use of message is to enable easy
 * additions of probabilities or weights per metro id in the future.
 */
export interface CountryProvinceGeotoken {
  geotoken?: number;
}

/**
 * Salient Countries is an estimated probability (salience) of a doc to be
 * relevant to a country. On this message, countries are represented as int32
 * (the format of this data is defined in
 * i18n/identifiers/stableinternalregionconverter.cc). Salience is a value in
 * range [0.0 - 1.0] in which 1.0 represents a high likelihood to be relevant to
 * the country
 */
export interface CountrySalientCountry {
  compressedSalience?: number;
  countryCode?: number;
  salience?: number;
}

/**
 * Proto contains parameters for a multiple component distributions, where each
 * component has non-negative weight and the sum of component weights is 1.
 */
export interface CrawlerChangerateMultipleComponentDistribution {
  components?: CrawlerChangerateSingleComponentDistribution[];
}

/**
 * Proto contains parameters of a single component distribution.
 */
export interface CrawlerChangerateSingleComponentDistribution {
  /**
   * Scaling factor to ensure the approximated posterior to have the same scale
   * as the product of prior and likelihood. This value is used to compute
   * posterior weights. Uses log scale to provide a wider range. This field is
   * for internal use only.
   */
  logScaling?: number;
  /**
   * The type indicates the type of the distribution.
   */
  type?:  | "LOG_GAMMA" | "INV_GAMMA" | "GAMMA" | "LOG_NORMAL";
  /**
   * The weight is only used in multiple component scenarios.
   */
  weight?: number;
}

/**
 * NEXT_TAG: 13
 */
export interface CrawlerChangerateUrlChange {
  /**
   * Duplicate UrlChanges crawled within a specified time range will be merged
   * together. UrlChanges are considered duplicates if the simhash,
   * simhash_is_trusted, simhash_v2, simhash_v2_is_trusted, and shingle_simhash
   * are the same. additional_changes_merged indiciates the number of duplicate
   * UrlChanges merged into this UrlChange.
   */
  additionalChangesMerged?: number;
  /**
   * Deprecated fields. The fraction of tiles (0 to 1) that changed.
   */
  fractionalTileChange?: number;
  /**
   * The length in seconds of the change.
   */
  interval?: number;
  /**
   * Whether the content of the off-domain links changed.
   */
  offDomainLinksChange?: boolean;
  /**
   * The new count of off-domain links, if they changed.
   */
  offDomainLinksCount?: number;
  /**
   * The new count of on-domain links, if the count changed.
   */
  onDomainLinksCount?: number;
  /**
   * Whether the number of on-domain links changed.
   */
  onDomainLinksCountChange?: boolean;
  /**
   * The old simhash value obtained from shingles.
   */
  shingleSimhash?: IndexingConverterShingleFingerprint;
  /**
   * The simhash-v1 value. Use of simhash-v1 is deprecated, and newer UrlChange
   * should only contain simhash-v2. During this transition period, UrlChange
   * can contain either simhash or simhash_v2. It is possible that previous
   * UrlChange only contain simhash-v1 and the next UrlChange only contain
   * simhash-v2. In this case, we skip that interval in our changerate
   * computation. [go/changerate-simhash-v2-migration]
   */
  simhash?: bigint;
  /**
   * Whether the simhash-v1 should be trusted.
   */
  simhashIsTrusted?: boolean;
  /**
   * The simhash-v2 value.
   */
  simhashV2?: bigint;
  /**
   * Whether the simhash-v2 value should be trusted.
   */
  simhashV2IsTrusted?: boolean;
}

function serializeCrawlerChangerateUrlChange(data: any): CrawlerChangerateUrlChange {
  return {
    ...data,
    shingleSimhash: data["shingleSimhash"] !== undefined ? serializeIndexingConverterShingleFingerprint(data["shingleSimhash"]) : undefined,
    simhash: data["simhash"] !== undefined ? String(data["simhash"]) : undefined,
    simhashV2: data["simhashV2"] !== undefined ? String(data["simhashV2"]) : undefined,
  };
}

function deserializeCrawlerChangerateUrlChange(data: any): CrawlerChangerateUrlChange {
  return {
    ...data,
    shingleSimhash: data["shingleSimhash"] !== undefined ? deserializeIndexingConverterShingleFingerprint(data["shingleSimhash"]) : undefined,
    simhash: data["simhash"] !== undefined ? BigInt(data["simhash"]) : undefined,
    simhashV2: data["simhashV2"] !== undefined ? BigInt(data["simhashV2"]) : undefined,
  };
}

/**
 * The next available field number is 22. To access the best estimate of change
 * period, please use GetChangePeriod in predict-change-rate.h to select between
 * this and other change period estimates below.
 */
export interface CrawlerChangerateUrlChangerate {
  /**
   * The approximated posterior distribution.
   */
  approximatedPosterior?: CrawlerChangerateMultipleComponentDistribution;
  /**
   * The "significance" of the average change we saw of this document (from 0
   * to 1). Influenced by content changes. This can be used for prioritizing the
   * crawl (higher significance first).
   */
  averageChangeSignificance?: number;
  /**
   * 
   * ////////////////////////////////////////////////////////////////////////////
   * The classic changerate estimation.
   * ////////////////////////////////////////////////////////////////////////////
   * The classic estimate of change period (in seconds). It is computed by
   * inserted a "fake" change and no-change interval as a prior distribution.
   * This field is generally not used and should NOT be accessed directly. See
   * above for correct method for determining the change period estimate.
   */
  changeperiod?: number;
  /**
   * The confidence (between 0 and 1) in the changeperiod guess.
   */
  confidence?: number;
  /**
   * 
   * ////////////////////////////////////////////////////////////////////////////
   * The changerate estimation based on the global prior.
   * ////////////////////////////////////////////////////////////////////////////
   * The global-based changeperiod. This is our estimate (in seconds) for the
   * average time between changes. It is computed using the new prior method
   * based on global_based_prior_period and the global_based_prior_strength
   * specified below. This is used for computing pattern priors. Use
   * pattern_based_change_period or changeperiod fields for all other purposes.
   */
  globalBasedChangePeriod?: number;
  /**
   * The 'confidence' of the global-based changeperiod. This is the n-th root
   * of the posterior evaluated at MAP point, where n is the number of history
   * intervals. For now, it is hard to interpret the meaning of the absolute
   * values of 'average' posterior cross different sets of data.
   */
  globalBasedChangePeriodConfidence?: number;
  /**
   * The 2 parameters below specify the prior employed in calculating the
   * global_based_change_period. These values are precomputed through an offline
   * analysis and specified via flags.
   */
  globalBasedPriorPeriod?: number;
  globalBasedPriorStrength?: number;
  /**
   * The last time (unix timestamp) we saw a changed copy of the document.
   * Provided iff we have seen the page change.
   */
  lastChanged?: number;
  /**
   * The "significance" of the last change we saw of this document (from 0 to
   * 1). Influenced by content changes, etc. This can be used for prioritizing
   * the crawl (higher significance first).
   */
  lastChangeSignificance?: number;
  /**
   * The last time (unix timestamp) we saw a fetched copy of the document.
   */
  lastFetched?: number;
  /**
   * The number of intervals we've seen for this document (where an interval is
   * two different versions).
   */
  numIntervals?: number;
  /**
   * 
   * ////////////////////////////////////////////////////////////////////////////
   * The changerate estimation based on the pattern prior.
   * ////////////////////////////////////////////////////////////////////////////
   * The pattern-based changeperiod. This is our estimate (in seconds) for the
   * average time between changes. It is calculated based on the
   * pattern_based_prior_period and pattern_based_prior_strength below. This
   * quantity will eventually replace the old changeperiod calculation.
   */
  patternBasedChangePeriod?: number;
  /**
   * The same as global_based_change_period_confidence, except it is computed
   * using pattern based priors.
   */
  patternBasedChangePeriodConfidence?: number;
  /**
   * The lower edge of a confidence interval for the pattern-based change
   * period.
   */
  patternBasedLowerChangePeriod?: number;
  /**
   * The 2 parameters below specify the prior employed in calculating the
   * pattern_based_change_period. These values are calculated in a separate
   * process and looked up based on the URL pattern.
   */
  patternBasedPriorPeriod?: number;
  patternBasedPriorStrength?: number;
  /**
   * The version number of the algorithm, refer to ChangePeriodVersion for more
   * information.
   */
  patternChangePeriodVersion?: number;
  /**
   * 
   * ////////////////////////////////////////////////////////////////////////////
   * Basic information of a document.
   * ////////////////////////////////////////////////////////////////////////////
   * The type of the document determined by crawl histories, refer to TYPE for
   * more information.
   */
  type?: number;
  /**
   * 
   * ////////////////////////////////////////////////////////////////////////////
   * The UGC changerate estimation.
   * ////////////////////////////////////////////////////////////////////////////
   * Information on change period generated from user generated content (UGC)
   * change history.
   */
  ugcChangePeriod?: number;
  ugcChangePeriodConfidence?: number;
}

export interface CrawlerChangerateUrlHistory {
  /**
   * All the changes we've seen for this URL.
   */
  change?: CrawlerChangerateUrlChange[];
  /**
   * The latest version we've seen.
   */
  latestVersion?: CrawlerChangerateUrlVersion;
  /**
   * This field in only set in 'url_history' column of Union repository to
   * avoid having to read CompositeDocs.
   */
  url?: string;
}

function serializeCrawlerChangerateUrlHistory(data: any): CrawlerChangerateUrlHistory {
  return {
    ...data,
    change: data["change"] !== undefined ? data["change"].map((item: any) => (serializeCrawlerChangerateUrlChange(item))) : undefined,
    latestVersion: data["latestVersion"] !== undefined ? serializeCrawlerChangerateUrlVersion(data["latestVersion"]) : undefined,
  };
}

function deserializeCrawlerChangerateUrlHistory(data: any): CrawlerChangerateUrlHistory {
  return {
    ...data,
    change: data["change"] !== undefined ? data["change"].map((item: any) => (deserializeCrawlerChangerateUrlChange(item))) : undefined,
    latestVersion: data["latestVersion"] !== undefined ? deserializeCrawlerChangerateUrlVersion(data["latestVersion"]) : undefined,
  };
}

/**
 * NEXT_TAG: 15
 */
export interface CrawlerChangerateUrlVersion {
  /**
   * Same as the field in UrlChange. This allows us to merge identical
   * UrlVersions into a single UrlVersion.
   */
  additionalChangesMerged?: number;
  /**
   * The content type of the page.
   */
  contentType?: number;
  /**
   * Whether this is an IMS response (a 304, not modified).
   */
  isImsNotModified?: boolean;
  /**
   * The date from the LastModified header, if present.
   */
  lastModified?: number;
  /**
   * The checksum of all the off-domain links on the page.
   */
  offDomainLinksChecksum?: number;
  /**
   * The count of all the off-domain links on the page.
   */
  offDomainLinksCount?: number;
  /**
   * The count of all the on-domain links on the page. We aren't worried about
   * the contents themselves, since they might often change (e.g., session ids).
   * We assume that a change in the number of links is significant, however.
   */
  onDomainLinksCount?: number;
  /**
   * The simhash value obtained from shingles.
   */
  shingleSimhash?: IndexingConverterShingleFingerprint;
  /**
   * The simhash-v1 value. The simhash-v1 is now deprecated and new UrlVersions
   * should only populate simhash-v2. During migration phase from using
   * simhash-v1 to simhash-v2, it is possible that previous UrlChange only
   * contain simhash-v1 and the next UrlChange / UrlVersion could only contain
   * simhash-v2. In this case, we skip that interval in our changerate
   * computation. [go/changerate-simhash-v2-migration]
   */
  simhash?: bigint;
  /**
   * Whether the simhash-v1 should be trusted.
   */
  simhashIsTrusted?: boolean;
  /**
   * The simhash-v2 value.
   */
  simhashV2?: bigint;
  /**
   * Whether the simhash-v2 value should be trusted.
   */
  simhashV2IsTrusted?: boolean;
  /**
   * The tiles of the document body. We use int32s instead of int64s (the norm)
   * in order to save space. Since rare inaccuracy doesn't really matter, we've
   * decided this is an okay tradeoff.
   */
  tile?: number[];
  /**
   * The timestamp we crawled the page.
   */
  timestamp?: number;
}

function serializeCrawlerChangerateUrlVersion(data: any): CrawlerChangerateUrlVersion {
  return {
    ...data,
    shingleSimhash: data["shingleSimhash"] !== undefined ? serializeIndexingConverterShingleFingerprint(data["shingleSimhash"]) : undefined,
    simhash: data["simhash"] !== undefined ? String(data["simhash"]) : undefined,
    simhashV2: data["simhashV2"] !== undefined ? String(data["simhashV2"]) : undefined,
  };
}

function deserializeCrawlerChangerateUrlVersion(data: any): CrawlerChangerateUrlVersion {
  return {
    ...data,
    shingleSimhash: data["shingleSimhash"] !== undefined ? deserializeIndexingConverterShingleFingerprint(data["shingleSimhash"]) : undefined,
    simhash: data["simhash"] !== undefined ? BigInt(data["simhash"]) : undefined,
    simhashV2: data["simhashV2"] !== undefined ? BigInt(data["simhashV2"]) : undefined,
  };
}

export interface CrowdingPerDocData {
  newscluster?: CrowdingPerDocDataNewsCluster[];
}

function serializeCrowdingPerDocData(data: any): CrowdingPerDocData {
  return {
    ...data,
    newscluster: data["newscluster"] !== undefined ? data["newscluster"].map((item: any) => (serializeCrowdingPerDocDataNewsCluster(item))) : undefined,
  };
}

function deserializeCrowdingPerDocData(data: any): CrowdingPerDocData {
  return {
    ...data,
    newscluster: data["newscluster"] !== undefined ? data["newscluster"].map((item: any) => (deserializeCrowdingPerDocDataNewsCluster(item))) : undefined,
  };
}

/**
 * For crowding in news we need to keep data about the last X clustering
 * iterations around.
 */
export interface CrowdingPerDocDataNewsCluster {
  /**
   * Fingerprint combination of all urls in a cluster
   */
  ClusterId?: bigint;
  /**
   * This is the X in the "and X related >>" link on headlines and search
   * results
   */
  ClusterSize?: number;
  /**
   * When was this clustered (needed for keeping last X iterations around and
   * discarding earlier ones)
   */
  ClusterTimeStamp?: number;
}

function serializeCrowdingPerDocDataNewsCluster(data: any): CrowdingPerDocDataNewsCluster {
  return {
    ...data,
    ClusterId: data["ClusterId"] !== undefined ? String(data["ClusterId"]) : undefined,
  };
}

function deserializeCrowdingPerDocDataNewsCluster(data: any): CrowdingPerDocDataNewsCluster {
  return {
    ...data,
    ClusterId: data["ClusterId"] !== undefined ? BigInt(data["ClusterId"]) : undefined,
  };
}

export interface DeepCropIndexing {
  /**
   * Compact representation for indexing, see creatism::CropBitmap for details
   * on the packing format.
   */
  cropBytes?: Uint8Array;
}

function serializeDeepCropIndexing(data: any): DeepCropIndexing {
  return {
    ...data,
    cropBytes: data["cropBytes"] !== undefined ? encodeBase64(data["cropBytes"]) : undefined,
  };
}

function deserializeDeepCropIndexing(data: any): DeepCropIndexing {
  return {
    ...data,
    cropBytes: data["cropBytes"] !== undefined ? decodeBase64(data["cropBytes"] as string) : undefined,
  };
}

export interface DeepCropPixels {
  /**
   * Pixels version of the DeepCropIndexing bytes, this corresponds to the crop
   * box for a given image (based input image size and desired aspect ratio).
   */
  x0?: number;
  x1?: number;
  y0?: number;
  y1?: number;
}

/**
 * NOTE: In segindexer, the docproperties of a document may be reused from a
 * previous cycle if its content is not changed. If you add a new field to
 * DocProperties, make sure it is taken care (i.e., gets copied from a previous
 * cycle to the current document) in CDocProperties::EndDocument().
 */
export interface DocProperties {
  /**
   * The average weighted font size of a term in the doc body
   */
  avgTermWeight?: number;
  /**
   * Missing or meaningless title
   */
  badTitle?: boolean;
  badtitleinfo?: DocPropertiesBadTitleInfo[];
  /**
   * A Language enum value. See: go/language-enum
   */
  languages?: number[];
  /**
   * Leading text information generated by
   * google3/quality/snippets/leadingtext/leadingtext-detector.cc
   */
  leadingtext?: SnippetsLeadingtextLeadingTextInfo;
  numPunctuations?: number;
  numTags?: number;
  /**
   * The number of tokens, tags and punctuations in the tokenized contents.
   * This is an approximation of the number of tokens, tags and punctuations we
   * end up with in mustang, but is inexact since we drop some tokens in mustang
   * and also truncate docs at a max cap.
   */
  numTokens?: number;
  /**
   * The restricts for CSE structured search.
   */
  proseRestrict?: string[];
  restricts?: string[];
  /**
   * The time CDocProperties::StartDocument() is called, encoded as seconds
   * past the epoch (Jan 1, 1970). This value is always refreshed and not
   * reused.
   */
  timestamp?: bigint;
  /**
   * Extracted from the title tag of the content. This is typically extracted
   * by TitleMetaCollector defined at google3/segindexer/title-meta-collector.h.
   * Please see its documentation for the format and other caveats.
   */
  title?: string;
}

function serializeDocProperties(data: any): DocProperties {
  return {
    ...data,
    timestamp: data["timestamp"] !== undefined ? String(data["timestamp"]) : undefined,
  };
}

function deserializeDocProperties(data: any): DocProperties {
  return {
    ...data,
    timestamp: data["timestamp"] !== undefined ? BigInt(data["timestamp"]) : undefined,
  };
}

/**
 * Bad title information.
 */
export interface DocPropertiesBadTitleInfo {
  score?: number;
  type?:  | "NOT_BAD" | "MISSING_OR_MEANINGLESS" | "BOILERPLATE" | "FOREIGN" | "UNREADABLE" | "NAKED" | "NO_QUERY_SUPPORT" | "NO_SITE_INFO";
}

export interface DrishtiDenseFeatureData {
  /**
   * If extra is present it must be of the same length as value.
   */
  extra?: DrishtiFeatureExtra[];
  generalExtra?: DrishtiFeatureExtra;
  /**
   * Dense data.
   */
  value?: number[];
}

export interface DrishtiFeatureExtra {
}

export interface DrishtiFeatureSetData {
  /**
   * Extra information for this particular FeatureSetData (example timestamp of
   * this frame in the video). (Almost never used).
   */
  extra?: DrishtiFeatureExtra[];
  /**
   * The following can have multiple FeatureSetElement(s) Each of these
   * FeatureSetElement correspond to the various feature groups. One concrete
   * example is the way these features are generated - example audio, video or
   * OCR.
   */
  feature?: DrishtiFeatureSetDataFeatureSetElement[];
  /**
   * Labels for this particular FeatureSetData. (Almost never used). Only
   * interesting when you have (for example) frame level labels.
   */
  label?: DrishtiLabelSetElement[];
}

function serializeDrishtiFeatureSetData(data: any): DrishtiFeatureSetData {
  return {
    ...data,
    feature: data["feature"] !== undefined ? data["feature"].map((item: any) => (serializeDrishtiFeatureSetDataFeatureSetElement(item))) : undefined,
    label: data["label"] !== undefined ? data["label"].map((item: any) => (serializeDrishtiLabelSetElement(item))) : undefined,
  };
}

function deserializeDrishtiFeatureSetData(data: any): DrishtiFeatureSetData {
  return {
    ...data,
    feature: data["feature"] !== undefined ? data["feature"].map((item: any) => (deserializeDrishtiFeatureSetDataFeatureSetElement(item))) : undefined,
    label: data["label"] !== undefined ? data["label"].map((item: any) => (deserializeDrishtiLabelSetElement(item))) : undefined,
  };
}

/**
 * A FeatureSetElement stores the features coming from a single group.
 */
export interface DrishtiFeatureSetDataFeatureSetElement {
  dense?: DrishtiDenseFeatureData;
  indexed?: DrishtiIndexedFeatureData;
  /**
   * A name for the feature group: example "AUDIO", "VIDEO", "OCR", etc.
   */
  name?: string;
  quantized?: DrishtiQuantizedDenseFeatureData;
  quantizedByteDense?: DrishtiQuantizedByteDenseFeatureData;
  quantizedByteIndexed?: DrishtiQuantizedByteIndexedFeatureData;
  sparse?: DrishtiSparseFeatureData;
}

function serializeDrishtiFeatureSetDataFeatureSetElement(data: any): DrishtiFeatureSetDataFeatureSetElement {
  return {
    ...data,
    indexed: data["indexed"] !== undefined ? serializeDrishtiIndexedFeatureData(data["indexed"]) : undefined,
    quantized: data["quantized"] !== undefined ? serializeDrishtiQuantizedDenseFeatureData(data["quantized"]) : undefined,
    quantizedByteDense: data["quantizedByteDense"] !== undefined ? serializeDrishtiQuantizedByteDenseFeatureData(data["quantizedByteDense"]) : undefined,
    quantizedByteIndexed: data["quantizedByteIndexed"] !== undefined ? serializeDrishtiQuantizedByteIndexedFeatureData(data["quantizedByteIndexed"]) : undefined,
  };
}

function deserializeDrishtiFeatureSetDataFeatureSetElement(data: any): DrishtiFeatureSetDataFeatureSetElement {
  return {
    ...data,
    indexed: data["indexed"] !== undefined ? deserializeDrishtiIndexedFeatureData(data["indexed"]) : undefined,
    quantized: data["quantized"] !== undefined ? deserializeDrishtiQuantizedDenseFeatureData(data["quantized"]) : undefined,
    quantizedByteDense: data["quantizedByteDense"] !== undefined ? deserializeDrishtiQuantizedByteDenseFeatureData(data["quantizedByteDense"]) : undefined,
    quantizedByteIndexed: data["quantizedByteIndexed"] !== undefined ? deserializeDrishtiQuantizedByteIndexedFeatureData(data["quantizedByteIndexed"]) : undefined,
  };
}

/**
 * This represents a sequence (ordered) of FeatureSetData elements.
 */
export interface DrishtiFeatureSetDataSequence {
  /**
   * FeatureSetData contains the features. In most scenarios, you only have one
   * element. However, multiple elements are appropriate in case of videos where
   * each element may correspond to a frame in the video.
   */
  element?: DrishtiFeatureSetData[];
  /**
   * Some extra information about this FeatureSetDataSequence. (Almost never
   * used).
   */
  extra?: DrishtiFeatureExtra[];
  /**
   * Global (video-level) labels. In most cases, you only have one
   * LabelSetElement. All the labels will be stored in this single
   * LabelSetElement. Scenarios where you may have multiple LabelSetElement(s)
   * is (for example) when you want to differentiate the labels into various
   * sub-groups - eg, central vs relevant, kg-ids vs queries, etc.
   */
  label?: DrishtiLabelSetElement[];
  /**
   * If set, must be same length as element. Each entry is the timestamp in
   * microseconds where the FeatureSetData element was extracted.
   */
  timestamp?: bigint[];
}

function serializeDrishtiFeatureSetDataSequence(data: any): DrishtiFeatureSetDataSequence {
  return {
    ...data,
    element: data["element"] !== undefined ? data["element"].map((item: any) => (serializeDrishtiFeatureSetData(item))) : undefined,
    label: data["label"] !== undefined ? data["label"].map((item: any) => (serializeDrishtiLabelSetElement(item))) : undefined,
    timestamp: data["timestamp"] !== undefined ? data["timestamp"].map((item: any) => (String(item))) : undefined,
  };
}

function deserializeDrishtiFeatureSetDataSequence(data: any): DrishtiFeatureSetDataSequence {
  return {
    ...data,
    element: data["element"] !== undefined ? data["element"].map((item: any) => (deserializeDrishtiFeatureSetData(item))) : undefined,
    label: data["label"] !== undefined ? data["label"].map((item: any) => (deserializeDrishtiLabelSetElement(item))) : undefined,
    timestamp: data["timestamp"] !== undefined ? data["timestamp"].map((item: any) => (BigInt(item))) : undefined,
  };
}

export interface DrishtiIndexedFeatureData {
  /**
   * If extra is present it must be of the same length as index and value.
   */
  extra?: DrishtiFeatureExtra[];
  generalExtra?: DrishtiFeatureExtra;
  /**
   * Indexed data. index and value must be of the same length.
   */
  index?: bigint[];
  value?: number[];
}

function serializeDrishtiIndexedFeatureData(data: any): DrishtiIndexedFeatureData {
  return {
    ...data,
    index: data["index"] !== undefined ? data["index"].map((item: any) => (String(item))) : undefined,
  };
}

function deserializeDrishtiIndexedFeatureData(data: any): DrishtiIndexedFeatureData {
  return {
    ...data,
    index: data["index"] !== undefined ? data["index"].map((item: any) => (BigInt(item))) : undefined,
  };
}

export interface DrishtiLabelSetData {
  extra?: DrishtiFeatureExtra[];
  generalExtra?: DrishtiFeatureExtra;
  targetClass?: bigint[];
  targetClassName?: string[];
  targetValue?: number[];
  targetWeight?: number[];
  /**
   * Weight assigned to this set of labels.
   */
  weight?: number;
}

function serializeDrishtiLabelSetData(data: any): DrishtiLabelSetData {
  return {
    ...data,
    targetClass: data["targetClass"] !== undefined ? data["targetClass"].map((item: any) => (String(item))) : undefined,
  };
}

function deserializeDrishtiLabelSetData(data: any): DrishtiLabelSetData {
  return {
    ...data,
    targetClass: data["targetClass"] !== undefined ? data["targetClass"].map((item: any) => (BigInt(item))) : undefined,
  };
}

export interface DrishtiLabelSetElement {
  label?: DrishtiLabelSetData;
  name?: string;
}

function serializeDrishtiLabelSetElement(data: any): DrishtiLabelSetElement {
  return {
    ...data,
    label: data["label"] !== undefined ? serializeDrishtiLabelSetData(data["label"]) : undefined,
  };
}

function deserializeDrishtiLabelSetElement(data: any): DrishtiLabelSetElement {
  return {
    ...data,
    label: data["label"] !== undefined ? deserializeDrishtiLabelSetData(data["label"]) : undefined,
  };
}

/**
 * Proto message to store quantized dense feature data.
 */
export interface DrishtiQuantizedByteDenseFeatureData {
  /**
   * If extra is present it must be of the same length as value.
   */
  extra?: DrishtiFeatureExtra[];
  generalExtra?: DrishtiFeatureExtra;
  /**
   * Quantized values for the feature.
   */
  value?: Uint8Array;
}

function serializeDrishtiQuantizedByteDenseFeatureData(data: any): DrishtiQuantizedByteDenseFeatureData {
  return {
    ...data,
    value: data["value"] !== undefined ? encodeBase64(data["value"]) : undefined,
  };
}

function deserializeDrishtiQuantizedByteDenseFeatureData(data: any): DrishtiQuantizedByteDenseFeatureData {
  return {
    ...data,
    value: data["value"] !== undefined ? decodeBase64(data["value"] as string) : undefined,
  };
}

/**
 * Proto message to store quantized indexed feature data.
 */
export interface DrishtiQuantizedByteIndexedFeatureData {
  /**
   * If extra is present it must be of the same length as value.
   */
  extra?: DrishtiFeatureExtra[];
  generalExtra?: DrishtiFeatureExtra;
  index?: bigint[];
  /**
   * Quantized values for the feature.
   */
  value?: Uint8Array;
}

function serializeDrishtiQuantizedByteIndexedFeatureData(data: any): DrishtiQuantizedByteIndexedFeatureData {
  return {
    ...data,
    index: data["index"] !== undefined ? data["index"].map((item: any) => (String(item))) : undefined,
    value: data["value"] !== undefined ? encodeBase64(data["value"]) : undefined,
  };
}

function deserializeDrishtiQuantizedByteIndexedFeatureData(data: any): DrishtiQuantizedByteIndexedFeatureData {
  return {
    ...data,
    index: data["index"] !== undefined ? data["index"].map((item: any) => (BigInt(item))) : undefined,
    value: data["value"] !== undefined ? decodeBase64(data["value"] as string) : undefined,
  };
}

export interface DrishtiQuantizedDenseFeatureData {
  /**
   * If extra is present it must be of the same length as value.
   */
  extra?: DrishtiFeatureExtra[];
  generalExtra?: DrishtiFeatureExtra;
  /**
   * Quantized Dense data.
   */
  value?: Uint8Array[];
}

function serializeDrishtiQuantizedDenseFeatureData(data: any): DrishtiQuantizedDenseFeatureData {
  return {
    ...data,
    value: data["value"] !== undefined ? data["value"].map((item: any) => (encodeBase64(item))) : undefined,
  };
}

function deserializeDrishtiQuantizedDenseFeatureData(data: any): DrishtiQuantizedDenseFeatureData {
  return {
    ...data,
    value: data["value"] !== undefined ? data["value"].map((item: any) => (decodeBase64(item as string))) : undefined,
  };
}

export interface DrishtiSparseFeatureData {
  /**
   * If extra is present it must be of the same length as label and value.
   */
  extra?: DrishtiFeatureExtra[];
  generalExtra?: DrishtiFeatureExtra;
  /**
   * Indexed data. label and value must be of the same length.
   */
  label?: string[];
  value?: number[];
}

/**
 * The attributes of encoded thumbnail images. Next id: 7.
 */
export interface DrishtiVesperEncodedThumbnail {
  /**
   * JPEG/WEBP quality factor in range [0,100].
   */
  encodingQuality?: number;
  /**
   * Image encoding type.
   */
  encodingType?:  | "UNKNOWN" | "JPEG" | "WEBP" | "PNG";
  height?: number;
  /**
   * Encoded thumbnail bytes. Prefer this over `image_string` as we are not
   * supposed to store image bytes in a proto string field.
   */
  imageBytes?: Uint8Array;
  /**
   * Please migrate to `image_bytes`.
   */
  imageString?: string;
  /**
   * Thumbnail resolution.
   */
  width?: number;
}

function serializeDrishtiVesperEncodedThumbnail(data: any): DrishtiVesperEncodedThumbnail {
  return {
    ...data,
    imageBytes: data["imageBytes"] !== undefined ? encodeBase64(data["imageBytes"]) : undefined,
  };
}

function deserializeDrishtiVesperEncodedThumbnail(data: any): DrishtiVesperEncodedThumbnail {
  return {
    ...data,
    imageBytes: data["imageBytes"] !== undefined ? decodeBase64(data["imageBytes"] as string) : undefined,
  };
}

/**
 * LINT: LEGACY_NAMES MovingThumbnail is defined as a short video clip that
 * represents the whole video content. Next id: 17.
 */
export interface DrishtiVesperMovingThumbnail {
  /**
   * The begin timestamp in milliseconds.
   */
  beginTimestampMs?: number;
  /**
   * The duration of the moving thumbnail in milliseconds. Note that the
   * duration may not be the difference between begin_timestamp_ms and
   * end_timestamp_ms, esp when the moving thumbnail covers multiple clips from
   * the video.
   */
  durationMs?: number;
  encodedGifAnimation?: Uint8Array;
  /**
   * The encoded video string.
   */
  encodedVideoString?: Uint8Array;
  /**
   * The encoded WebP animation.
   */
  encodedWebpAnimation?: Uint8Array;
  /**
   * The end timestamp in milliseconds.
   */
  endTimestampMs?: number;
  /**
   * Pixel height of the moving thumbnail.
   */
  height?: number;
  /**
   * MovingThumbnail id (e.g., the video id).
   */
  id?: string;
  /**
   * If set, this is the algorithm version used to generate this moving
   * thumbnail.
   */
  movingThumbnailerVersion?:  | "V0" | "V1" | "DEPRECATED_V2" | "DEPRECATED_V3" | "V4" | "V5" | "V6" | "SHORT_PREVIEW_V0" | "LIVE_MOVING_THUMBNAILER" | "MANUAL";
  /**
   * MovingThumbnail name.
   */
  name?:  | "UNKNOWN" | "MQDEFAULT" | "MQDEFAULT_6S" | "LQDEFAULT_6S" | "MQ220P_5S" | "MQDEFAULT_6S_HIGHLIGHT" | "MQDEFAULT_6S_PRE_HIGHLIGHT" | "MQDEFAULT_6S_THIRD_HIGHLIGHT" | "MQDEFAULT_6S_ZOOM_IN" | "SD360P_6S_ZOOM_IN" | "MQDEFAULT_3S" | "MQDEFAULT_6S_480x270" | "MQDEFAULT_1S" | "MQ_SHORTS_PREVIEW" | "HQ_SHORTS_PREVIEW";
  /**
   * The score of the moving thumbnail.
   */
  score?: number;
  scoreComponents?: DrishtiVesperMovingThumbnailScoreComponents;
  /**
   * A set of single frame thumbnails in the MovingThumbnail.
   */
  thumbnails?: DrishtiVesperThumbnail[];
  /**
   * MovingThumbnail type.
   */
  type?:  | "TYPE_UNKNOWN" | "AN_GIF" | "AN_WEBP" | "AN_MP4" | "AN_WEBM";
  /**
   * The actual quality of the Webp animation. Note this value may not be equal
   * to the quality value requested in the animation creator's options. This is
   * because other requirements, such as the max file size, may force the
   * creator to lower the actual quality value.
   */
  webpQualityLevel?: number;
  /**
   * Pixel width of the moving thumbnail.
   */
  width?: number;
}

function serializeDrishtiVesperMovingThumbnail(data: any): DrishtiVesperMovingThumbnail {
  return {
    ...data,
    encodedGifAnimation: data["encodedGifAnimation"] !== undefined ? encodeBase64(data["encodedGifAnimation"]) : undefined,
    encodedVideoString: data["encodedVideoString"] !== undefined ? encodeBase64(data["encodedVideoString"]) : undefined,
    encodedWebpAnimation: data["encodedWebpAnimation"] !== undefined ? encodeBase64(data["encodedWebpAnimation"]) : undefined,
    thumbnails: data["thumbnails"] !== undefined ? data["thumbnails"].map((item: any) => (serializeDrishtiVesperThumbnail(item))) : undefined,
  };
}

function deserializeDrishtiVesperMovingThumbnail(data: any): DrishtiVesperMovingThumbnail {
  return {
    ...data,
    encodedGifAnimation: data["encodedGifAnimation"] !== undefined ? decodeBase64(data["encodedGifAnimation"] as string) : undefined,
    encodedVideoString: data["encodedVideoString"] !== undefined ? decodeBase64(data["encodedVideoString"] as string) : undefined,
    encodedWebpAnimation: data["encodedWebpAnimation"] !== undefined ? decodeBase64(data["encodedWebpAnimation"] as string) : undefined,
    thumbnails: data["thumbnails"] !== undefined ? data["thumbnails"].map((item: any) => (deserializeDrishtiVesperThumbnail(item))) : undefined,
  };
}

/**
 * Sum of individual score components within a moving thumbnail. Used as input
 * for weight fitting.
 */
export interface DrishtiVesperMovingThumbnailScoreComponents {
  audienceRewindRatioScore?: number;
  iconicFaceScore?: number;
  matchingScore?: number;
  motionScore?: number;
  titleMatchingScore?: number;
  videoThumbQualityScore?: number;
}

/**
 * The attributes of a video thumbnail.
 */
export interface DrishtiVesperThumbnail {
  /**
   * Thumbnail dense features
   */
  denseFeatures?: number[];
  /**
   * Thumbnail image as an encoded image. Deprecated, use encoded_thumbnails
   * instead.
   */
  encodedImageString?: string;
  /**
   * Thumbnail image as an encoded image with smaller resolution. Deprecated,
   * use encoded_thumbnails instead.
   */
  encodedImageStringSmall?: string;
  /**
   * Encoded thumbnail images.
   */
  encodedThumbnails?: DrishtiVesperEncodedThumbnail[];
  /**
   * Thumbnail id.
   */
  id?: string;
  /**
   * Text in video thumbnails that was detected by OCR.
   */
  ocrText?: string;
  /**
   * Thumbnail quality scores.
   */
  qualityScores?: DrishtiVesperThumbnailQualityScore[];
  /**
   * If true, this thumbnail should update default thumbnail.
   */
  shouldUpdateDefaultThumbnail?: boolean;
  /**
   * Thumbnailer Version.
   */
  thumbnailerModelVersion?:  | "VERSION_UNKNOWN" | "VERSION_FIRST" | "VERSION_RANDOM" | "VERSION_4" | "VERSION_5" | "VERSION_6" | "VERSION_7" | "VERSION_8" | "VERSION_SHORTS_4" | "VERSION_SHORTS_5" | "VERSION_SHORTS_6" | "VERSION_STORY_4" | "VERSION_STORY_5" | "VERSION_MOVING_4" | "VERSION_MOVING_5" | "VERSION_MOVING_6" | "VERSION_MOVING_SHORTS_0" | "VERSION_MOVING_LIVE_0" | "VERSION_MOVING_MANUAL_0" | "VERSION_LITE_1" | "VERSION_CUSTOM" | "VERSION_REJECTED";
  /**
   * Thumbnail timestamp in milliseconds.
   */
  timestampMs?: number;
  /**
   * Thumbnail type.
   */
  type?:  | "UNKNOWN" | "MAIN_THUMB_CUSTOM" | "MAIN_THUMB_NON_CUSTOM" | "SHOT_THUMB" | "NUMBERED_THUMB" | "KEY_FRAME" | "FRAME" | "AUTO";
  userReportedThumbnail?: DrishtiVesperUserReportUserReportedThumbnail;
  /**
   * All user reported thumbnails of interest.
   */
  userReportedThumbnails?: DrishtiVesperUserReportUserReportedThumbnail[];
  /**
   * Thumbnail version, i.e., the unix time in seconds when the thumbnail was
   * created.
   */
  version?: number;
}

function serializeDrishtiVesperThumbnail(data: any): DrishtiVesperThumbnail {
  return {
    ...data,
    encodedThumbnails: data["encodedThumbnails"] !== undefined ? data["encodedThumbnails"].map((item: any) => (serializeDrishtiVesperEncodedThumbnail(item))) : undefined,
  };
}

function deserializeDrishtiVesperThumbnail(data: any): DrishtiVesperThumbnail {
  return {
    ...data,
    encodedThumbnails: data["encodedThumbnails"] !== undefined ? data["encodedThumbnails"].map((item: any) => (deserializeDrishtiVesperEncodedThumbnail(item))) : undefined,
  };
}

export interface DrishtiVesperThumbnailQualityScore {
  score?: number;
  type?:  | "UNKNOWN" | "PHOTO_QUALITY" | "PAMIR_IMAGE_QUALITY" | "VIDEO_THUMB_QUALITY" | "SALIENCY" | "COMPLEXITY" | "SHARPNESS" | "CLOSE_UP" | "BEEHIVE_QUALITY" | "ICONIC_FACE" | "DUMMY" | "COLORFULNESS" | "MOTION" | "RETENTION_STATS" | "FACIAL_EXPRESSION" | "MATCHING" | "LUCKYSHOT_SHARPNESS" | "SINGLE_FACE_MODULE" | "TITLE_MATCHING" | "FACE_CLUSTERING" | "FACE_MATCHING" | "RACY_SCORE" | "NON_RACY_SCORE" | "SALIENCY_COVERAGE" | "AUDIENCE_WATCH_DATA" | "AUDIENCE_REWATCH_DATA" | "AUDIENCE_REWIND_RATIO" | "AUDIENCE_DROPOFF_RATIO" | "HIGHLIGHT_SCORE" | "JOY_FACE" | "EYE_OPEN" | "FACE_RATIO" | "OCR_RACY_SCORE" | "SHOT_BOUNDARY" | "NIMA" | "FOREGROUND_MOTION_SALIENCY" | "PAGE_QUALITY" | "GLOBAL_MOTION" | "CHAPTER_TITLE_MATCHING" | "DBSCAN_FRAME_CHAPTER_SIMILARITY" | "EYES_NOT_VISIBLY_CLOSED" | "ENGAGINESS" | "MERGED";
}

/**
 * Proto holding values for details about human labels.
 */
export interface DrishtiVesperUserReportHumanLabel {
  racyLevel?:  | "UNKNOWN" | "SAFE" | "BORDERLINE" | "SEXUAL";
}

/**
 * Proto holding values for details about score and the source model.
 */
export interface DrishtiVesperUserReportModelScore {
  modelName?: string;
  score?: number;
}

/**
 * Proto holding values for user reported thumbnails. Next id: 12
 */
export interface DrishtiVesperUserReportUserReportedThumbnail {
  denseFeatures?: number[];
  /**
   * Number of days in which volume is calculated.
   */
  duration?: number;
  humanLabel?: DrishtiVesperUserReportHumanLabel;
  /**
   * Daily aggregared impressions for the reported video.
   */
  impressions?: number;
  /**
   * Whether the thumbnail needs a human label.
   */
  needHumanLabel?: boolean;
  rawHumanLabels?: DrishtiVesperUserReportHumanLabel[];
  reportScore?: DrishtiVesperUserReportModelScore;
  reportType?:  | "UNKNOWN" | "RACY";
  score?: DrishtiVesperUserReportModelScore;
  useCase?:  | "UNKNOWN" | "TRAIN" | "EVAL";
  /**
   * Number of reports.
   */
  volume?: number;
}

/**
 * Video level container for thumbnail with its attributes, e.g., timestamp,
 * id, quality scores, annotations, or features.
 */
export interface DrishtiVesperVideoThumbnail {
  /**
   * Video id.
   */
  id?: string;
  movingThumbnails?: DrishtiVesperMovingThumbnail[];
  thumbnails?: DrishtiVesperThumbnail[];
}

function serializeDrishtiVesperVideoThumbnail(data: any): DrishtiVesperVideoThumbnail {
  return {
    ...data,
    movingThumbnails: data["movingThumbnails"] !== undefined ? data["movingThumbnails"].map((item: any) => (serializeDrishtiVesperMovingThumbnail(item))) : undefined,
    thumbnails: data["thumbnails"] !== undefined ? data["thumbnails"].map((item: any) => (serializeDrishtiVesperThumbnail(item))) : undefined,
  };
}

function deserializeDrishtiVesperVideoThumbnail(data: any): DrishtiVesperVideoThumbnail {
  return {
    ...data,
    movingThumbnails: data["movingThumbnails"] !== undefined ? data["movingThumbnails"].map((item: any) => (deserializeDrishtiVesperMovingThumbnail(item))) : undefined,
    thumbnails: data["thumbnails"] !== undefined ? data["thumbnails"].map((item: any) => (deserializeDrishtiVesperThumbnail(item))) : undefined,
  };
}

/**
 * Deep-linking data is used to construct a deep-link URI for an activity or
 * frame's embed, such that on click, the user is taken to the right place in a
 * mobile app. If the app is not installed, the user is taken to the app store.
 * If not on mobile, an analogous web uri is used.
 */
export interface EmbedsDeepLinkData {
  /**
   * Application ID (or project ID) from Google API Console.
   */
  appId?: bigint;
  /**
   * The data for a Google API Console client is entered by a developer during
   * client registration and is stored in PackagingService.
   */
  client?: EmbedsPackagingServiceClient[];
  /**
   * The ID for non-URL content. Embeds may either have no analogous web
   * presence or prefer a native mobile experience if supported. In the case of
   * no web presence, instead of setting the "url" field of an embed, such
   * developers will set this field and other content fields, e.g. thumbnail,
   * title, description. If set, this field is used to construct the deep-link
   * URI. Note that the native experience is preferred over the web link and the
   * web link is used as a fallback.
   */
  deepLinkId?: string;
  /**
   * Analogous web presence. Used as desktop fallback or when no native link
   * data is present.
   */
  url?: string;
}

function serializeEmbedsDeepLinkData(data: any): EmbedsDeepLinkData {
  return {
    ...data,
    appId: data["appId"] !== undefined ? String(data["appId"]) : undefined,
  };
}

function deserializeEmbedsDeepLinkData(data: any): EmbedsDeepLinkData {
  return {
    ...data,
    appId: data["appId"] !== undefined ? BigInt(data["appId"]) : undefined,
  };
}

/**
 * Represents an embedded object in an update. This is a wrapper class that can
 * contain a single specific item proto in an extension field. Think of it as a
 * base class like `Message` in Java. Each item proto must declare that it
 * extends this proto: message ExampleObject { option (item_type) =
 * EXAMPLE_OBJECT; extend EmbedClientItem { optional ExampleObject
 * example_object = ; } } See go/es-embeds for details.
 */
export interface EmbedsEmbedClientItem {
  /**
   * The canonical ID of the embed. If absent, the canonical ID is equal to the
   * ID; if present, then the canonical ID represents an "equivalence class" of
   * embeds which really refer to the same object. (For example, the URLs
   * http://www.foo.com/ and http://foo.com/ refer to the same object) This
   * field may be updated periodically by background processes.
   */
  canonicalId?: string;
  /**
   * Deep-linking data to take the user to the right place in a mobile app.
   * This is only used for preview and attribution. Links that are specific to a
   * given embed type should live on that specific embed's proto by using Link.
   * See http://goto.google.com/mariana-design.
   */
  deepLinkData?: EmbedsDeepLinkData;
  /**
   * The ID of the embed. This corresponds to the schema.org ID, as represented
   * in the ItemScope.id field.
   */
  id?: string;
  /**
   * The provenance of the embed, populated when the embed originated from a
   * web fetch. The provenance captures information about the web page the embed
   * had originated, like the URL that was retrieved and the retrieved URL's
   * canonical form. This is useful in the case where the URL shared by the URL
   * redirects (e.g., in the case of a shortened URL).
   */
  provenance?: EmbedsProvenance;
  /**
   * The ID used to identify the embed during rendering. This field will match
   * ID, if set, otherwise it will be the ID of the parent activity. This field
   * is only populated on the server for client use and is not persisted to
   * storage.
   */
  renderId?: string;
  /**
   * Signature of the embed, used for verification.
   */
  signature?: string;
  /**
   * Transient generic data that will not be saved on the server.
   */
  transientData?: EmbedsTransientData;
  /**
   * The first value in `type` determines which extension field will be set.
   * When creating an EmbedClientItem, you only need to set the first (primary)
   * type in this field. When the server receives the item, it will populate the
   * full type list using the parent annotations in the ItemType enum.
   */
  type?:  | "UNKNOWN" | "ACTION_V2" | "ADD_ACTION_V2" | "AGGREGATE_RATING_V2" | "ARTICLE_V2" | "ASSESS_ACTION_V2" | "AUDIO_OBJECT_V2" | "BASIC_INTERACTION_V2" | "BLOG_POSTING_V2" | "BLOG_V2" | "BOOK_V2" | "BUY_ACTION_V2" | "CHECK_IN_ACTION_V2" | "CHECKIN_V2" | "COLLEXION_V2" | "COMMENT_ACTION_V2" | "COMMENT_V2" | "COMMUNICATE_ACTION_V2" | "CONSUME_ACTION_V2" | "CREATE_ACTION_V2" | "CREATIVE_WORK_V2" | "DISCOVER_ACTION_V2" | "DOCUMENT_OBJECT_V2" | "DRAWING_OBJECT_V2" | "DRIVE_OBJECT_V2" | "EMOTISHARE_V2" | "ENTRY_POINT_V2" | "EVENT_TIME_V2" | "EVENT_V2" | "FILE_OBJECT_V2" | "FIND_ACTION_V2" | "FINANCIAL_QUOTE_V2" | "FORM_OBJECT_V2" | "GEO_COORDINATES_V2" | "GOOGLE_OFFER_V2" | "HANGOUT_CHAT_MESSAGE" | "HANGOUT_QUOTE" | "HANGOUT_V2" | "HOA_PLUS_EVENT_V2" | "IMAGE_OBJECT_V2" | "INTERACT_ACTION_V2" | "INTERACTION_V2" | "LISTEN_ACTION_V2" | "LOCAL_BUSINESS_V2" | "LOCAL_PLUS_PHOTO_ALBUM_V2" | "MAGAZINE_V2" | "MEDIA_OBJECT_V2" | "MOBILE_APPLICATION_V2" | "MOVIE_V2" | "MUSIC_ALBUM_V2" | "MUSIC_GROUP_V2" | "MUSIC_PLAYLIST_V2" | "MUSIC_RECORDING_V2" | "NEWS_ARTICLE_V2" | "OFFER_V2" | "ORGANIZATION_V2" | "ORGANIZE_ACTION_V2" | "PERSON_V2" | "PLACE_REVIEW_V2" | "PLACE_V2" | "PLAN_ACTION_V2" | "PLAY_MUSIC_ALBUM_V2" | "PLAY_MUSIC_TRACK_V2" | "PLAY_OBJECT_V2" | "PLUS_AUDIO_V2" | "PLUS_EVENT_V2" | "PLUS_MEDIA_COLLECTION_V2" | "PLUS_MEDIA_OBJECT_V2" | "PLUS_PAGE_V2" | "PLUS_PHOTOS_ADDED_TO_COLLECTION_V2" | "PLUS_PHOTO_ALBUM_V2" | "PLUS_PHOTO_COLLECTION_V2" | "PLUS_PHOTO_V2" | "PLUS_POST_V2" | "PLUS_RESHARE_V2" | "PLUS_SOFTWARE_APPLICATION_V2" | "POLL_OPTION_V2" | "POLL_V2" | "POSTAL_ADDRESS_V2" | "PRESENTATION_OBJECT_V2" | "PRODUCT_REVIEW_V2" | "RATING_V2" | "REACT_ACTION_V2" | "RESERVATION_V2" | "RESERVE_ACTION_V2" | "REVIEW_V2" | "REVIEW_ACTION_V2" | "SOFTWARE_APPLICATION_V2" | "SPREADSHEET_OBJECT_V2" | "SQUARE_INVITE_V2" | "SQUARE_V2" | "STICKER_V2" | "STORY_V2" | "THING_V2" | "TRADE_ACTION_V2" | "DEPRECATED_TOUR_OBJECT_V2" | "TV_EPISODE_V2" | "TV_SERIES_V2" | "UPDATE_ACTION_V2" | "VIEW_ACTION_V2" | "VIDEO_OBJECT_V2" | "VIDEO_GALLERY_V2" | "WANT_ACTION_V2" | "WEB_PAGE_V2" | "WRITE_ACTION_V2" | "YOUTUBE_CHANNEL_V2" | "GOOGLE_USER_PHOTO_V2" | "GOOGLE_USER_PHOTO_ALBUM" | "GOOGLE_PHOTO_RECIPE" | "THING" | "CREATIVE_WORK" | "EVENT" | "INTANGIBLE" | "ORGANIZATION" | "PERSON" | "PLACE" | "PRODUCT" | "ARTICLE" | "BLOG_POSTING" | "NEWS_ARTICLE" | "SCHOLARLY_ARTICLE" | "BLOG" | "BOOK" | "COMMENT" | "ITEM_LIST" | "MAP" | "MEDIA_OBJECT" | "AUDIO_OBJECT" | "IMAGE_OBJECT" | "MUSIC_VIDEO_OBJECT" | "VIDEO_OBJECT" | "MOVIE" | "MUSIC_PLAYLIST" | "MUSIC_ALBUM" | "MUSIC_RECORDING" | "PAINTING" | "PHOTOGRAPH" | "RECIPE" | "REVIEW" | "SCULPTURE" | "SOFTWARE_APPLICATION" | "MOBILE_APPLICATION" | "WEB_APPLICATION" | "TV_EPISODE" | "TV_SEASON" | "TV_SERIES" | "WEB_PAGE" | "ABOUT_PAGE" | "CHECKOUT_PAGE" | "COLLECTION_PAGE" | "IMAGE_GALLERY" | "VIDEO_GALLERY" | "CONTACT_PAGE" | "ITEM_PAGE" | "PROFILE_PAGE" | "SEARCH_RESULTS_PAGE" | "WEB_PAGE_ELEMENT" | "SITE_NAVIGATION_ELEMENT" | "TABLE" | "WP_AD_BLOCK" | "WP_FOOTER" | "WP_HEADER" | "WP_SIDEBAR" | "APP_INVITE" | "EMOTISHARE" | "BUSINESS_EVENT" | "CHILDRENS_EVENT" | "COMEDY_EVENT" | "DANCE_EVENT" | "EDUCATION_EVENT" | "FESTIVAL" | "FOOD_EVENT" | "LITERARY_EVENT" | "MUSIC_EVENT" | "SALE_EVENT" | "SOCIAL_EVENT" | "SPORTS_EVENT" | "THEATER_EVENT" | "VISUAL_ARTS_EVENT" | "RESERVATION" | "TRAVEL_EVENT" | "CORPORATION" | "EDUCATIONAL_ORGANIZATION" | "COLLEGE_OR_UNIVERSITY" | "ELEMENTARY_SCHOOL" | "HIGH_SCHOOL" | "MIDDLE_SCHOOL" | "PRESCHOOL" | "SCHOOL" | "GOVERNMENT_ORGANIZATION" | "LOCAL_BUSINESS" | "ANIMAL_SHELTER" | "AUTOMOTIVE_BUSINESS" | "AUTO_BODY_SHOP" | "AUTO_DEALER" | "AUTO_PARTS_STORE" | "AUTO_RENTAL" | "AUTO_REPAIR" | "AUTO_WASH" | "GAS_STATION" | "MOTORCYCLE_DEALER" | "MOTORCYCLE_REPAIR" | "CHILD_CARE" | "DRY_CLEANING_OR_LAUNDRY" | "EMERGENCY_SERVICE" | "FIRE_STATION" | "HOSPITAL" | "POLICE_STATION" | "EMPLOYMENT_AGENGY" | "ENTERTAINMENT_BUSINESS" | "ADULT_ENTERTAINMENT" | "AMUSEMENT_PARK" | "ART_GALLERY" | "CASINO" | "COMEDY_CLUB" | "MOVIE_THEATER" | "NIGHT_CLUB" | "FINANCIAL_SERVICE" | "ACCOUNTING_SERVICE" | "AUTOMATED_TELLER" | "BANK_OR_CREDIT_UNION" | "INSURANCE_AGENCY" | "FOOD_ESTABLISHMENT" | "BAKERY" | "BAR_OR_PUB" | "BREWERY" | "CAFE_OR_COFFEE_SHOP" | "FAST_FOOD_RESTAURANT" | "ICE_CREAM_SHOP" | "RESTAURANT" | "WINERY" | "GOVERNMENT_OFFICE" | "POST_OFFICE" | "HEALTH_AND_BEAUTY_BUSINESS" | "BEAUTY_SALON" | "DAY_SPA" | "HAIR_SALON" | "HEALTH_CLUB" | "NAIL_SALON" | "TATTOO_PARLOR" | "HOME_AND_CONSTRUCTION_BUSINESS" | "ELECTRICIAN" | "GENERAL_CONTRACTOR" | "HVAC_BUSINESS" | "HOUSE_PAINTER" | "LOCKSMITH" | "MOVING_COMPANY" | "PLUMBER" | "ROOFING_CONTRACTOR" | "INTERNET_CAFE" | "LIBRARY" | "LODGING_BUSINESS" | "BED_AND_BREAKFAST" | "HOSTEL" | "HOTEL" | "MOTEL" | "MEDICAL_ORGANIZATION" | "DENTIST" | "MEDICAL_CLINIC" | "OPTICIAN" | "PHARMACY" | "PHYSICIAN" | "VETERINARY_CARE" | "PROFESSIONAL_SERVICE" | "ATTORNEY" | "NOTARY" | "RADIO_STATION" | "REAL_ESTATE_AGENT" | "RECYCLING_CENTER" | "SELF_STORAGE" | "SHOPPING_CENTER" | "SPORTS_ACTIVITY_LOCATION" | "BOWLING_ALLEY" | "EXERCISE_GYM" | "GOLF_COURSE" | "PUBLIC_SWIMMING_POOL" | "SKI_RESORT" | "SPORTS_CLUB" | "STADIUM_OR_ARENA" | "TENNIS_COMPLEX" | "STORE" | "BIKE_STORE" | "BOOK_STORE" | "CLOTHING_STORE" | "COMPUTER_STORE" | "CONVENIENCE_STORE" | "DEPARTMENT_STORE" | "ELECTRONICS_STORE" | "FLORIST" | "FURNITURE_STORE" | "GARDEN_STORE" | "GROCERY_STORE" | "HARDWARE_STORE" | "HOBBY_SHOP" | "HOME_GOODS_STORE" | "JEWELRY_STORE" | "LIQUOR_STORE" | "MENS_CLOTHING_STORE" | "MOBILE_PHONE_STORE" | "MOVIE_RENTAL_STORE" | "MUSIC_STORE" | "OFFICE_EQUIPMENT_STORE" | "OUTLET_STORE" | "PAWN_SHOP" | "PET_STORE" | "SHOE_STORE" | "SPORTING_GOODS_STORE" | "TIRE_SHOP" | "TOY_STORE" | "WHOLESALE_STORE" | "TELEVISION_STATION" | "TOURIST_INFORMATION_CENTER" | "TRAVEL_AGENCY" | "PERFORMING_GROUP" | "MUSIC_GROUP" | "ADMINISTRATIVE_AREA" | "CITY" | "COUNTRY" | "STATE" | "CIVIC_STRUCTURE" | "AIRPORT" | "AQUARIUM" | "BEACH" | "BUS_STATION" | "BUS_STOP" | "CAMPGROUND" | "CEMETERY" | "CREMATORIUM" | "EVENT_VENUE" | "GOVERNMENT_BUILDING" | "CITY_HALL" | "COURTHOUSE" | "DEFENCE_ESTABLISHMENT" | "EMBASSY" | "LEGISLATIVE_BUILDING" | "MUSEUM" | "MUSIC_VENUE" | "PARK" | "PARKING_FACILITY" | "PERFORMING_ARTS_THEATER" | "PLACE_OF_WORSHIP" | "BUDDHIST_TEMPLE" | "CATHOLIC_CHURCH" | "CHURCH" | "HINDU_TEMPLE" | "MOSQUE" | "SYNAGOGUE" | "PLAYGROUND" | "R_V_PARK" | "RESIDENCE" | "APARTMENT_COMPLEX" | "GATED_RESIDENCE_COMMUNITY" | "SINGLE_FAMILY_RESIDENCE" | "TOURIST_ATTRACTION" | "SUBWAY_STATION" | "TAXI_STAND" | "TRAIN_STATION" | "ZOO" | "LANDFORM" | "BODY_OF_WATER" | "CANAL" | "LAKE_BODY_OF_WATER" | "OCEAN_BODY_OF_WATER" | "POND" | "RESERVOIR" | "RIVER_BODY_OF_WATER" | "SEA_BODY_OF_WATER" | "WATERFALL" | "CONTINENT" | "MOUNTAIN" | "VOLCANO" | "LANDMARKS_OR_HISTORICAL_BUILDINGS" | "USER_INTERACTION" | "USER_PLUS_ONES" | "ENUMERATION" | "BOOK_FORMAT_TYPE" | "ITEM_AVAILABILITY" | "OFFER_ITEM_CONDITION" | "JOB_POSTING" | "LANGUAGE" | "OFFER" | "QUANTITY" | "DISTANCE" | "DURATION" | "ENERGY" | "MASS" | "RATING" | "AGGREGATE_RATING" | "STRUCTURED_VALUE" | "CONTACT_POINT" | "POSTAL_ADDRESS" | "GEO_COORDINATES" | "GEO_SHAPE" | "NUTRITION_INFORMATION" | "PRESENTATION_OBJECT" | "DOCUMENT_OBJECT" | "SPREADSHEET_OBJECT" | "FORM_OBJECT" | "DRAWING_OBJECT" | "PLACE_REVIEW" | "FILE_OBJECT" | "PLAY_MUSIC_TRACK" | "PLAY_MUSIC_ALBUM" | "MAGAZINE" | "CAROUSEL_FRAME" | "PLUS_EVENT" | "HANGOUT" | "HANGOUT_BROADCAST" | "HANGOUT_CONSUMER" | "CHECKIN" | "EXAMPLE_OBJECT" | "SQUARE" | "SQUARE_INVITE" | "PLUS_PHOTO" | "PLUS_PHOTO_ALBUM" | "LOCAL_PLUS_PHOTO_ALBUM" | "PRODUCT_REVIEW" | "FINANCIAL_QUOTE" | "DEPRECATED_TOUR_OBJECT" | "PLUS_PAGE" | "GOOGLE_CHART" | "PLUS_PHOTOS_ADDED_TO_COLLECTION" | "RECOMMENDED_PEOPLE" | "PLUS_POST" | "DATE" | "DRIVE_OBJECT_COLLECTION" | "NEWS_MEDIA_ORGANIZATION" | "DYNAMITE_ATTACHMENT_METADATA" | "DYNAMITE_MESSAGE_METADATA"[];
}

function serializeEmbedsEmbedClientItem(data: any): EmbedsEmbedClientItem {
  return {
    ...data,
    deepLinkData: data["deepLinkData"] !== undefined ? serializeEmbedsDeepLinkData(data["deepLinkData"]) : undefined,
    provenance: data["provenance"] !== undefined ? serializeEmbedsProvenance(data["provenance"]) : undefined,
  };
}

function deserializeEmbedsEmbedClientItem(data: any): EmbedsEmbedClientItem {
  return {
    ...data,
    deepLinkData: data["deepLinkData"] !== undefined ? deserializeEmbedsDeepLinkData(data["deepLinkData"]) : undefined,
    provenance: data["provenance"] !== undefined ? deserializeEmbedsProvenance(data["provenance"]) : undefined,
  };
}

/**
 * Developers register a client in Google API Console to get the deep-linking
 * feature on Google+ posts or frames about their apps. The client data is
 * stored in this proto.
 */
export interface EmbedsPackagingServiceClient {
  /**
   * Android app's package name to generate the deep-link URI.
   */
  androidPackageName?: string;
  /**
   * iOS app's App Store ID to generate the App Store URL when app is not
   * installed on device.
   */
  iosAppStoreId?: string;
  /**
   * iOS app's bundle ID to generate the deep-link URI.
   */
  iosBundleId?: string;
  /**
   * Type of Google API Console client.
   */
  type?:  | "ANDROID" | "IOS";
}

/**
 * This field records where the ItemScope was retrieved, if it was created via
 * a web fetch.
 */
export interface EmbedsProvenance {
  /**
   * Annotation blob from Annotation Service.
   */
  annotationBlob?: Uint8Array;
  /**
   * Canonical url of the retrieved_url, if one was resolved during retrieval,
   * for example, if a rel="canonical" link tag was provided in the retrieved
   * web page.
   */
  canonicalUrl?: string;
  /**
   * The url originally passed in the PRS request, which should be used to
   * re-discover the content. Note that this URL may be a forwarding service or
   * link shortener (bit.ly), so it should not be assumed to be canonical, but
   * should be used for navigation back to the original source of the itemscope.
   */
  inputUrl?: string;
  /**
   * Contains exact types as parsed, whether or not we recognized that type at
   * parse time. If an itemscope is created by merging SchemaOrg markup and open
   * graph markup then the first itemtype would be schemaorg type, the second
   * would be open graph and so on. example: http://schema.org/VideoObject,
   * og:video.movie Plain text; usually a URL
   */
  itemtype?: string[];
  /**
   * The server retrieved timestamp (in msec).
   */
  retrievedTimestampMsec?: bigint;
  /**
   * The final URL that was the actual source of the itemscope, after any
   * redirects.
   */
  retrievedUrl?: string;
}

function serializeEmbedsProvenance(data: any): EmbedsProvenance {
  return {
    ...data,
    annotationBlob: data["annotationBlob"] !== undefined ? encodeBase64(data["annotationBlob"]) : undefined,
    retrievedTimestampMsec: data["retrievedTimestampMsec"] !== undefined ? String(data["retrievedTimestampMsec"]) : undefined,
  };
}

function deserializeEmbedsProvenance(data: any): EmbedsProvenance {
  return {
    ...data,
    annotationBlob: data["annotationBlob"] !== undefined ? decodeBase64(data["annotationBlob"] as string) : undefined,
    retrievedTimestampMsec: data["retrievedTimestampMsec"] !== undefined ? BigInt(data["retrievedTimestampMsec"]) : undefined,
  };
}

/**
 * Transient generic data that will not be saved on the server.
 */
export interface EmbedsTransientData {
}

/**
 * An EventId is a 128 bit identifier that uniquely identifies an event, such
 * as a query. The event time recorded to the nearest microsecond, along with
 * information about the process generating the event, ensures that all EventIds
 * are unique. Details of this EventId are described in a design document:
 * http://www/eng/designdocs/sawmill/adlogs.html
 */
export interface EventIdMessage {
  /**
   * process_id is an integer that identifies the process on this machine that
   * generated this event. This id is calculated once when the server generates
   * its first event, and may change if the process is migrated to a different
   * host. This field has a very specific format mandated by the logs collection
   * infrastructure, which is subject to change WITHOUT NOTICE. As of
   * 2013-01-09, this format is: uint32 process_id = (time(NULL) << 24) +
   * (getpid() & 0xFFFFFF); If you are generating an extended_pid directly, you
   * MUST use one of the maintained library implementations in order to generate
   * it properly: C++ //borg/borgletlib:extended_pid; call borg::ExtendedPid()
   * Python //borg/borgletlib/python:pyextendedpid; call ExtendedPid() Go
   * //borg/borgletlib/go:extendedpid; call Get() Java
   * //java/com/google/common/logging; call EventId.getPid() If you think that
   * you need to parse the values of this field, please contact
   * logs-collection-dev@ to discuss your requirement.
   */
  processId?: number;
  /**
   * server_ip is the IPv4 address or http://go/ghostid of the machine running
   * the server that created this event message. This allows us to distinguish
   * between events that occur at the same time on different servers. Format:
   * 10.1.2.3 is stored as 0x0a010203, and GHostId 1 as 0x00000001.
   */
  serverIp?: number;
  /**
   * time_usec is the number of microseconds since the epoch (i.e., since
   * 1970-01-01 00:00:00 UTC) as an int64: 1e6 * (unix time) + microseconds.
   * Applications must ensure that EventIdMessages have increasing times,
   * artificially increasing time_usec to one greater than the previous value if
   * necessary. Alternate implementations were considered: 1. storing unix time
   * and microseconds separately would require a bit more storage, and the
   * convenience of having a single value representing the time seemed more
   * useful than having trivial access to a unix time. 2. storing unix time in
   * the upper 32 bits would allow for more precision - up to 4G events/second,
   * but it wouldn't print nicely as a decimal value and it seems unlikely that
   * any single server would ever sustain more than 1M events/second. 3.
   * Java-compatible time uses millis - this would limit servers to 1000 events
   * per second - too small. Other names for this field were considered,
   * including time, time_stamp, and utime. We felt that including the units in
   * the name would tend to produce more readable code. utime might be
   * interpreted as user time. unix timestamp * 1e6 + microseconds
   */
  timeUsec?: bigint;
}

function serializeEventIdMessage(data: any): EventIdMessage {
  return {
    ...data,
    timeUsec: data["timeUsec"] !== undefined ? String(data["timeUsec"]) : undefined,
  };
}

function deserializeEventIdMessage(data: any): EventIdMessage {
  return {
    ...data,
    timeUsec: data["timeUsec"] !== undefined ? BigInt(data["timeUsec"]) : undefined,
  };
}

/**
 * the extra info response from ascorer used to build snippets in GWS
 * experiments
 */
export interface ExtraSnippetInfoResponse {
  matchinfo?: ExtraSnippetInfoResponseMatchInfo;
  querysubitem?: ExtraSnippetInfoResponseQuerySubitem[];
  tidbit?: ExtraSnippetInfoResponseTidbit[];
}

function serializeExtraSnippetInfoResponse(data: any): ExtraSnippetInfoResponse {
  return {
    ...data,
    matchinfo: data["matchinfo"] !== undefined ? serializeExtraSnippetInfoResponseMatchInfo(data["matchinfo"]) : undefined,
    tidbit: data["tidbit"] !== undefined ? data["tidbit"].map((item: any) => (serializeExtraSnippetInfoResponseTidbit(item))) : undefined,
  };
}

function deserializeExtraSnippetInfoResponse(data: any): ExtraSnippetInfoResponse {
  return {
    ...data,
    matchinfo: data["matchinfo"] !== undefined ? deserializeExtraSnippetInfoResponseMatchInfo(data["matchinfo"]) : undefined,
    tidbit: data["tidbit"] !== undefined ? data["tidbit"].map((item: any) => (deserializeExtraSnippetInfoResponseTidbit(item))) : undefined,
  };
}

export interface ExtraSnippetInfoResponseMatchInfo {
  /**
   * bitvector of query items matching the title
   */
  titleMatches?: bigint;
  /**
   * bitvector of query items matching the url
   */
  urlMatches?: bigint;
  /**
   * bitvector of query items considered by chooser
   */
  weightedItems?: bigint;
}

function serializeExtraSnippetInfoResponseMatchInfo(data: any): ExtraSnippetInfoResponseMatchInfo {
  return {
    ...data,
    titleMatches: data["titleMatches"] !== undefined ? String(data["titleMatches"]) : undefined,
    urlMatches: data["urlMatches"] !== undefined ? String(data["urlMatches"]) : undefined,
    weightedItems: data["weightedItems"] !== undefined ? String(data["weightedItems"]) : undefined,
  };
}

function deserializeExtraSnippetInfoResponseMatchInfo(data: any): ExtraSnippetInfoResponseMatchInfo {
  return {
    ...data,
    titleMatches: data["titleMatches"] !== undefined ? BigInt(data["titleMatches"]) : undefined,
    urlMatches: data["urlMatches"] !== undefined ? BigInt(data["urlMatches"]) : undefined,
    weightedItems: data["weightedItems"] !== undefined ? BigInt(data["weightedItems"]) : undefined,
  };
}

/**
 * A query term, phrase, or synonym. An original query term or phrase is called
 * an "item". Each item may have more than one "subitem" if there are synonyms.
 * In rare cases a subitem may correspond to multiple items, such as the subitem
 * "cia" in the query [central intelligence agency].
 */
export interface ExtraSnippetInfoResponseQuerySubitem {
  /**
   * Additional information from the SnippetQuery.
   */
  isHighlighted?: boolean;
  isOptional?: boolean;
  /**
   * true iff this subitem was an original query term or phrase. Can only be
   * false if want_all_query_subitems == true in the request.
   */
  isOriginal?: boolean;
  /**
   * a bitvector of the query items corresponding to this subitem. Typically
   * only one bit is set, but see comment above.
   */
  items?: number;
  /**
   * text associated with this query item
   */
  text?: string;
  /**
   * the weight of this query item, as calculated by SubitemWeight():
   * https://qwiki.corp.google.com/display/Q/SnippetWeights
   */
  weight?: number;
}

export interface ExtraSnippetInfoResponseTidbit {
  anchorinfo?: ExtraSnippetInfoResponseTidbitAnchorInfo;
  /**
   * For tidbits only: position of tidbit in the document. More specifically,
   * tidbit is found at [begin, end) in the document's tokens.
   */
  begin?: number;
  end?: number;
  /**
   * a bitvector of each query term within this tidbit
   */
  items?: bigint;
  /**
   * the score for this tidbit if there was one this is returned for Snippets
   * and Tidbits and is only meaningful for comparing between objects of the
   * same type (snippet to snippet, tidbit to tidbit)
   */
  score?: number;
  /**
   * the tidbit text, with search terms already highlighted
   */
  text?: string;
  type?:  | "TIDBIT" | "BODY" | "META" | "GWD" | "FULL" | "ANCHOR";
}

function serializeExtraSnippetInfoResponseTidbit(data: any): ExtraSnippetInfoResponseTidbit {
  return {
    ...data,
    items: data["items"] !== undefined ? String(data["items"]) : undefined,
  };
}

function deserializeExtraSnippetInfoResponseTidbit(data: any): ExtraSnippetInfoResponseTidbit {
  return {
    ...data,
    items: data["items"] !== undefined ? BigInt(data["items"]) : undefined,
  };
}

/**
 * this information is specific to anchors and is only returned if type ==
 * ANCHOR
 */
export interface ExtraSnippetInfoResponseTidbitAnchorInfo {
  offdomainCount?: number;
  ondomainCount?: number;
}

export interface FaceIndexing {
  /**
   * Always use image/search/utils/face_proto_util.h for packing and unpacking
   * these values.
   */
  mustangBytes?: Uint8Array;
  mustangBytesVersion?: number;
}

function serializeFaceIndexing(data: any): FaceIndexing {
  return {
    ...data,
    mustangBytes: data["mustangBytes"] !== undefined ? encodeBase64(data["mustangBytes"]) : undefined,
  };
}

function deserializeFaceIndexing(data: any): FaceIndexing {
  return {
    ...data,
    mustangBytes: data["mustangBytes"] !== undefined ? decodeBase64(data["mustangBytes"] as string) : undefined,
  };
}

export interface FatcatCompactBinaryClassification {
  /**
   * Either binary_classifier will be set, using the enum above, or
   * binary_classifier_name will be set, if it is not one of the classifiers in
   * the enum - never both.
   */
  binaryClassifier?:  | "BLOG" | "FORUM" | "LOGIN" | "B2B_OK" | "IMAGES" | "SOCIAL" | "PURCHASING_INTENT" | "PORN" | "ADULTISH" | "VIOLENCE_GORE" | "GOSSIP";
  binaryClassifierName?: string;
  /**
   * A CompactDocClassification will not usually have a weight. For a
   * CompactSiteClassification, this value will be 0...127 corresponding to
   * 0.0...1.0, indicating fraction of the site that this label applies to
   */
  discreteFraction?: number;
}

/**
 * The result of PetacatAnnotator. Each result contains: 1. RephilClusters; 2.
 * At most 5 verticals from each taxonomy, sorted by the probabilities in
 * descending order. 3. Binary classification results about page types and
 * sensitive content. The types of taxonomies include: verticals4, geo,
 * verticals4_geo, products_services, icm_im_audiences and icm_im_audiences_dev.
 */
export interface FatcatCompactDocClassification {
  binary?: FatcatCompactBinaryClassification[];
  clusters?: FatcatCompactRephilClusters;
  epoch?: string;
  langCode?: string;
  /**
   * The id of the Rephil model used to generate the Rephil clusters. If it is
   * absent, Rephil 4 is assumed.
   */
  rephilModelId?: number;
  taxonomic?: FatcatCompactTaxonomicClassification[];
  /**
   * not needed if the url is the sstable / bigtable key used during
   * intermediate processing only
   */
  url?: string;
  /**
   * The relative weight of this doc within a site, typically something like
   * pagerank or navboost impressions. May be a large number (like an actual
   * pageviews estimate), not limited to a small range.
   */
  weight?: bigint;
}

function serializeFatcatCompactDocClassification(data: any): FatcatCompactDocClassification {
  return {
    ...data,
    weight: data["weight"] !== undefined ? String(data["weight"]) : undefined,
  };
}

function deserializeFatcatCompactDocClassification(data: any): FatcatCompactDocClassification {
  return {
    ...data,
    weight: data["weight"] !== undefined ? BigInt(data["weight"]) : undefined,
  };
}

export interface FatcatCompactRephilClusters {
  cluster?: FatcatCompactRephilClustersCluster[];
}

export interface FatcatCompactRephilClustersCluster {
  /**
   * 0...127 corresponds to 0.0 - 1.0
   */
  discreteWeight?: number;
  id?: number;
}

/**
 * A version of this proto for logging is available at
 * cs/symbol:logged_fatcat.LoggedCompactTaxonomicClassification
 */
export interface FatcatCompactTaxonomicClassification {
  category?: FatcatCompactTaxonomicClassificationCategory[];
  classifierVersion?: string;
  /**
   * Either taxonomy will be set, using the enum above, or taxonomy_name will
   * be set (if the taxonomy is not one of the ones in the enum) - never both
   */
  taxonomy?:  | "VERTICALS" | "VERTICALS4" | "VERTICALS4_GEO" | "GEO" | "PRODUCTS_SERVICES" | "ICM_IM_AUDIENCES" | "ICM_IM_AUDIENCES_DEV";
  taxonomyName?: string;
}

/**
 * A taxonomic category. A classification consists of weight (totalling 1.0)
 * distributed among one or more categories.
 */
export interface FatcatCompactTaxonomicClassificationCategory {
  /**
   * go/petacat-faq#how-should-i-interpret-classification-weights Discrete to
   * reduce size. Range is [0,127], corresponding to [0.0,1.0].
   */
  discreteWeight?: number;
  /**
   * The category's ID, e.g. 20 for /Sports in the go/verticals4 taxonomy.
   */
  id?: number;
}

/**
 * http://go/contact-detail-hash.
 */
export interface FocusBackendContactDetailHash {
  type?:  | "UNSPECIFIED" | "PHONE" | "EMAIL";
  /**
   * The hash here will be a 16-bit weak hash to avoid reverse engineering for
   * decoding the actual contact detail. The hash value is computed by the
   * fingerprint of the raw contact detail mod 2^16.
   */
  value?: number;
}

/**
 * A contact pointer that represents a contact
 * (http://go/assistant-contact-id).
 */
export interface FocusBackendContactPointer {
  /**
   * The annotation ID. Annotations are only allowed to point to annotations
   * that do not themselves have a pointer (avoids any possibilty of loops).
   * Cast this field to string in javascript to make it compile in js.
   */
  annotationId?: bigint;
  /**
   * The raw contact ID from an active mobile device of the user.
   */
  deviceRawContactId?: FocusBackendDeviceRawContactId;
  /**
   * The contact ID from the Focus backend. Cast this field to string in
   * javascript to make it compile in js.
   */
  focusContactId?: bigint;
  /**
   * Additional contact ids that are not actively used to match contact
   * pointers to contacts.
   */
  otherContactId?: FocusBackendOtherContactId;
  /**
   * The secondary identifier of contact. It will be used when the primary ID
   * doesn't match any contact.
   */
  secondaryId?: FocusBackendSecondaryContactId;
}

function serializeFocusBackendContactPointer(data: any): FocusBackendContactPointer {
  return {
    ...data,
    annotationId: data["annotationId"] !== undefined ? String(data["annotationId"]) : undefined,
    deviceRawContactId: data["deviceRawContactId"] !== undefined ? serializeFocusBackendDeviceRawContactId(data["deviceRawContactId"]) : undefined,
    focusContactId: data["focusContactId"] !== undefined ? String(data["focusContactId"]) : undefined,
    otherContactId: data["otherContactId"] !== undefined ? serializeFocusBackendOtherContactId(data["otherContactId"]) : undefined,
    secondaryId: data["secondaryId"] !== undefined ? serializeFocusBackendSecondaryContactId(data["secondaryId"]) : undefined,
  };
}

function deserializeFocusBackendContactPointer(data: any): FocusBackendContactPointer {
  return {
    ...data,
    annotationId: data["annotationId"] !== undefined ? BigInt(data["annotationId"]) : undefined,
    deviceRawContactId: data["deviceRawContactId"] !== undefined ? deserializeFocusBackendDeviceRawContactId(data["deviceRawContactId"]) : undefined,
    focusContactId: data["focusContactId"] !== undefined ? BigInt(data["focusContactId"]) : undefined,
    otherContactId: data["otherContactId"] !== undefined ? deserializeFocusBackendOtherContactId(data["otherContactId"]) : undefined,
    secondaryId: data["secondaryId"] !== undefined ? deserializeFocusBackendSecondaryContactId(data["secondaryId"]) : undefined,
  };
}

/**
 * //////////////////// DeviceContactId ////////////////////// Used by Device
 * Contacts only. For more details see go/fbs-support-for-device-contacts.
 */
export interface FocusBackendDeviceContactId {
  /**
   * DeviceContact Id.
   */
  ContactId?: bigint;
  /**
   * Device Id.
   */
  DeviceId?: FocusBackendDeviceId;
}

function serializeFocusBackendDeviceContactId(data: any): FocusBackendDeviceContactId {
  return {
    ...data,
    ContactId: data["ContactId"] !== undefined ? String(data["ContactId"]) : undefined,
    DeviceId: data["DeviceId"] !== undefined ? serializeFocusBackendDeviceId(data["DeviceId"]) : undefined,
  };
}

function deserializeFocusBackendDeviceContactId(data: any): FocusBackendDeviceContactId {
  return {
    ...data,
    ContactId: data["ContactId"] !== undefined ? BigInt(data["ContactId"]) : undefined,
    DeviceId: data["DeviceId"] !== undefined ? deserializeFocusBackendDeviceId(data["DeviceId"]) : undefined,
  };
}

/**
 * //////////////////// DeviceId ////////////////////// Used by Device Contacts
 * only. For more details see go/fbs-support-for-device-contacts.
 */
export interface FocusBackendDeviceId {
  /**
   * The GServices id on Android. See go/android-id.
   */
  AndroidDeviceId?: bigint;
  /**
   * DeviceId.Hash is a SHA256 of some attribute of the user and device. For
   * Android devices: Hash = SHA256(gaia_account_name + “:” + “1” + “:” +
   * (android id - LSB)); For iOS devices: Hash =
   * TOLOWER(HEX(GMCSComputeUserDeviceToken(userId, iOsDeviceId)) For more
   * details see go/client-instance-id.
   */
  Hash?: string;
}

function serializeFocusBackendDeviceId(data: any): FocusBackendDeviceId {
  return {
    ...data,
    AndroidDeviceId: data["AndroidDeviceId"] !== undefined ? String(data["AndroidDeviceId"]) : undefined,
  };
}

function deserializeFocusBackendDeviceId(data: any): FocusBackendDeviceId {
  return {
    ...data,
    AndroidDeviceId: data["AndroidDeviceId"] !== undefined ? BigInt(data["AndroidDeviceId"]) : undefined,
  };
}

/**
 * //////////////////// DeviceRawContactId ////////////////////// Used by
 * Device Contacts Only. The Raw ID as assigned to the original contact on the
 * device. For more details see go/fbs-support-for-device-contacts.
 */
export interface FocusBackendDeviceRawContactId {
  DeviceId?: FocusBackendDeviceId;
  /**
   * Raw ID assigned by the device. Cast this field to string in javascript to
   * make it compile in js.
   */
  RawContactId?: bigint;
}

function serializeFocusBackendDeviceRawContactId(data: any): FocusBackendDeviceRawContactId {
  return {
    ...data,
    DeviceId: data["DeviceId"] !== undefined ? serializeFocusBackendDeviceId(data["DeviceId"]) : undefined,
    RawContactId: data["RawContactId"] !== undefined ? String(data["RawContactId"]) : undefined,
  };
}

function deserializeFocusBackendDeviceRawContactId(data: any): FocusBackendDeviceRawContactId {
  return {
    ...data,
    DeviceId: data["DeviceId"] !== undefined ? deserializeFocusBackendDeviceId(data["DeviceId"]) : undefined,
    RawContactId: data["RawContactId"] !== undefined ? BigInt(data["RawContactId"]) : undefined,
  };
}

/**
 * Additional contact ids that are not actively used to match contact pointers
 * to contacts. There may be overlap with primary or secondary contact ids.
 */
export interface FocusBackendOtherContactId {
  /**
   * Device contact ID, when available: - The annotation points to a device
   * contact, and the device contact id was correctly populated when the
   * annotation was created. Note that the device contact id is populated once
   * per device contact on a device. It is distinct from RawContactId - a single
   * device contact may have multiple raw contact ids. - The annotation points
   * to a Focus contact that was merged with device contact information in
   * Starlight. When the annotation was created, a device contact id was
   * available on the merged person object. - The contact annotation was created
   * from April 2021 onwards. All prior annotations do not populate this field.
   * ContactPointer creation relies on the client caller to correctly populate
   * the device contact id, and does not enforce any assumptions on availability
   * of this field. This field is repeated because in rare cases Starlight may
   * merge device contact information across different devices into a single
   * merged person object. WARNING: Use with extreme caution! This ID is not
   * stable. For more details see go/fbs-support-for-device-contacts.
   */
  deviceContactId?: FocusBackendDeviceContactId[];
}

function serializeFocusBackendOtherContactId(data: any): FocusBackendOtherContactId {
  return {
    ...data,
    deviceContactId: data["deviceContactId"] !== undefined ? data["deviceContactId"].map((item: any) => (serializeFocusBackendDeviceContactId(item))) : undefined,
  };
}

function deserializeFocusBackendOtherContactId(data: any): FocusBackendOtherContactId {
  return {
    ...data,
    deviceContactId: data["deviceContactId"] !== undefined ? data["deviceContactId"].map((item: any) => (deserializeFocusBackendDeviceContactId(item))) : undefined,
  };
}

/**
 * The secondary ID of a contact.
 */
export interface FocusBackendSecondaryContactId {
  /**
   * The hashes of the contact details (e.g. phone number and email address).
   */
  contactDetailHash?: FocusBackendContactDetailHash[];
  /**
   * The contact's full name, not hashed.
   */
  contactName?: string;
  /**
   * The hash of contact's full name, generated using Fingerprint2011(). Cast
   * this field to string in javascript to make it compile in js.
   */
  contactNameHash?: bigint;
}

function serializeFocusBackendSecondaryContactId(data: any): FocusBackendSecondaryContactId {
  return {
    ...data,
    contactNameHash: data["contactNameHash"] !== undefined ? String(data["contactNameHash"]) : undefined,
  };
}

function deserializeFocusBackendSecondaryContactId(data: any): FocusBackendSecondaryContactId {
  return {
    ...data,
    contactNameHash: data["contactNameHash"] !== undefined ? BigInt(data["contactNameHash"]) : undefined,
  };
}

/**
 * Citation contains the information needed to correctly attribute the source
 * of data.
 */
export interface FreebaseCitation {
  /**
   * Mid of the dataset.
   */
  dataset?: string;
  /**
   * If set to true, the citation is required to be displayed when the data is
   * used.
   */
  isAttributionRequired?: boolean;
  /**
   * Name of the project of the data's origin.
   */
  project?: string;
  /**
   * The name of the provider of this information.
   */
  provider?: string;
  /**
   * A human readable statement of attribution.
   */
  statement?: string;
  /**
   * Uri link associated with this data.
   */
  uri?: string;
}

/**
 * An Id contains the identifiers used to reference this topic (entity) in the
 * Knowledge Graph. The Knowledge Graph supports several forms of identifiers: -
 * "mids" (machine ids) that are assigned at creation time, and support a
 * resolution mechanism that tracks topics after they are merged (for more about
 * mids, see go/kg-mid), - "ids" are human-readable ids (HRIDs) that are derived
 * from a namespace hierarchy stored in Knowledge Graph, and a set of rules, -
 * "guids" are low-level ids historically used in Freebase (pre-Knowledge Graph,
 * deprecated). Only the mid and id are supplied here. Note that mids can be
 * converted to guids or uint64s (see //metaweb/util/mid/mid.h).
 */
export interface FreebaseId {
  /**
   * "id" may be a human readable ID (HRID) or a MID. Originally it was
   * intended to always be a human readable ID, but that convention was not
   * always followed so clients should be wary. Not every topic has an id.
   */
  id?: string;
  /**
   * The "mid" should be used whenever a globally unique, primary key into the
   * Knowledge Graph is needed. These keys are always prefixed with the "/m" and
   * "/g", (and more rarely the "/x" and "/t") namespaces, and are alphanumeric
   * strings consisting of lowercase letters excluding vowels, numbers and the
   * underscore character. (Applications should not assume a constant length for
   * these strings as Livegraph reserves the right to extend the number of
   * characters to accommodate more topics.)
   */
  mid?: string;
}

/**
 * Represents a geopoint, which is one of the possible Value types.
 */
export interface FreebaseLatLong {
  latDeg?: number;
  longDeg?: number;
}

/**
 * Represents a measurements, which is one of the possible Value types. A
 * measurement value like "5.2 meter^2 / second" would be represented as:
 * magnitude: 5.2 unit { unit_mid: "/m/mid_for_meter" power: 2 } unit {
 * unit_mid: "/m/mid_for_second" power: -1 }
 */
export interface FreebaseMeasurement {
  magnitude?: number;
  /**
   * Repeated units are interpreted as a product. i.e. (meter ^ 1) * (second ^
   * -2)
   */
  unit?: FreebaseMeasurementUnit[];
}

export interface FreebaseMeasurementUnit {
  power?: number;
  unit?: FreebaseId;
  /**
   * Deprecated fields.
   */
  unitMid?: string;
}

/**
 * List of { predicate, { object } } to be processed as a Nested Struct. Nested
 * Struct can be recursive. NestedStruct.property_value(i).value(j) may have
 * nested_struct field.
 */
export interface FreebaseNestedStruct {
  propertyValue?: FreebasePropertyValue[];
}

function serializeFreebaseNestedStruct(data: any): FreebaseNestedStruct {
  return {
    ...data,
    propertyValue: data["propertyValue"] !== undefined ? data["propertyValue"].map((item: any) => (serializeFreebasePropertyValue(item))) : undefined,
  };
}

function deserializeFreebaseNestedStruct(data: any): FreebaseNestedStruct {
  return {
    ...data,
    propertyValue: data["propertyValue"] !== undefined ? data["propertyValue"].map((item: any) => (deserializeFreebasePropertyValue(item))) : undefined,
  };
}

/**
 * A PropertyValue associates properties with values in the context of a topic.
 */
export interface FreebasePropertyValue {
  /**
   * The id of the property.
   */
  property?: FreebaseId;
  /**
   * Indicates the total values that exist for this property, even if they
   * aren't all present in the value field, due to truncation.
   */
  totalValueCount?: bigint;
  /**
   * The value associated with the property for the containing topic.
   */
  value?: FreebaseValue[];
  /**
   * If ValueStatus is not set at all, the implication is that there are
   * well-known value(s), specified in the "value" field. (It should be
   * considered malformed data to have value_status set when len(values) > 0.)
   */
  valueStatus?:  | "HAS_UNKNOWN_VALUE" | "HAS_NO_VALUE";
}

function serializeFreebasePropertyValue(data: any): FreebasePropertyValue {
  return {
    ...data,
    totalValueCount: data["totalValueCount"] !== undefined ? String(data["totalValueCount"]) : undefined,
    value: data["value"] !== undefined ? data["value"].map((item: any) => (serializeFreebaseValue(item))) : undefined,
  };
}

function deserializeFreebasePropertyValue(data: any): FreebasePropertyValue {
  return {
    ...data,
    totalValueCount: data["totalValueCount"] !== undefined ? BigInt(data["totalValueCount"]) : undefined,
    value: data["value"] !== undefined ? data["value"].map((item: any) => (deserializeFreebaseValue(item))) : undefined,
  };
}

/**
 * A Topic represents a Knowledge Graph entity with its associated properties
 * and their values.
 */
export interface FreebaseTopic {
  /**
   * The id (mid and human-readable id) of the topic. The id will always be
   * present and will contain a mid value for topics in the topic sstable.
   */
  id?: FreebaseId;
  /**
   * The property-value bindings associated with the topic. Note that in the
   * case where a property is relevant to a topic based on its type, but no
   * values of that property are present for the topic, the PropertyValue will
   * simply not appear, rather than being present with a null value, or empty
   * repeated value list.
   */
  propertyValue?: FreebasePropertyValue[];
}

function serializeFreebaseTopic(data: any): FreebaseTopic {
  return {
    ...data,
    propertyValue: data["propertyValue"] !== undefined ? data["propertyValue"].map((item: any) => (serializeFreebasePropertyValue(item))) : undefined,
  };
}

function deserializeFreebaseTopic(data: any): FreebaseTopic {
  return {
    ...data,
    propertyValue: data["propertyValue"] !== undefined ? data["propertyValue"].map((item: any) => (deserializeFreebasePropertyValue(item))) : undefined,
  };
}

/**
 * Values are effectively a union of several possible Knowledge Graph types:
 * simple primitive datatypes such as booleans, integers and floats, references
 * to other Knowledge Graph topics (by id), or "compound values" which are
 * expressed as embedded topics with associated properties and values. Values
 * occur in indexed order (if any).
 */
export interface FreebaseValue {
  /**
   * key, uri, or datetime. Present when value is bool.
   */
  boolValue?: boolean;
  /**
   * Citation data for this value. See: http://go/kg-clap
   */
  citation?: FreebaseCitation;
  /**
   * Compound values are those that contain either a number of simple valued
   * facets (such as a latitude/longitude pair), or "mediator" topics
   * representing multi-dimensional relationships between topics. In both cases
   * we represent them here with an embedded topic, although the topic's
   * identity is somewhat secondary to the property/value pairs it contains.
   * (The identity is still made available so that it can be used to perform
   * updates to that mediator on the Knowledge Graph.)
   */
  compoundValue?: FreebaseTopic;
  /**
   * Deletion provenance for this value.
   */
  deletionProvenance?: StorageGraphBfgTripleProvenance[];
  /**
   * The lang of the display_value field.
   */
  displayLang?: string;
  /**
   * The display value of this value. This is a i18n-aware formatted value if
   * present.
   */
  displayValue?: string;
  /**
   * An optional name for a proto field.
   */
  expectedProto?: string;
  /**
   * Present when value is float.
   */
  floatValue?: number;
  /**
   * Present when value is an id.
   */
  idValue?: FreebaseId;
  /**
   * Index of the value relative to the containing property (if any). Knowledge
   * Graph supports a loose notion of indexing: some non-unique properties may
   * have indices, while others may not. Furthermore, for a single property,
   * some values may have indices (such as the top 5 actors in a film), while
   * others may not (the film's supporting cast). Un-indexed values will appear
   * at the end of the repeated value list. This field contains the index value
   * only when is present in the Knowledge Graph.
   */
  index?: bigint;
  /**
   * Present when value is int.
   */
  intValue?: bigint;
  /**
   * Whenever the value is text with TYPE_TEXT, the lang field is populated
   * with the III LanguageCode associated with the string_value field.
   */
  lang?: string;
  latLongValue?: FreebaseLatLong;
  measurementValue?: FreebaseMeasurement;
  /**
   * Populated if this value holds NestedStruct. 'type' field needs to be set
   * to TYPE_NESTED_STRUCT.
   */
  nestedStruct?: FreebaseNestedStruct;
  /**
   * Provenance for this value.
   */
  provenance?: StorageGraphBfgTripleProvenance[];
  /**
   * Similar to string_value/etc but contains raw bytes.
   */
  rawValue?: Uint8Array;
  /**
   * Present when value is text, enum,
   */
  stringValue?: string;
  subgraphId?: bigint[];
  /**
   * The ISO-8601 timestamp corresponding to when this value was created (when
   * it was written to the Knowledge Graph). Deprecated in favor of
   * timestamp_usec.
   */
  timestamp?: string;
  /**
   * The microsecond timestamp corresponding to when this value was created.
   */
  timestampUsec?: bigint;
  type?:  | "TYPE_NULL" | "TYPE_ID" | "TYPE_TEXT" | "TYPE_ENUM" | "TYPE_KEY" | "TYPE_URI" | "TYPE_DATETIME" | "TYPE_BOOL" | "TYPE_INT" | "TYPE_FLOAT" | "TYPE_COMPOUND" | "TYPE_PROTO" | "TYPE_EXTENSION" | "TYPE_NESTED_STRUCT" | "TYPE_SEMANTIC_REFERENCE" | "TYPE_LAT_LONG" | "TYPE_MEASUREMENT" | "TYPE_HAS_VALUE" | "TYPE_HAS_NO_VALUE";
}

function serializeFreebaseValue(data: any): FreebaseValue {
  return {
    ...data,
    compoundValue: data["compoundValue"] !== undefined ? serializeFreebaseTopic(data["compoundValue"]) : undefined,
    deletionProvenance: data["deletionProvenance"] !== undefined ? data["deletionProvenance"].map((item: any) => (serializeStorageGraphBfgTripleProvenance(item))) : undefined,
    index: data["index"] !== undefined ? String(data["index"]) : undefined,
    intValue: data["intValue"] !== undefined ? String(data["intValue"]) : undefined,
    nestedStruct: data["nestedStruct"] !== undefined ? serializeFreebaseNestedStruct(data["nestedStruct"]) : undefined,
    provenance: data["provenance"] !== undefined ? data["provenance"].map((item: any) => (serializeStorageGraphBfgTripleProvenance(item))) : undefined,
    rawValue: data["rawValue"] !== undefined ? encodeBase64(data["rawValue"]) : undefined,
    subgraphId: data["subgraphId"] !== undefined ? data["subgraphId"].map((item: any) => (String(item))) : undefined,
    timestampUsec: data["timestampUsec"] !== undefined ? String(data["timestampUsec"]) : undefined,
  };
}

function deserializeFreebaseValue(data: any): FreebaseValue {
  return {
    ...data,
    compoundValue: data["compoundValue"] !== undefined ? deserializeFreebaseTopic(data["compoundValue"]) : undefined,
    deletionProvenance: data["deletionProvenance"] !== undefined ? data["deletionProvenance"].map((item: any) => (deserializeStorageGraphBfgTripleProvenance(item))) : undefined,
    index: data["index"] !== undefined ? BigInt(data["index"]) : undefined,
    intValue: data["intValue"] !== undefined ? BigInt(data["intValue"]) : undefined,
    nestedStruct: data["nestedStruct"] !== undefined ? deserializeFreebaseNestedStruct(data["nestedStruct"]) : undefined,
    provenance: data["provenance"] !== undefined ? data["provenance"].map((item: any) => (deserializeStorageGraphBfgTripleProvenance(item))) : undefined,
    rawValue: data["rawValue"] !== undefined ? decodeBase64(data["rawValue"] as string) : undefined,
    subgraphId: data["subgraphId"] !== undefined ? data["subgraphId"].map((item: any) => (BigInt(item))) : undefined,
    timestampUsec: data["timestampUsec"] !== undefined ? BigInt(data["timestampUsec"]) : undefined,
  };
}

/**
 * Next id: 127
 */
export interface GDocumentBase {
  content?: GDocumentBaseContent;
  /**
   * unix secs from epoch
   */
  ContentExpiryTime?: number;
  directory?: GDocumentBaseDirectory[];
  /**
   * Sometimes the URL displayed in search results should be different from
   * what gets indexed (e.g. in enterprise, content management systems). If this
   * value is not set, we default to the regular URL.
   */
  DisplayUrl?: string;
  /**
   * 64-bit docid of the document (usually fingerprint of URL, but not always).
   * WARNING: This does NOT uniquely identify a document ANYMORE. For a unique
   * identifier across all documents in production please refer to the field
   * 'id().key()' listed above.
   */
  DocId?: bigint;
  /**
   * 96-bit fingerprint of the canonical url's webmirror equivalence class name
   * as of when this cdoc was exported.
   */
  ecnFp?: Uint8Array;
  ExternalFeedMetadata?: string;
  /**
   * Enterprise-specific external metadata. See
   * http://engdoc/eng/designdocs/enterprise/enterprise_indexing_metadata.html
   */
  ExternalHttpMetadata?: string;
  /**
   * Deprecated, do not use, this field is not populated since 2012.
   */
  FilterForSafeSearch?: number;
  /**
   * The primary identifier of a production document is the document key given
   * in the ServingDocumentIdentifier, which is the same as the row-key in
   * Alexandria, and represents a URL and its crawling context. In your
   * production code, please always assume that the document key is the only way
   * to uniquely identify a document. ## Recommended way of reading: const
   * string& doc_key = cdoc.doc().id().key(); ## CHECK(!doc_key.empty()); More
   * background information can be found in
   * google3/indexing/crawler_id/servingdocumentidentifier.proto The
   * ServingDocumentIdentifier uniquely identifies a document in serving and
   * also distinguishes between experimental vs. production documents. The SDI
   * is also used as an input for the union/muppet key generation in serving.
   */
  id?: IndexingCrawlerIdServingDocumentIdentifier;
  /**
   * IP addr in binary (allows for IPv6)
   */
  IPAddr?: Uint8Array;
  /**
   * Localsearch-specific data.
   */
  localsearchDocInfo?: LocalsearchDocInfo;
  NoArchiveReason?: number;
  NoFollowReason?: number;
  NoImageframeOverlayReason?: number;
  NoImageIndexReason?: number;
  /**
   * When these reasons are set to a non zero value, the document should not be
   * indexed, or show a snippet, or show a cache, etc. These reasons are bit
   * maps of indexing.converter.RobotsInfo.RobotedReasons enum values reflecting
   * the places where the restriction was found.
   */
  NoIndexReason?: number;
  NoPreviewReason?: number;
  NoSnippetReason?: number;
  NoTranslateReason?: number;
  /**
   * Ocean-specific data.
   */
  oceanDocInfo?: OceanDocInfo;
  originalcontent?: GDocumentBaseOriginalContent;
  /**
   * Pagerank for doc (if known)
   */
  Pagerank?: number;
  /**
   * Pagerank-NearestSeeds is an alternative pagerank score for the doc.
   */
  PagerankNS?: number;
  /**
   * is the webmirror representative id of the canonical url. Urls with the
   * same repid are considered as dups in webmirror. WARNING: use this field
   * with caution! The webmirror duprules change frequently, so this value only
   * reflects the duprules at the time when the canonical's docjoin is built.
   */
  Repid?: Uint8Array;
  /**
   * Citation data for science articles.
   */
  ScienceMetadata?: ScienceCitation;
  /**
   * WARNING: the URL does NOT uniquely identify a document ANYMORE. For a
   * unique identifier across all documents in production please refer to the
   * field 'id().key()' listed above. Reason: foo.bar:/http and
   * foo.bar:/http:SMARTPHONE share the same URL, but the body of the two
   * documents might differ because of different crawl-context (desktop vs.
   * smartphone in this example).
   */
  URL?: string;
  URLAfterRedirects?: string;
  /**
   * See webutil/urlencoding
   */
  URLEncoding?: number;
  /**
   * The user agent name used to crawl the URL. See
   * //crawler/engine/webmirror_user_agents.h for the list of user-agents (e.g.
   * crawler::WebmirrorUserAgents::kGoogleBot). NOTE: This field is copied from
   * the first WEBMIRROR FetchReplyClientInfo in trawler_fetch_info column. We
   * leave this field unpopulated if no WEBMIRROR FecthReplyClientInfo is found.
   * As the submission of cl/51488336, Alexandria starts to populate this field.
   * However, docjoins from freshdocs (or any other source), won't have this
   * field populated, because we believe no one needs to read this field from
   * freshdocs docjoins.
   */
  userAgentName?: string;
}

function serializeGDocumentBase(data: any): GDocumentBase {
  return {
    ...data,
    content: data["content"] !== undefined ? serializeGDocumentBaseContent(data["content"]) : undefined,
    DocId: data["DocId"] !== undefined ? String(data["DocId"]) : undefined,
    ecnFp: data["ecnFp"] !== undefined ? encodeBase64(data["ecnFp"]) : undefined,
    IPAddr: data["IPAddr"] !== undefined ? encodeBase64(data["IPAddr"]) : undefined,
    oceanDocInfo: data["oceanDocInfo"] !== undefined ? serializeOceanDocInfo(data["oceanDocInfo"]) : undefined,
    Repid: data["Repid"] !== undefined ? encodeBase64(data["Repid"]) : undefined,
    ScienceMetadata: data["ScienceMetadata"] !== undefined ? serializeScienceCitation(data["ScienceMetadata"]) : undefined,
  };
}

function deserializeGDocumentBase(data: any): GDocumentBase {
  return {
    ...data,
    content: data["content"] !== undefined ? deserializeGDocumentBaseContent(data["content"]) : undefined,
    DocId: data["DocId"] !== undefined ? BigInt(data["DocId"]) : undefined,
    ecnFp: data["ecnFp"] !== undefined ? decodeBase64(data["ecnFp"] as string) : undefined,
    IPAddr: data["IPAddr"] !== undefined ? decodeBase64(data["IPAddr"] as string) : undefined,
    oceanDocInfo: data["oceanDocInfo"] !== undefined ? deserializeOceanDocInfo(data["oceanDocInfo"]) : undefined,
    Repid: data["Repid"] !== undefined ? decodeBase64(data["Repid"] as string) : undefined,
    ScienceMetadata: data["ScienceMetadata"] !== undefined ? deserializeScienceCitation(data["ScienceMetadata"]) : undefined,
  };
}

/**
 * Main content section
 */
export interface GDocumentBaseContent {
  AuthMethod?: number;
  /**
   * The actual length of the content: If Representation is compressed, this
   * equals to Content.UncompressedLength; otherwise it is the length of the
   * representation string.
   */
  ContentLength?: number;
  /**
   * See enum ContentType in //depot/google3/webutil/http/content-type.proto.
   */
  ContentType?: number;
  /**
   * Crawled file size of the original document.
   */
  crawledFileSize?: number;
  /**
   * Seconds since Unix epoch.
   */
  CrawlTime?: bigint;
  /**
   * GeometryAnnotations, encoded with GeometryUtil::DeltaEncode() to reduce
   * disk space usage. Use GeometryUtil::DeltaDecode() to decode this field.
   */
  encodedGeometryAnnotations?: Uint8Array;
  /**
   * See //depot/google3/i18n/encodings/public/encodings.h Encoding of
   * representation
   */
  Encoding?: number;
  /**
   * Set to false if Representation does not contain HTTP headers.
   */
  HasHttpHeader?: boolean;
  /**
   * A Language enum value. See: go/language-enum Default is english
   */
  Language?: number;
  /**
   * If OriginalEncoding is present, the body part of the Representation was
   * converted to UTF-8, Encoding was set to UTF8, and OriginalEncoding was set
   * to the original encoding before conversion. However, the HTTP headers part
   * of the content might not be valid UTF-8. -1=an invalid value
   */
  OriginalEncoding?: number;
  /**
   * Possibly compressed for old documents. It is not compressed for docjoins
   * produced by Raffia after ~2012.
   */
  Representation?: Uint8Array;
  /**
   * Historically present if Representation is compressed.
   */
  UncompressedLength?: number;
  /**
   * Whether the content was visual right-to-left, and if so, what type of
   * visual document it is. Must be one of the values in enum VisualType from
   * google3/repository/rtl/visualtype.h Default is NOT_VISUAL_DOCUMENT. See
   * http://wiki/Main/RtlLanguages for background.
   */
  VisualType?: number;
}

function serializeGDocumentBaseContent(data: any): GDocumentBaseContent {
  return {
    ...data,
    CrawlTime: data["CrawlTime"] !== undefined ? String(data["CrawlTime"]) : undefined,
    encodedGeometryAnnotations: data["encodedGeometryAnnotations"] !== undefined ? encodeBase64(data["encodedGeometryAnnotations"]) : undefined,
    Representation: data["Representation"] !== undefined ? encodeBase64(data["Representation"]) : undefined,
  };
}

function deserializeGDocumentBaseContent(data: any): GDocumentBaseContent {
  return {
    ...data,
    CrawlTime: data["CrawlTime"] !== undefined ? BigInt(data["CrawlTime"]) : undefined,
    encodedGeometryAnnotations: data["encodedGeometryAnnotations"] !== undefined ? decodeBase64(data["encodedGeometryAnnotations"] as string) : undefined,
    Representation: data["Representation"] !== undefined ? decodeBase64(data["Representation"] as string) : undefined,
  };
}

/**
 * The Directory proto group holds snippet and title metadata which is made
 * available to the snippet code. The proto group was originally created for
 * metadata coming from the Google Web Directory (gwd) project. It has since
 * come to be used to hold metadata from gwd and other sources.
 */
export interface GDocumentBaseDirectory {
  /**
   * encoded in UTF8
   */
  Category?: string;
  /**
   * encoded in UTF8
   */
  Description?: string;
  DescriptionScore?: number;
  /**
   * "gwd", etc.
   */
  Identifier?: string;
  /**
   * go/language-enum
   */
  Language?: number;
  /**
   * encoded in UTF8
   */
  Title?: string;
  /**
   * Deprecated; do not use. There is no code populating these fields as of Oct
   * 2017.
   */
  TitleScore?: number;
  URL?: string;
}

/**
 * The original, unconverted document, typically PDF or Word. Copied from
 * OriginalDoc field of doclogs. Unlike "Content", this does not contain any
 * HTTP headers. The content may be compressed using the same method as
 * "Content". In practice it is only compressed in the Teragoogle index. It is
 * never compressed in docjoins because those are compressed at the sstable
 * level. In doclogs content will only be compressed if the Trawler fetchreply
 * is also compressed--which is currently never and unlikely to change for
 * performance reasons.
 */
export interface GDocumentBaseOriginalContent {
  Representation?: string;
  /**
   * present iff rep is compressed
   */
  UncompressedLength?: number;
}

/**
 * The generic version of a snippet response
 */
export interface GenericSnippetResponse {
  /**
   * Per-doc debug information.
   */
  debugInfo?: string[];
  /**
   * Servlet-specific response info.
   */
  info?: Proto2BridgeMessageSet;
  /**
   * Lines of the snippet HTML. Typically gws concatenates these and lets the
   * browser wrap. The values include trailing spaces, so inserting additional
   * spaces is not necessary. However, for very old browsers, gws may insert
   * break tags after each snippet line. This field is confusing and poorly
   * named; "snippet_line" would be better. In particular, note that this does
   * not return multiple snippets for a result. Nor are these fields the
   * individual tidbits of the snippet.
   */
  snippet?: string[];
  /**
   * The title HTML. It may contain tags to denote query term matches. It may
   * be already truncated and "..." is put instead (note that truncation does
   * not always happen at the very end of the title text). However the existence
   * of "..." does not guarantee that the snippet generation algorithm truncated
   * it; e.g. webmasters themselves can write "...".
   */
  title?: string;
  /**
   * Snippet-specific members (tag ids 16+, must be optional!) Example:
   * optional NewContentResponse new_response;
   */
  wwwSnippetResponse?: WWWSnippetResponse;
}

function serializeGenericSnippetResponse(data: any): GenericSnippetResponse {
  return {
    ...data,
    wwwSnippetResponse: data["wwwSnippetResponse"] !== undefined ? serializeWWWSnippetResponse(data["wwwSnippetResponse"]) : undefined,
  };
}

function deserializeGenericSnippetResponse(data: any): GenericSnippetResponse {
  return {
    ...data,
    wwwSnippetResponse: data["wwwSnippetResponse"] !== undefined ? deserializeWWWSnippetResponse(data["wwwSnippetResponse"]) : undefined,
  };
}

/**
 * Actions supported by Madden for a local entity.
 */
export interface GeoOndemandAssistantSupportedActions {
  /**
   * Whether this local entity allows guest checkout for reservations.
   */
  allowsGuestCheckout?: boolean;
  /**
   * Whether or not this local entity supports asynchronous restaurant
   * reservations, through the above restaurant_reservation_url.
   */
  isAsynchronousRestaurantReservation?: boolean;
  /**
   * URL for the Madden restaurant reservation flow, e.g. for display in a
   * WebView. Not populated if restaurant reservations are not supported for the
   * local entity.
   */
  restaurantReservationUrl?: string;
}

/**
 * This class holds information about a single access point. An access point
 * establishes a relationship between a feature (like a POI or building) and
 * some other feature. For example, consider a TYPE_LOCALITY feature like
 * Seattle. An access point might be the TYPE_AIRPORT feature for Seattle-Tacoma
 * International Airport. The airport feature defines the access point to gain
 * airplane-based access to Seattle. A feature like Seattle will typically have
 * multiple access points. You can get to Seattle using airplanes, various forms
 * of public transit, or by driving a car. Thus Seattle would have multiple
 * access points. You may be able to get to Seattle by flying into SeaTac, or
 * you might be able to fly into Boeing Field, or Paine Field in Everett. You
 * could drive in from the North/South using I-5, or you could drive in from the
 * East using I-90. Many access points are from the road network. Thus the
 * access point for some building at 123 Main Street would likely be a segment
 * that defines the 100-200 block of "Main Street". A feature at the corner of
 * "Hollywood" and "Vine" streets might have access points from both named
 * streets. Access points are an optional field. Data editors may ignore them
 * when creating features or editing other fields. In these cases, other quality
 * teams will synthesize and update them. Several fields are also optional, as
 * they are derivable from other fields. Access points to non-TYPE_SEGMENT
 * features should always have the following fields set: - feature_type -
 * feature_id - point Location and reference fields: BASIC vs DERIVABLE Access
 * points to TYPE_SEGMENT features must have all the following BASIC fields: -
 * feature_type (of the segment, e.g. TYPE_ROAD or TYPE_VIRTUAL_SEGMENT) -
 * point_off_segment (or point; see "fuzzy point" note below) -
 * unsuitable_travel_mode (may be empty) - level (indoor access points only) The
 * following are DERIVABLE fields, which should only be added if the supplier is
 * confident about their accuracy: - feature_id - point_on_segment -
 * segment_position Editing clients are encouraged to set all fields, but they
 * may set only the BASIC fields, in which case quality teams may use the BASIC
 * fields to snap to an appropriate segment and derive the remaining fields.
 * Example: The segment is split, so that the portion that the access point is
 * on has a new feature ID. Quality teams notice that the point_on_segment is no
 * longer on the segment with feature_id, finds the new nearest segment based on
 * feature_type and existing point_on_segment, and re-derives a new feature_id,
 * point_on_segment, and segment_position, keeping other fields consistent.
 * Fuzzy point special case If the editor does not have side-of-road information
 * for access points or is otherwise unsure of the precise placement of the
 * access point, it may supply the point field (and not point_off_segment) as
 * basic data instead, in which case quality teams may generate the
 * point_off_segment. Identity Access points are considered semantically
 * equivalent if they have the same geometry, including derived fields, and the
 * same references to other features (feature_id, level_feature_id). For the
 * exact definition, see cs/symbol:geostore::AreAccessPointsEquivalent. Field
 * definitions
 */
export interface GeostoreAccessPointProto {
  /**
   * RESERVED
   */
  canEnter?: boolean;
  /**
   * RESERVED
   */
  canExit?: boolean;
  /**
   * The ID of the feature that defines the access point. The bounding box of
   * the feature is expanded to include the bounding box of the feature with the
   * access point in accordance with the standard practice for bucketing
   * map/reduce operations. See the wiki page at
   * http://wiki/Main/OysterBucketingMapReduce for more information. For access
   * points to TYPE_SEGMENT features, this may be re-derived if necessary by
   * looking up the nearest segment to existing geometry.
   */
  featureId?: GeostoreFeatureIdProto;
  /**
   * The type of the feature. Required, to allow handling the access point
   * differently based on feature type. For access points to non-TYPE_SEGMENT
   * features, this cached type also makes things easier for clients that aren't
   * running a bucketing map-reduce. For access points to TYPE_SEGMENT features,
   * this is used to find to find the nearest segment of the given type.
   */
  featureType?: number;
  /**
   * For indoor access points, this should be set to the level that the access
   * point is on. The feature_id should point to the indoor segment, but when it
   * is missing or invalid, and we need to derive it from geometry, only
   * segments on this level will be considered. For non-indoor access points,
   * level should remain unset, and when we derive feature_id from geometry,
   * only segments not on any level (non-indoor segments) will be considered.
   * The bounding box of the level feature is expanded to include the bounding
   * box of the feature with the access point in accordance with the standard
   * practice for bucketing map/reduce operations. See the wiki page at
   * http://wiki/Main/OysterBucketingMapReduce for more information. (Though in
   * general the feature should reside on the level already anyway..)
   */
  levelFeatureId?: GeostoreFeatureIdProto;
  /**
   * Field-level metadata for this access point.
   */
  metadata?: GeostoreFieldMetadataProto;
  /**
   * For access points to non-TYPE_SEGMENT features, the location of the access
   * point. For access points to TYPE_SEGMENT features, this can be supplied as
   * a fuzzy access point that is not guaranteed to be on the correct side of
   * road. It should not be used by end clients in case of TYPE_SEGMENT access
   * points.
   */
  point?: GeostorePointProto;
  /**
   * If the access point is defined by a TYPE_SEGMENT feature, this is the
   * location of the access point displaced slightly to the correct side of the
   * segment. This offset is in a direction perpendicular to the direction of
   * travel along the segment. The actual offset distance is unspecified. It
   * would typically be relatively small (approximately 1 meter). You can
   * subtract the "off segment" point from the "on segment" point to get a
   * vector of unknown length pointing from "on segment" point to the "off
   * segment" point. You can then scale that vector to whatever length you want.
   * Note that extending this displacement vector a large distance (10s of
   * meters) may result in a new point that is in the middle of some other
   * feature (park, street, intersection). This is the preferred basic geometry
   * field for incoming data from editing clients and importers, if side-of-road
   * is well-established.
   */
  pointOffSegment?: GeostorePointProto;
  /**
   * If the access point is defined by a TYPE_SEGMENT feature, this is the
   * point on the centerline of the segment that is closest to the actual access
   * point. May be re-derived if necessary to maintain precise placement on
   * segment.
   */
  pointOnSegment?: GeostorePointProto;
  /**
   * LINT.ThenChange(//depot/google3/geostore/cleanup/callbacks/\
   * ID_DUPLICATE_ACCESS_POINT.cc)
   */
  priority?:  | "TYPE_PRIMARY" | "TYPE_SECONDARY";
  /**
   * If the access point is defined by a TYPE_SEGMENT feature, this is the
   * location of the access point expressed as a fractional distance along the
   * segment. The value runs from 0 to 1 inclusive. May be re-derived if
   * necessary to maintain precise placement on segment.
   */
  segmentPosition?: number;
  /**
   * This list represents the travel modes for which this access-point should
   * be avoided. If this list is empty, the access-point is suitable for any
   * travel mode. If all access points are unsuitable for the current travel
   * mode, client should revert to other heuristics (e.g. feature center). This
   * is only used for access points to TYPE_SEGMENT features; access points to
   * non-TYPE_SEGMENT features, e.g. TYPE_ESTABLISHMENT_POI features with
   * gcid:transit_station GConcepts are just identified by feature_type and
   * feature_id.
   */
  unsuitableTravelMode?:  | "TRAVEL_MODE_MOTOR_VEHICLE" | "TRAVEL_MODE_AUTO" | "TRAVEL_MODE_TWO_WHEELER" | "TRAVEL_MODE_BICYCLE" | "TRAVEL_MODE_PEDESTRIAN" | "TRAVEL_MODE_PUBLIC_TRANSIT"[];
}

function serializeGeostoreAccessPointProto(data: any): GeostoreAccessPointProto {
  return {
    ...data,
    featureId: data["featureId"] !== undefined ? serializeGeostoreFeatureIdProto(data["featureId"]) : undefined,
    levelFeatureId: data["levelFeatureId"] !== undefined ? serializeGeostoreFeatureIdProto(data["levelFeatureId"]) : undefined,
  };
}

function deserializeGeostoreAccessPointProto(data: any): GeostoreAccessPointProto {
  return {
    ...data,
    featureId: data["featureId"] !== undefined ? deserializeGeostoreFeatureIdProto(data["featureId"]) : undefined,
    levelFeatureId: data["levelFeatureId"] !== undefined ? deserializeGeostoreFeatureIdProto(data["levelFeatureId"]) : undefined,
  };
}

/**
 * This class represents a parsed field within an address. NOTE: if you add a
 * field to this proto, please update the AreAddressComponentsEquivalent()
 * function in google3/geostore/base/internal/addresscomponent.cc
 */
export interface GeostoreAddressComponentProto {
  /**
   * The id of the corresponding Feature, if such a feature is defined. As
   * discussed above for feature_type, components of TYPE_FEATURE or
   * TYPE_LANDMARK may have a corresponding feature id.
   */
  featureId?: GeostoreFeatureIdProto;
  /**
   * For components of TYPE_FEATURE or TYPE_LANDMARK, this is the feature type
   * (TYPE_COUNTRY, TYPE_LOCALITY, TYPE_ESTABLISHMENT_POI etc.). Note that some
   * features may not actually exist in the geostore (e.g. a village that we've
   * never heard of), in which case the feature_id will be missing but the
   * feature_type is still specified. Please refer to
   * IsValidAddressComponentFeatureType() in
   * google3/geostore/base/public/addresscomponent.h for the definitive list of
   * feature types allowed for the type (either TYPE_FEATURE or TYPE_LANDMARK)
   * of components.
   */
  featureType?: number;
  /**
   * The order of this address component relative to the ones that share the
   * same feature_type in the AddressProto. For now, the primary use of this
   * index field is to handle ordering issue of multiple occurrences of
   * AddressComponentProto with feature_type of TYPE_ROUTE (and subtypes), or
   * TYPE_POLITICAL, where the order of the address components matters as there
   * are dependences. 0 is the smallest valid index value, representing the most
   * specific address component. Index value of 1 represents a relatively less
   * specific address component of the same feature_type on which the 0-indexed
   * address component depends.
   */
  index?: number;
  /**
   * The parsed_name field contains one or more names of an address component.
   * Its actual contents depends on where in the Geo/Google stack you are
   * reading a feature: 1. When an address is initially parsed via a feed or
   * other raw input and structured as an AddressProto, parsed_name should
   * contain the set of names that corresponds to the (possibly normalized) raw
   * text from the raw input. 2. In MapFacts, the address component may be
   * linked to an actual feature via feature_id. Any address formatting directly
   * from MapFacts should follow links to retrieve names when possible. The
   * parsed_name contents may be formatted directly if the address component is
   * unlinked following the same rules as selecting and formatting the name of a
   * feature. The cached parsed_name is regularly refreshed from the linked
   * feature with the minimal set of names for address components (usually just
   * a single, preferred name, in the local language, plus a Latin-script name:
   * go/story-of-ac-names). 3. In serving systems, the names of linked features
   * may be denormalized into the parsed_name field to facilitate quicker
   * address formatting or for simple data filtering (e.g. finding all geocodes
   * in California by name). If reading a feature from such a system, the
   * parsed_name field could contain multiple names in multiple languages that
   * reflect a cached copy of the names associated with the linked features.
   * Formatting of such names should follow the same rules as selecting and
   * formatting the name of a feature itself.
   */
  parsedName?: GeostoreNameProto[];
  /**
   * Any numerical address component may optionally be specified as a range.
   * For example if a component of TYPE_STREET_NUMBER has the optional "range"
   * attribute, then it represents a range of addresses rather than a single
   * address (see AddressRangeProto for details).
   */
  range?: GeostoreAddressRangeProto;
  /**
   * A place for clients to attach arbitrary data to an address component.
   * Never set in MapFacts.
   */
  temporaryData?: Proto2BridgeMessageSet;
  /**
   * Additional text to append before and/or after the parsed_name, when the
   * address is formatted. Multiple instance should represent translations.
   * Currently, this is only permitted on TYPE_LANDMARK components, and only one
   * instance is permitted.
   */
  textAffix?: GeostoreTextAffixProto[];
  /**
   * Every address component has a type. Most address components correspond to
   * one of the feature types defined in FeatureProto, so rather than defining a
   * separate category system here, instead we mark them as TYPE_FEATURE and
   * store the FeatureProto type in the feature_type() field. This is how we
   * handle countries, cities, streets, etc. However, there are a few types of
   * address components that do not have a corresponding feature type (e.g. PO
   * boxes). These components have their type defined here. An address component
   * of TYPE_STREET_NUMBER may correspond to a physical entity that defines a
   * street number, such as a geocoded address or a land parcel. In this case,
   * the address component may have a link to the corresponding feature. A good
   * reference for what types of address components are possible is the xAL
   * standard, which is a published XML schema:
   * http://www.oasis-open.org/committees/ciq/download.shtml. This standard is
   * the basis of the PostalAddress protocol message.
   */
  type?:  | "TYPE_FEATURE" | "TYPE_POSTAL_CODE_SUFFIX" | "TYPE_POST_BOX" | "TYPE_STREET_NUMBER" | "TYPE_FLOOR" | "TYPE_ROOM" | "TYPE_HOUSE_ID" | "TYPE_DISTANCE_MARKER" | "TYPE_LANDMARK" | "TYPE_PLUS_CODE";
}

function serializeGeostoreAddressComponentProto(data: any): GeostoreAddressComponentProto {
  return {
    ...data,
    featureId: data["featureId"] !== undefined ? serializeGeostoreFeatureIdProto(data["featureId"]) : undefined,
  };
}

function deserializeGeostoreAddressComponentProto(data: any): GeostoreAddressComponentProto {
  return {
    ...data,
    featureId: data["featureId"] !== undefined ? deserializeGeostoreFeatureIdProto(data["featureId"]) : undefined,
  };
}

/**
 * Represents the unparsed portion of an address with an associated language.
 */
export interface GeostoreAddressLinesProto {
  /**
   * The external form of a Google International Identifiers Initiative (III)
   * LanguageCode object. See google3/i18n/identifiers/languagecode.h for
   * details. We place extra restrictions on languages in addition to what the
   * III library requires. See
   * http://go/geo-schema-reference/feature-properties/languages.md
   */
  language?: string;
  /**
   * These lines are in display order.
   */
  line?: string[];
}

/**
 * This class represents an address, partial address, or address range. It is
 * intended to be attached to features to identify their address(es). Some
 * important points about addresses: - The addresses in the Geo Schema do *not*
 * include a component for the name of the feature, i.e. they are not
 * self-referential. For example, the name of a feature might be "Zack's Pizza"
 * and its address would be "123 Main Street". Similarly, streets, cities, and
 * counties do not include themselves as part of their address. The address of
 * "Seattle" is "King County, Washington, USA". If want to construct an address
 * that *does* include the feature name, you can simply prepend it to the other
 * address components. - Lakes, mountains, and other natural features do not
 * normally have addresses. Countries also do not have addresses because they
 * are at the top of the political hierarchy. - Address components in the Geo
 * Schema are listed in a particular order, independent of the conventions used
 * by the country in which they occur. The basic order is "smallest to largest"
 * starting with street numbers and routes, then political features, and ending
 * with postal features. The exact rules are defined by the implementation of
 * the AddressComponentOrdering::IsLessThan() function. - Some types of address
 * components may occur more than once in an address. For example, a UK address
 * with a "dependent thoroughfare" would have two components of TYPE_ROUTE (i.e.
 * street names). These are listed in the order they are normally written.
 */
export interface GeostoreAddressProto {
  /**
   * The unparsed portion (lines) of the address. An address can have multiple
   * unparsed portions. Multiple unparsed portions sharing the same language
   * should be modeled as one address_lines instance having multiple lines.
   * Historically, we also supported uparsed portions in different languages,
   * but we no longer do. Consequently, only one value is allowed for this field
   * despite the fact that it is repeated. See go/address-lines-multi-language
   * for information about why we made this change. If any components are filled
   * in, this is supplemental to (i.e. disjoint from) them. Furthermore, this
   * must be the most specific portion of the address (except for the portion,
   * if any, stored in the name field of feature.proto). Unparsed lines are
   * always formatted together in a block. Other address components are never
   * formatted between the address lines. This doesn't imply that the address
   * lines are always either the first or the last part of the formatted output.
   */
  addressLines?: GeostoreAddressLinesProto[];
  /**
   * A list of parsed address components, e.g. the street, city, etc. An
   * address range is one type of component.
   */
  component?: GeostoreAddressComponentProto[];
  /**
   * ** DEPRECATED ** This field is now deprecated (see b/33268032). If you
   * want to store cross street information as part of an address, use the
   * address_lines field.
   */
  crossStreet?: GeostoreAddressComponentProto[];
  /**
   * Field-level metadata for this address.
   */
  metadata?: GeostoreFieldMetadataProto;
  /**
   * reserved
   */
  partialDenormalization?: GeostoreAddressProto;
  /**
   * The opaque ID of the address template that contains rules for structuring
   * this address. The id of the address template can be retrieved using
   * google3/geostore/address_templates/public/address_templates.h
   */
  templateId?: string;
  /**
   * A place for clients to attach arbitrary data to an address. Never set in
   * MapFacts.
   */
  temporaryData?: Proto2BridgeMessageSet;
}

function serializeGeostoreAddressProto(data: any): GeostoreAddressProto {
  return {
    ...data,
    component: data["component"] !== undefined ? data["component"].map((item: any) => (serializeGeostoreAddressComponentProto(item))) : undefined,
    crossStreet: data["crossStreet"] !== undefined ? data["crossStreet"].map((item: any) => (serializeGeostoreAddressComponentProto(item))) : undefined,
    partialDenormalization: data["partialDenormalization"] !== undefined ? serializeGeostoreAddressProto(data["partialDenormalization"]) : undefined,
  };
}

function deserializeGeostoreAddressProto(data: any): GeostoreAddressProto {
  return {
    ...data,
    component: data["component"] !== undefined ? data["component"].map((item: any) => (deserializeGeostoreAddressComponentProto(item))) : undefined,
    crossStreet: data["crossStreet"] !== undefined ? data["crossStreet"].map((item: any) => (deserializeGeostoreAddressComponentProto(item))) : undefined,
    partialDenormalization: data["partialDenormalization"] !== undefined ? deserializeGeostoreAddressProto(data["partialDenormalization"]) : undefined,
  };
}

/**
 * This class represents a range of numbers in an address. It is an optional
 * additional field in the 'AddressComponentProto' message. This structure can
 * be used to model both single addresses and address ranges. There are two
 * primary use-cases for address ranges: definitions and references. Ranges are
 * being defined when they are present on the addresses of segment features.
 * Ranges are being referenced when they are present on non-segment features.
 * NOTE: If you add fields in this proto, consider updating the
 * AreAddressRangesEquivalent() function in
 * google3/geostore/base/internal/addressrange.cc
 */
export interface GeostoreAddressRangeProto {
  /**
   * Two or more address numbers. Each number represents an address that was
   * mentioned by the data provider.
   */
  number?: number[];
  /**
   * For address range definitions: Two or more interpolation parameter values.
   * The length of this array must match the length of the number array, and
   * each parameter number specifies the position of the corresponding address
   * number. Each value is an interpolation between 0.0 and 1.0 inclusive. The
   * value is proportional to the distance traveled along the segment's polyline
   * starting at its origin. The parameters must be provided in increasing order
   * and the values in the number array must be in strictly increasing or
   * decreasing order. We make an exception for singleton addresses, which are
   * represented as two copies of a (number, parameter) pair, for backwards
   * compatibility. For address range references: This array must be empty.
   */
  parameter?: number[];
  /**
   * If specified, the prefix or suffix is applied to all numbers in the range.
   * For example, this can be used to indicate that addresses B1 through B99 are
   * on one side of the street, while A1 through A99 are on the other side of
   * the street.
   */
  prefix?: string;
  /**
   * If 'same_parity' is true, then all 'number' values must have the same
   * parity (even or odd), and this address range only includes addresses whose
   * parity is the same as the given 'number' values.
   */
  sameParity?: boolean;
  suffix?: string;
  /**
   * A place for clients to attach arbitrary data to an address range. Never
   * set in MapFacts. Here are some examples: Example #1: Single non-numeric
   * address (e.g., "Twelve") At the moment this can only be represented as a
   * street number (with the value in the parsed_name field of the
   * AddressComponentProto). We have future plans to make other changes so we
   * can handle this case. Example #2: Single semi-numeric address (e.g.,
   * "12bis") The number array contains two copies of the single numeric value
   * (12). The prefix is empty and the suffix contains "bis". The parameter
   * array has two identical values specifying the position of the single
   * address. Example #3: Simple address range (e.g., "100 to 198, even numbers
   * only") The number array contains the two values "100" and "198". The prefix
   * and suffix strings are empty in this example. The parameter array has two
   * values, one for each number. The same_parity flag is set in this example.
   */
  temporaryData?: Proto2BridgeMessageSet;
}

/**
 * A feature’s geometry that is populated from the 3D Geometry Store. Please
 * see go/a3d-and-mapfacts for design details.
 */
export interface GeostoreAnchoredGeometryProto {
  /**
   * The ID to be used to fetch the feature’s geometry from the 3D Geometry
   * Store.
   */
  geometryId?: string;
}

/**
 * A container for speed limits that allows tagging with a correctness trust
 * level.
 */
export interface GeostoreAppliedSpeedLimitProto {
  /**
   * The actual speed limit value.
   */
  speedLimit?: GeostoreSpeedLimitProto;
  /**
   * The level of trust we have in this speed limit value.
   */
  trustLevel?:  | "SPEED_LIMIT_TRUST_LEVEL_UNKNOWN" | "LOW_QUALITY" | "HIGH_QUALITY" | "EXACT";
}

/**
 * An AttachmentProto contains structured data of a client-specified type. An
 * attachment is uniquely identified by the combination of its attachment_id and
 * client_name_space fields.
 */
export interface GeostoreAttachmentsAttachmentProto {
  /**
   * attachment_id distinguishes messages of the same type_id associated with
   * the same feature. It can not be set to 0x0.
   */
  attachmentId?: bigint;
  /**
   * This field specifies a namespace identifier that can be used to track the
   * sources of attachments in a human friendly format. Name spaces must be at
   * most 64 characters long and must be composed entirely of alphanumeric
   * characters, hyphens, and underscores. No other characters are allowed.
   */
  clientNameSpace?: string;
  /**
   * comment is a human-readable string that is logged whenever this attachment
   * is processed by the framework.
   */
  comment?: string;
  /**
   * messages contains the structured data for this attachment. It should
   * contain a single message with a type ID matching the value of the type_id
   * field below.
   */
  messages?: Proto2BridgeMessageSet;
  /**
   * type_id determines the type of the actual attachment that should be set in
   * the messages MessageSet. It can not be set to 0x0.
   */
  typeId?: bigint;
}

function serializeGeostoreAttachmentsAttachmentProto(data: any): GeostoreAttachmentsAttachmentProto {
  return {
    ...data,
    attachmentId: data["attachmentId"] !== undefined ? String(data["attachmentId"]) : undefined,
    typeId: data["typeId"] !== undefined ? String(data["typeId"]) : undefined,
  };
}

function deserializeGeostoreAttachmentsAttachmentProto(data: any): GeostoreAttachmentsAttachmentProto {
  return {
    ...data,
    attachmentId: data["attachmentId"] !== undefined ? BigInt(data["attachmentId"]) : undefined,
    typeId: data["typeId"] !== undefined ? BigInt(data["typeId"]) : undefined,
  };
}

/**
 * Used to represent the unique id of an attribute.
 */
export interface GeostoreAttributeIdProto {
  /**
   * The id of the attribute. Stored as a stripped format of the gcid (e.g.
   * "foo" instead of "gcid:att_foo").
   */
  id?: string;
  /**
   * Set because it's required, but not really meaningful in geostore (always
   * set to "Geo").
   */
  providerId?: string;
  type?:  | "ITEMCLASS" | "ATTRIBUTE" | "VALUESPACE" | "DATASTORE";
}

/**
 * Protocol buffer for attaching attributes and values to instances. This is
 * for assigning a particular attribute and value to a repository item, not for
 * metadata. For protocol buffers that represents metadata about attributes and
 * values, see CanonicalAttribute in itemclass.proto and ValueSpace in
 * valuespace.proto.
 */
export interface GeostoreAttributeProto {
  applicationData?: Proto2BridgeMessageSet;
  attributeDisplay?: GeostoreAttributeValueDisplayProto[];
  booleanValue?: boolean;
  /**
   * The canonical attribute for this attribute instance.
   */
  canonicalAttributeId?: GeostoreAttributeIdProto;
  doubleValue?: number;
  /**
   * For those attribute ids that expect their values to be taken from an
   * enumeration-style set of values, that value's gcid should be stored here,
   * e.g. "gcid:attval_yes".
   */
  enumIdValue?: string;
  floatValue?: number;
  int64Value?: bigint;
  integerValue?: number;
  itemClassId?: GeostoreAttributeIdProto;
  /**
   * Field-level metadata for this attribute
   */
  metadata?: GeostoreFieldMetadataProto;
  /**
   * Fully qualified package name because genprotohdf uses genproto for this
   * proto2 syntax:
   * https://wiki.corp.google.com/twiki/bin/view/Main/Proto2WithGenproto
   */
  protoValue?: Proto2BridgeMessageSet;
  /**
   * The attribute value falls into one of these fields, based on value_type:
   */
  stringValue?: string;
  uint32Value?: number;
  /**
   * Used to store language-specific names of this attribute's value (e.g. a
   * translation into another language).
   */
  valueDisplay?: GeostoreAttributeValueDisplayProto[];
  valueSpaceId?: GeostoreAttributeIdProto;
  valueType?:  | "NONE" | "STRING" | "INTEGER" | "DOUBLE" | "BOOLEAN" | "PROTO_VALUE" | "INT64" | "FLOAT" | "DISPLAY_ONLY" | "UINT32" | "ENUM_ID";
}

function serializeGeostoreAttributeProto(data: any): GeostoreAttributeProto {
  return {
    ...data,
    int64Value: data["int64Value"] !== undefined ? String(data["int64Value"]) : undefined,
  };
}

function deserializeGeostoreAttributeProto(data: any): GeostoreAttributeProto {
  return {
    ...data,
    int64Value: data["int64Value"] !== undefined ? BigInt(data["int64Value"]) : undefined,
  };
}

/**
 * Used to help display language-specific names of attributes.
 */
export interface GeostoreAttributeValueDisplayProto {
  language?: string;
  synonym?: string;
}

export interface GeostoreBarrierLogicalMaterialProto {
  material?:  | "UNKNOWN_LOGICAL_MATERIAL" | "CONCRETE" | "METAL" | "PLASTIC" | "STONE" | "TIMBER"[];
}

/**
 * A BestLocaleProto holds information about the best-match locale for a
 * feature. Clients may use this information to determine the appropriate local
 * name of a feature.
 */
export interface GeostoreBestLocaleProto {
  /**
   * The ID of the best-match TYPE_LOCALE feature for this feature.
   */
  locale?: GeostoreFeatureIdProto;
  /**
   * The ID of the localization policy to apply when selecting a name for a
   * feature. This field should always be set. If feature_id is also defined,
   * this field should have the same localization policy ID as the referenced
   * locale feature. Localization policy IDs are arbitrary identifiers (up to
   * some number of bytes; see geostore/base/public/constants.h) that uniquely
   * distinguish a set of language-selection rules.
   */
  localizationPolicyId?: string;
  /**
   * Field-level metadata for this best locale.
   */
  metadata?: GeostoreFieldMetadataProto;
}

function serializeGeostoreBestLocaleProto(data: any): GeostoreBestLocaleProto {
  return {
    ...data,
    locale: data["locale"] !== undefined ? serializeGeostoreFeatureIdProto(data["locale"]) : undefined,
  };
}

function deserializeGeostoreBestLocaleProto(data: any): GeostoreBestLocaleProto {
  return {
    ...data,
    locale: data["locale"] !== undefined ? deserializeGeostoreFeatureIdProto(data["locale"]) : undefined,
  };
}

/**
 * The reference to a BizBuilder listing. For details on BizBuilder see
 * http://g3doc/commerce/bizbuilder/backend/g3doc/index.md
 */
export interface GeostoreBizBuilderReferenceProto {
  /**
   * Listing id. Used in queries to BizBuilder backend for listing access.
   */
  id?: bigint;
}

function serializeGeostoreBizBuilderReferenceProto(data: any): GeostoreBizBuilderReferenceProto {
  return {
    ...data,
    id: data["id"] !== undefined ? String(data["id"]) : undefined,
  };
}

function deserializeGeostoreBizBuilderReferenceProto(data: any): GeostoreBizBuilderReferenceProto {
  return {
    ...data,
    id: data["id"] !== undefined ? BigInt(data["id"]) : undefined,
  };
}

/**
 * A border represents a line of division between two features of the same type
 * (i.e. United States and Mexico, but not California and Mexico). Borders are
 * only used for features that tile an area. For example, country features have
 * borders with one another because they tile an area of land. Country features
 * do not have borders with province features because those two types of
 * features may intersect with each other. The geometry of a border will often
 * be similar (or derived from) the geometry of the two features that it
 * separates. However, it is useful to have borders represented by stand-alone
 * features for map-styling purposes. Ideally, the geometry in a border feature
 * would be exactly the same as the common edges of the polygonal geometry of
 * the two features. This may not always be true in practice. At some point in
 * the future we would like to build a network of borders for features that are
 * supposed to tile with each other. The network would be composed of different
 * border types meeting at endpoint intersections. In the process of building
 * this network, we would perform small geometry corrections to ensure that the
 * borders align properly at all zoom levels. Border features are intended
 * primarily for map drawing, and they would rarely be useful for geocoding. One
 * exception would be for famous borders like the "Mason Dixon Line" or the
 * "Berlin Wall." The standard feature properties have the following
 * interpretations: name - Borders rarely have names unless they notable in
 * their own right (e.g. "Mason Dixon Line", "Berlin Wall"). point - A border
 * should not have point geometry. polyline - A border should have a single
 * polyline that represents the division between the two features. polygon - A
 * border should not have polygon geometry.
 */
export interface GeostoreBorderProto {
  /**
   * The ids of the area features to the left and right of the border, relative
   * to the start and end of this borders' polyline geometry. These features
   * should have the same type as the "type" attribute above. These ids are not
   * required because the corresponding features may be nonexistent or difficult
   * to obtain.
   */
  featureIdLeft?: GeostoreFeatureIdProto;
  featureIdRight?: GeostoreFeatureIdProto;
  /**
   * The logical borders which this border is a part of.
   */
  logicalBorder?: GeostoreFeatureIdProto[];
  /**
   * List of border status overrides. Due to legal reasons, we may be required
   * to display some borders differently on some domains for instance.
   */
  overrideStatus?: GeostoreOverrideBorderStatusProto[];
  /**
   * The border status identifies the legal status of the border line.
   */
  status?:  | "STATUS_NORMAL" | "STATUS_DISPUTED" | "STATUS_UNSURVEYED" | "STATUS_INTERNATIONAL_WATER" | "STATUS_NEVER_DISPLAY" | "STATUS_TREATY" | "STATUS_PROVISIONAL" | "STATUS_NO_LABEL";
  /**
   * The type of the features this border separates. Should always be a subtype
   * of TYPE_POLITICAL. NOTE: as of December 2019, we currently require this to
   * be equal to TYPE_COUNTRY or TYPE_ADMINISTRATIVE_AREA1. In the future, we
   * may support TYPE_BORDER for lower types of political features.
   */
  type?: number;
}

function serializeGeostoreBorderProto(data: any): GeostoreBorderProto {
  return {
    ...data,
    featureIdLeft: data["featureIdLeft"] !== undefined ? serializeGeostoreFeatureIdProto(data["featureIdLeft"]) : undefined,
    featureIdRight: data["featureIdRight"] !== undefined ? serializeGeostoreFeatureIdProto(data["featureIdRight"]) : undefined,
    logicalBorder: data["logicalBorder"] !== undefined ? data["logicalBorder"].map((item: any) => (serializeGeostoreFeatureIdProto(item))) : undefined,
  };
}

function deserializeGeostoreBorderProto(data: any): GeostoreBorderProto {
  return {
    ...data,
    featureIdLeft: data["featureIdLeft"] !== undefined ? deserializeGeostoreFeatureIdProto(data["featureIdLeft"]) : undefined,
    featureIdRight: data["featureIdRight"] !== undefined ? deserializeGeostoreFeatureIdProto(data["featureIdRight"]) : undefined,
    logicalBorder: data["logicalBorder"] !== undefined ? data["logicalBorder"].map((item: any) => (deserializeGeostoreFeatureIdProto(item))) : undefined,
  };
}

export interface GeostoreBoundingMarkerProto {
  /**
   * References to any gcid:physical_lane_marker features that bound this lane
   * or lane connection.
   */
  boundingMarker?: GeostoreFeatureIdProto;
  /**
   * A token that can be used to identify the version of the data about this
   * bounding marker.
   */
  boundingMarkerToken?: string;
  /**
   * Which part of the flowline does this association refer to? These should be
   * between 0 and 1. These are optionally set, but can be approximated
   * geometrically if they aren’t set. NOTE: These refer to the geometry of this
   * feature.
   */
  flowlineAdjacencyBeginFraction?: number;
  flowlineAdjacencyEndFraction?: number;
  /**
   * Which part of the marker track does this association refer to? These
   * should be between 0 and 1. These are optionally set, but can be
   * approximated geometrically if they aren’t set. NOTE: These refer to the
   * geometry of the marker feature.
   */
  markerAdjacencyBeginFraction?: number;
  markerAdjacencyEndFraction?: number;
  /**
   * Which side of the flowline does the marker occur on.
   */
  side?:  | "UNKNOWN" | "LEFT" | "RIGHT";
}

function serializeGeostoreBoundingMarkerProto(data: any): GeostoreBoundingMarkerProto {
  return {
    ...data,
    boundingMarker: data["boundingMarker"] !== undefined ? serializeGeostoreFeatureIdProto(data["boundingMarker"]) : undefined,
  };
}

function deserializeGeostoreBoundingMarkerProto(data: any): GeostoreBoundingMarkerProto {
  return {
    ...data,
    boundingMarker: data["boundingMarker"] !== undefined ? deserializeGeostoreFeatureIdProto(data["boundingMarker"]) : undefined,
  };
}

/**
 * This protocol buffer holds the building-specific attributes for features of
 * type TYPE_COMPOUND_BUILDING.
 */
export interface GeostoreBuildingProto {
  /**
   * The height of the base of this building, in meters above ground-level, if
   * known.
   */
  baseHeightMetersAgl?: number;
  /**
   * The level in this building that should get displayed by default. If
   * present, the default display level must be one of this building's levels
   * that are listed in the level[] field, and if a level is set as a default
   * level of one building, all buildings sharing the level should have that
   * same level as their default level. If not present, clients should not
   * display any level by default for that building.
   */
  defaultDisplayLevel?: GeostoreFeatureIdProto;
  /**
   * The number of floors above the base of the building, if known. For example
   * a regular 1-story building would set this to "1". Use a value of
   * GeostoreConstants::kDefaultHeightPerFloor when converting "floors" to
   * "height_meters".
   */
  floors?: number;
  floorsMetadata?: GeostoreFieldMetadataProto;
  /**
   * The height of the building above its base, in meters, if known.
   */
  heightMeters?: number;
  heightMetersMetadata?: GeostoreFieldMetadataProto;
  /**
   * The levels in this building, in no particular order. These levels refer
   * back to the building via another strong reference (the LevelProto.building
   * field).
   */
  level?: GeostoreFeatureIdProto[];
  /**
   * "Structure" denotes a physical architecture of the building that is
   * readily visible. This attribute is useful in that rarer structures can make
   * good landmarks.
   */
  structure?:  | "STRUCTURE_ANY" | "STRUCTURE_TOWER" | "STRUCTURE_DOME" | "STRUCTURE_CASTLE" | "STRUCTURE_SHRINE" | "STRUCTURE_TEMPLE" | "STRUCTURE_TANK";
}

function serializeGeostoreBuildingProto(data: any): GeostoreBuildingProto {
  return {
    ...data,
    defaultDisplayLevel: data["defaultDisplayLevel"] !== undefined ? serializeGeostoreFeatureIdProto(data["defaultDisplayLevel"]) : undefined,
    level: data["level"] !== undefined ? data["level"].map((item: any) => (serializeGeostoreFeatureIdProto(item))) : undefined,
  };
}

function deserializeGeostoreBuildingProto(data: any): GeostoreBuildingProto {
  return {
    ...data,
    defaultDisplayLevel: data["defaultDisplayLevel"] !== undefined ? deserializeGeostoreFeatureIdProto(data["defaultDisplayLevel"]) : undefined,
    level: data["level"] !== undefined ? data["level"].map((item: any) => (deserializeGeostoreFeatureIdProto(item))) : undefined,
  };
}

/**
 * This holds data specific to business chain features.
 */
export interface GeostoreBusinessChainProto {
  /**
   * Canonical GConcepts describe the ideal state of the GConcepts of this
   * business chain's members.
   */
  canonicalGconcepts?: GeostoreCanonicalGConceptProto[];
}

/**
 * A BusinessHoursProto stores a weekly schedule of opening hours for a
 * business (represented as a BusinessHours message) together with other closely
 * related information that is Geo-specific.
 */
export interface GeostoreBusinessHoursProto {
  /**
   * The actual hours represented by this BusinessHoursProto.
   */
  data?: BusinessHours;
  /**
   * Field-level metadata for these hours.
   */
  metadata?: GeostoreFieldMetadataProto;
}

/**
 * Message containing calls to action specified by the business owner.
 */
export interface GeostoreCallToActionProto {
  /**
   * Required.
   */
  ctaType?:  | "CTA_TYPE_UNSPECIFIED" | "CTA_TYPE_BOOK" | "CTA_TYPE_BUY" | "CTA_TYPE_ORDER_ONLINE" | "CTA_TYPE_LEARN_MORE" | "CTA_TYPE_SIGN_UP" | "CTA_TYPE_GET_OFFER";
  url?: GeostoreUrlProto;
}

/**
 * This proto represents a canonical gconcept of a business chain's members.
 */
export interface GeostoreCanonicalGConceptProto {
  gconcept?: GeostoreGConceptInstanceProto;
  /**
   * Whether the gconcept must be on a member. This must be true for a primary
   * gconcept.
   */
  isRequired?: boolean;
}

/**
 * This protocol buffer holds S2 cell covering for the feature. See
 * util/geometry/s2cell_union.h for more information on S2 cells. See
 * geostore/base/public/cellcovering.h for utility functions.
 */
export interface GeostoreCellCoveringProto {
  /**
   * Array of S2 cell ids that represent the covering. There is no preset limit
   * on how many cells can be used.
   */
  cellId?: bigint[];
}

function serializeGeostoreCellCoveringProto(data: any): GeostoreCellCoveringProto {
  return {
    ...data,
    cellId: data["cellId"] !== undefined ? data["cellId"].map((item: any) => (String(item))) : undefined,
  };
}

function deserializeGeostoreCellCoveringProto(data: any): GeostoreCellCoveringProto {
  return {
    ...data,
    cellId: data["cellId"] !== undefined ? data["cellId"].map((item: any) => (BigInt(item))) : undefined,
  };
}

/**
 * Generic item proto. This is intended to have only certain aspects filled
 * (e.g. photo only, name + price). Valid combinations of properties are
 * enforced by linters.
 */
export interface GeostoreComposableItemProto {
  /**
   * Call to action for the individual product.
   */
  callToAction?: GeostoreCallToActionProto;
  jobMetadata?: GeostoreJobMetadata;
  /**
   * Any photos describing this item.
   */
  media?: GeostoreMediaItemProto[];
  /**
   * The repeated name_info field is for price list sections listed in multiple
   * languages. At least one name_info containing id must be specified. There
   * should be at most one name_info for any given language. When representing a
   * job item, there should be exactly one name_info specified.
   */
  nameInfo?: GeostorePriceListNameInfoProto[];
  /**
   * Represents if an item is offered at a business. For TYPE_JOB, this
   * represents if this job is offered by the corresponding business
   */
  offered?:  | "OFFERED_UNSPECIFIED" | "OFFERED" | "OFFERED_NOT" | "OFFERED_ON_WEBSITE";
  /**
   * Price of the item. There should be at most one price for any given
   * currency.
   */
  price?: GeostorePriceRangeProto;
  /**
   * Represents which price format is being used by this item, which determines
   * the usage/meaning of the “price” field above. Optional – the default value
   * is legal and safe (represents no price if the “price” field is unset).
   */
  priceFormat?:  | "PRICE_FORMAT_DEFAULT" | "PRICE_FORMAT_VARIES";
  /**
   * Numerical score which can be provided by data sources to indicate
   * preferred item ordering. This is purely a hint – we are not required to
   * followed it if we have a different order we think is better. Higher scores
   * represent items that should be shown more prominently/earlier. Optional.
   */
  rankingHint?: number;
}

function serializeGeostoreComposableItemProto(data: any): GeostoreComposableItemProto {
  return {
    ...data,
    jobMetadata: data["jobMetadata"] !== undefined ? serializeGeostoreJobMetadata(data["jobMetadata"]) : undefined,
  };
}

function deserializeGeostoreComposableItemProto(data: any): GeostoreComposableItemProto {
  return {
    ...data,
    jobMetadata: data["jobMetadata"] !== undefined ? deserializeGeostoreJobMetadata(data["jobMetadata"]) : undefined,
  };
}

/**
 * A count value tagged with a comparison operator. This can be used for axle
 * count, trailer count, etc.
 */
export interface GeostoreCountComparisonProto {
  comparisonOperator?:  | "UNSPECIFIED" | "EQUAL" | "LESS_THAN" | "LESS_THAN_OR_EQUAL" | "GREATER_THAN" | "GREATER_THAN_OR_EQUAL";
  count?: number;
}

/**
 * Possible patterns of a crossing stripe (any element that denotes a point on
 * a segment or lane at which the vehicle must stop or yield). These include
 * crosswalks, stop, and yield lines.
 */
export interface GeostoreCrossingStripePatternProto {
  borderLine?: GeostorePhysicalLineProto;
  borderPattern?:  | "UNKNOWN_BORDER_PATTERN" | "NO_BORDER_PATTERN" | "SOLID" | "DASHED";
  /**
   * Colors found on this crossing.
   */
  color?: GeostorePaintedElementLogicalColorProto[];
  stripePattern?:  | "UNKNOWN_STRIPE_PATTERN" | "NO_STRIPE_PATTERN" | "LONGITUDINAL_STRIPE" | "DIAGONAL_STRIPE" | "LATERAL_STRIPE" | "SINGLE_CROSSING_LINE" | "DOUBLE_CROSSING_LINE" | "TRIANGLE_CROSSING_LINE_POINTING_LEFT" | "TRIANGLE_CROSSING_LINE_POINTING_RIGHT" | "STRUCTURED_CROSSING_LINE";
}

/**
 * Protocol buffer describing a curve that connects two externally specified
 * endpoints.
 */
export interface GeostoreCurveConnectionProto {
  bezierParams?: GeostoreCurveConnectionProtoBezierParams;
  circleParams?: GeostoreCurveConnectionProtoCircleParams;
  type?:  | "UNSPECIFIED" | "BEZIER" | "CIRCLE" | "STRAIGHT_EDGE";
}

export interface GeostoreCurveConnectionProtoBezierParams {
  /**
   * Internal Bezier handles. One can be used for a quadratic curve, two for
   * cubic Beziers.
   */
  controlPoint?: GeostoreCurveConnectionProtoBezierParamsControlPoint[];
}

export interface GeostoreCurveConnectionProtoBezierParamsControlPoint {
  /**
   * We use this parameterization to make curves change predictable when
   * endpoints move. Each point P is defined in terms of the straight edge [S,
   * E] between the start point of the curve S and its end point E. *P / / / S
   * *------------* E Counter-clockwise angle between vector SE and vector SP.
   */
  angleDegrees?: number;
  /**
   * Distance(S, P) in units of Distance(S, E).
   */
  distanceMultiplier?: number;
}

export interface GeostoreCurveConnectionProtoCircleParams {
  /**
   * Arc radius. Must be greater than half-distance between two endpoints.
   */
  radius?: number;
}

/**
 * Every data source used to construct a data repository has an associated
 * feature that provides more information about it. The standard feature
 * properties have the following interpretations: bound - The bounds must
 * includes all features that refer to this data source, so that bucketing
 * MapReduce passes work correctly. name - The provider name associated with
 * this data source. It is expected to remain constant from release to release,
 * and between datasets. address - should be empty. point, polyline, polygon -
 * should be empty. source_info - should not be set. child - should be empty.
 */
export interface GeostoreDataSourceProto {
  /**
   * This is the URL of a website representing this DataSource as a whole. If
   * this DataSource feature is specific to a particular dataset or product, the
   * page may contain information relevant to that dataset or product or may be
   * the main page of the organization.
   */
  attributionUrl?: GeostoreUrlProto[];
  /**
   * A UTF8 string that will be inserted in copyright messages to refer to this
   * copyright owner, e.g. "Tele Atlas".
   */
  copyrightOwner?: string;
  /**
   * The copyright year of this data (which may be different than the year of
   * the release date), e.g. 2005.
   */
  copyrightYear?: number;
  /**
   * A free-form description of this data source. Ideally the description
   * should include: - Where the data was obtained (URL, company name,
   * individual, etc). - Where to find detailed documentation. - A brief summary
   * of the licensing terms. - As much internal and external contact information
   * as possible (e.g. who to ask about licensing questions, interpreting the
   * data, updating the data, fixing bugs in the importer, etc).
   */
  description?: string;
  /**
   * The build information of the importer binary used to generate this data
   * source.
   */
  importerBuildInfo?: string;
  /**
   * The build target of the importer binary used to generate this data source.
   */
  importerBuildTarget?: string;
  /**
   * The Perforce client information of the importer binary used to generate
   * this data source.
   */
  importerClientInfo?: string;
  /**
   * If the importer was built as an MPM, the version number can be stored in
   * this field. As with build_info, this can be useful when tracking down
   * issues that may be due to the use of a particular binary.
   */
  importerMpmVersion?: string;
  /**
   * The timestamp of the importer binary used to generate this data source.
   */
  importerTimestamp?: string;
  /**
   * The provider type of this data source.
   */
  provider?:  | "PROVIDER_ANY" | "PROVIDER_UNKNOWN" | "PROVIDER_NAVTEQ" | "PROVIDER_TELE_ATLAS" | "PROVIDER_TELE_ATLAS_MULTINET" | "PROVIDER_TELE_ATLAS_CODEPOINT" | "PROVIDER_TELE_ATLAS_GEOPOST" | "PROVIDER_TELE_ATLAS_DATAGEO" | "PROVIDER_TELE_ATLAS_ADDRESS_POINTS" | "PROVIDER_TELCONTAR" | "PROVIDER_EUROPA" | "PROVIDER_ROYAL_MAIL" | "PROVIDER_GOOGLE" | "PROVIDER_GOOGLE_HAND_EDIT" | "PROVIDER_GOOGLE_BORDERS" | "PROVIDER_GOOGLE_SUBRANGE" | "PROVIDER_GOOGLE_GT_FUSION" | "PROVIDER_GOOGLE_ZAGAT_CMS" | "PROVIDER_GOOGLE_PLACE_NAVBOOST" | "PROVIDER_GOOGLE_FOOTPRINT" | "PROVIDER_GOOGLE_PRODUCT_TERMS" | "PROVIDER_GOOGLE_POINTCARDS" | "PROVIDER_GOOGLE_BUSINESS_CHAINS" | "PROVIDER_GOOGLE_LOCAL_SUMMARIZATION" | "PROVIDER_GOOGLE_PRONUNCIATIONS" | "PROVIDER_GOOGLE_DUMPLING" | "PROVIDER_GOOGLE_DISTILLERY" | "PROVIDER_GOOGLE_LOCAL_ATTRIBUTE_SUMMARIZATION" | "PROVIDER_GOOGLE_RELATION_MINER" | "PROVIDER_GOOGLE_MAPSPAM" | "PROVIDER_GOOGLE_ROSE" | "PROVIDER_GOOGLE_LOCAL_PLACE_RATINGS" | "PROVIDER_GOOGLE_WIPEOUT" | "PROVIDER_GOOGLE_KNOWLEDGE_GRAPH" | "PROVIDER_GOOGLE_BEEGEES" | "PROVIDER_GOOGLE_REVIEW_SUMMARIZATION" | "PROVIDER_GOOGLE_OFFLINE_NON_CORE_ATTRIBUTE_SUMMARIZATION" | "PROVIDER_GOOGLE_GEO_WORLDMAPS" | "PROVIDER_GOOGLE_GEO_MODERATION" | "PROVIDER_GOOGLE_OYSTER_AUTO_EDITS" | "PROVIDER_GOOGLE_LOCAL_ALCHEMY" | "PROVIDER_GOOGLE_KEROUAC" | "PROVIDER_GOOGLE_MOBRANK" | "PROVIDER_GOOGLE_RAPTURE" | "PROVIDER_GOOGLE_CULTURAL_INSTITUTE" | "PROVIDER_GOOGLE_GEOCODES_FROM_LOCAL_FEEDS" | "PROVIDER_GOOGLE_ATTRIBUTES_FROM_CRAWLED_CHAINS" | "PROVIDER_GOOGLE_TACTILE_MAPS" | "PROVIDER_GOOGLE_MAPS_FOR_MOBILE" | "PROVIDER_GOOGLE_GEO_REALTIME" | "PROVIDER_GOOGLE_PROMINENT_PLACES" | "PROVIDER_GOOGLE_PLACE_ACTIONS" | "PROVIDER_GOOGLE_GT_AUTO_EDITS" | "PROVIDER_GOOGLE_WAZE" | "PROVIDER_GOOGLE_ONTHEGO" | "PROVIDER_GOOGLE_GT_IMPORT" | "PROVIDER_GOOGLE_STRUCTURED_DATA" | "PROVIDER_GOOGLE_HELICOPTER" | "PROVIDER_GOOGLE_ROLLBACK" | "PROVIDER_GOOGLE_RIGHTS_REPAIR" | "PROVIDER_GOOGLE_PERFUME" | "PROVIDER_GOOGLE_MAPS_TRANSLATION" | "PROVIDER_GOOGLE_CALL_ME_MAYBE" | "PROVIDER_GOOGLE_LOCAL_UNIVERSAL" | "PROVIDER_GOOGLE_CROUPIER" | "PROVIDER_GOOGLE_SKYSMART" | "PROVIDER_GOOGLE_RIDDLER" | "PROVIDER_GOOGLE_ROADCLOSURES" | "PROVIDER_GOOGLE_SPORE" | "PROVIDER_GOOGLE_LOCALIZATION" | "PROVIDER_GOOGLE_CATTERMS" | "PROVIDER_GOOGLE_GT_FIELD_OPS" | "PROVIDER_GOOGLE_MATCHMAKER" | "PROVIDER_GOOGLE_ARBITRATION" | "PROVIDER_GOOGLE_BIZBUILDER_OPS" | "PROVIDER_GOOGLE_LOCAL_INVENTORY_ADS" | "PROVIDER_GOOGLE_GT_DRAFTY" | "PROVIDER_GOOGLE_HOTELADS_OPS" | "PROVIDER_GOOGLE_MARKERS" | "PROVIDER_GOOGLE_STATE_MACHINE" | "PROVIDER_GOOGLE_ATTRIBUTES_INFERENCE" | "PROVIDER_GOOGLE_BIKESHARE" | "PROVIDER_GOOGLE_GHOSTWRITER" | "PROVIDER_GOOGLE_EDIT_PLATFORM" | "PROVIDER_GOOGLE_BLUE_GINGER" | "PROVIDER_GOOGLE_GEO_TIGER" | "PROVIDER_GOOGLE_HYADES" | "PROVIDER_GOOGLE_WEBQUARRY" | "PROVIDER_GOOGLE_GEO_MADDEN" | "PROVIDER_GOOGLE_ANDROID_PAY" | "PROVIDER_GOOGLE_OPENING_HOURS_TEAM" | "PROVIDER_GOOGLE_LOCAL_DISCOVERY" | "PROVIDER_GOOGLE_LOCAL_HEALTH" | "PROVIDER_GOOGLE_UGC_MAPS" | "PROVIDER_GOOGLE_FIBER" | "PROVIDER_GOOGLE_REVGEO" | "PROVIDER_GOOGLE_HOTELADS_PARTNER_FRONT_END" | "PROVIDER_GOOGLE_GEO_UGC_TASKS" | "PROVIDER_GOOGLE_GEOCODING" | "PROVIDER_GOOGLE_SPYGLASS" | "PROVIDER_GOOGLE_PLUS_CODES_AS_ADDRESSES" | "PROVIDER_GOOGLE_GEO_CHANGES" | "PROVIDER_GOOGLE_HUME" | "PROVIDER_GOOGLE_MEGAMIND" | "PROVIDER_GOOGLE_GT_ROADSYNTH" | "PROVIDER_GOOGLE_FIREBOLT" | "PROVIDER_GOOGLE_LOCAL_PLACE_OFFERINGS" | "PROVIDER_GOOGLE_UGC_SERVICES" | "PROVIDER_GOOGLE_GEOALIGN" | "PROVIDER_GOOGLE_GT_COMPOUNDS" | "PROVIDER_GOOGLE_FOOD_ORDERING" | "PROVIDER_GOOGLE_HOTEL_KNOWLEDGE_OPS" | "PROVIDER_GOOGLE_URAW" | "PROVIDER_GOOGLE_FLYEYE" | "PROVIDER_GOOGLE_YOUKE" | "PROVIDER_GOOGLE_GT_ZEPHYR" | "PROVIDER_GOOGLE_USER_SAFETY" | "PROVIDER_GOOGLE_ADDRESS_MAKER" | "PROVIDER_GOOGLE_UGC_PHOTOS" | "PROVIDER_GOOGLE_GT_WINDCHIME" | "PROVIDER_GOOGLE_SNAG_FIXER" | "PROVIDER_GOOGLE_GEO_DEALS" | "PROVIDER_GOOGLE_LOCAL_PLACE_TOPICS" | "PROVIDER_GOOGLE_PROPERTY_INSIGHTS" | "PROVIDER_GOOGLE_GEO_CONSUMER_MERCHANT_EXPERIMENTS" | "PROVIDER_GOOGLE_GEO_PORTKEY" | "PROVIDER_GOOGLE_ROAD_MAPPER" | "PROVIDER_GOOGLE_LOCATION_PLATFORM" | "PROVIDER_GOOGLE_POSTTRIP" | "PROVIDER_GOOGLE_TRAVEL_DESTINATION" | "PROVIDER_GOOGLE_GEO_DATA_UPLOAD" | "PROVIDER_GOOGLE_BIZBUILDER_CLEANUP" | "PROVIDER_GOOGLE_USER" | "PROVIDER_GOOGLE_STATION" | "PROVIDER_GOOGLE_GEO_FOOD" | "PROVIDER_GOOGLE_GEO_AR" | "PROVIDER_GOOGLE_GEO_TEMPORAL" | "PROVIDER_GOOGLE_SERVICES_MARKETPLACE" | "PROVIDER_GOOGLE_IMT_CLEANUP" | "PROVIDER_GOOGLE_GEO_FOOD_MENU" | "PROVIDER_GOOGLE_CARENAV" | "PROVIDER_GOOGLE_DRIVING_FEEDS" | "PROVIDER_GOOGLE_DRIVING_UGC" | "PROVIDER_GOOGLE_POLAR" | "PROVIDER_GOOGLE_TRIWILD" | "PROVIDER_GOOGLE_CROWD_COMPUTE_OPS" | "PROVIDER_GOOGLE_SA_FROM_WEB" | "PROVIDER_GOOGLE_POI_ALIGNMENT" | "PROVIDER_GOOGLE_SA_FROM_HULK" | "PROVIDER_GOOGLE_SERVICES_INTERACTIONS" | "PROVIDER_GOOGLE_ROADS_UGC_EDITOR" | "PROVIDER_GOOGLE_SA_FROM_NG_INFERENCE" | "PROVIDER_GOOGLE_GEO_DRIVING_VIZ" | "PROVIDER_GOOGLE_GEO_TASKING" | "PROVIDER_GOOGLE_CROWDTASK_DATACOMPUTE" | "PROVIDER_GOOGLE_CROWDTASK_TASKADS" | "PROVIDER_GOOGLE_CROWDTASK_TASKMATE" | "PROVIDER_GOOGLE_CROWDTASK_FURBALL" | "PROVIDER_GOOGLE_CROWDTASK_ADAP" | "PROVIDER_GOOGLE_GPAY" | "PROVIDER_GOOGLE_GEO_UGC_TRUSTED_USERS" | "PROVIDER_GOOGLE_THIRD_PARTY_DATA_PRODUCTION" | "PROVIDER_GOOGLE_GEOTRACKER" | "PROVIDER_GOOGLE_LOCAL_LANDMARK_INFERENCE" | "PROVIDER_GOOGLE_GEO_CLOSED_LOOP" | "PROVIDER_GOOGLE_SA_FROM_MERCHANT_POSTS" | "PROVIDER_GOOGLE_CORE_DATA_RIGHTS" | "PROVIDER_GOOGLE_SA_FROM_USER_REVIEWS" | "PROVIDER_GOOGLE_GEO_CONTENT_FIXER" | "PROVIDER_GOOGLE_POLYGON_REFINEMENT" | "PROVIDER_GOOGLE_HANASU" | "PROVIDER_GOOGLE_FULLRIGHTS_GEO_DATA_UPLOAD" | "PROVIDER_GOOGLE_FULLRIGHTS_3P_OUTREACH_UPLOAD" | "PROVIDER_GOOGLE_ATTRIBUTION_3P_OUTREACH_UPLOAD" | "PROVIDER_GOOGLE_SA_FROM_FOOD_MENUS" | "PROVIDER_GOOGLE_GT_CONSISTENCY_EDITS" | "PROVIDER_GOOGLE_SA_QUALITY" | "PROVIDER_GOOGLE_GDCE_CLEANUP" | "PROVIDER_GOOGLE_UGC_QUALITY_CHAINS" | "PROVIDER_GOOGLE_ATTRIBUTES_DISCOVERY" | "PROVIDER_GOOGLE_GEO_LDE" | "PROVIDER_GOOGLE_GEO_SIGNAL_TRACKING" | "PROVIDER_GOOGLE_UGC_AGGREGATION" | "PROVIDER_GOOGLE_3D_BASEMAP" | "PROVIDER_GOOGLE_MAPFACTS_PRIVACY" | "PROVIDER_GOOGLE_GT_ALF" | "PROVIDER_GOOGLE_GT_OPERATOR_PROVENANCE" | "PROVIDER_GOOGLE_LOCAL_SERVICES_ADS" | "PROVIDER_GOOGLE_LOCALSEARCH" | "PROVIDER_GOOGLE_TRANSIT" | "PROVIDER_GOOGLE_GEOWIKI" | "PROVIDER_GOOGLE_CHINA_LOCAL_TEAM" | "PROVIDER_GOOGLE_SYNTHESIZED" | "PROVIDER_GOOGLE_INTERNAL_TEST" | "PROVIDER_GOOGLE_DISPUTED_AREAS" | "PROVIDER_GOOGLE_3DWAREHOUSE" | "PROVIDER_GOOGLE_GROUNDS_BUILDER" | "PROVIDER_GOOGLE_SESAME" | "PROVIDER_GOOGLE_GT" | "PROVIDER_GOOGLE_GT_BASEMAP_UPLOAD" | "PROVIDER_GOOGLE_ADSDB" | "PROVIDER_GOOGLE_MACHINE_TRANSLITERATION" | "PROVIDER_GOOGLE_TRAVELSEARCH" | "PROVIDER_GOOGLE_PANORAMIO" | "PROVIDER_GOOGLE_YOUTUBE" | "PROVIDER_GOOGLE_OLD" | "PROVIDER_GOOGLE_STREETVIEW" | "PROVIDER_GOOGLE_STREETVIEW_BIZVIEW" | "PROVIDER_GOOGLE_ZIPIT" | "PROVIDER_GOOGLE_OYSTER_CONNECT_ROUTES" | "PROVIDER_GOOGLE_GOLDEN" | "PROVIDER_GOOGLE_INNERSPACE" | "PROVIDER_GOOGLE_MAPSEARCH" | "PROVIDER_GOOGLE_CATEGORIES_TEAM" | "PROVIDER_GOOGLE_CROWDSENSUS" | "PROVIDER_GOOGLE_LOCAL_ALGORITHMIC_IDENTITY" | "PROVIDER_GOOGLE_FREEBASE" | "PROVIDER_GOOGLE_HOTELADS" | "PROVIDER_GOOGLE_AUTHORITY_PAGES" | "PROVIDER_GOOGLE_PLACES_API" | "PROVIDER_GOOGLE_NAMEHEATMAP" | "PROVIDER_GOOGLE_MAPMAKER" | "PROVIDER_GOOGLE_MAPMAKER_MOBILE" | "PROVIDER_GOOGLE_MAPMAKER_PANCAKE" | "PROVIDER_GOOGLE_MAPMAKER_V2" | "PROVIDER_GOOGLE_LOCAL_CLUSTERING_OPERATOR_OVERRIDE" | "PROVIDER_GOOGLE_SERVED_ON_MAPMAKER" | "PROVIDER_GOOGLE_GT_LOCAL" | "PROVIDER_GOOGLE_GT_LOCAL_WITH_RIGHTS" | "PROVIDER_GOOGLE_LOGS_RANKING_SIGNALS" | "PROVIDER_GOOGLE_ENTITY_NAVBOOST" | "PROVIDER_GOOGLE_RELATED_PLACES" | "PROVIDER_GOOGLE_KNOWN_FOR_TERMS" | "PROVIDER_GOOGLE_SYNTHETIC_AREAS" | "PROVIDER_GOOGLE_AUTHORITY_PAGE_PHOTOS" | "PROVIDER_GOOGLE_CROSS_STREETS" | "PROVIDER_GOOGLE_CORRIDORS" | "PROVIDER_GOOGLE_BICYCLE_RENTAL" | "PROVIDER_GOOGLE_CONCRETE_URLS" | "PROVIDER_GOOGLE_LEANBACK" | "PROVIDER_GOOGLE_LOCKED_LISTINGS" | "PROVIDER_GOOGLE_MONITORING" | "PROVIDER_GOOGLE_SPROUT" | "PROVIDER_GOOGLE_LOCAL_SEARCH_QUALITY" | "PROVIDER_GOOGLE_GOBY" | "PROVIDER_GOOGLE_PROBLEM_REPORT" | "PROVIDER_GOOGLE_CANDID" | "PROVIDER_GOOGLE_BIZBUILDER" | "PROVIDER_AUTOMOTIVE_NAVIGATION_DATA" | "PROVIDER_MAPDATA_SCIENCES" | "PROVIDER_MAPONICS" | "PROVIDER_SKI_RESORTS" | "PROVIDER_ZENRIN" | "PROVIDER_SANBORN" | "PROVIDER_URBAN_MAPPING" | "PROVIDER_US_GOVERNMENT" | "PROVIDER_US_CENSUS" | "PROVIDER_US_POSTAL_SERVICE" | "PROVIDER_US_GEOLOGICAL_SURVEY" | "PROVIDER_US_GNIS" | "PROVIDER_US_LANDSAT" | "PROVIDER_US_NATIONAL_GEOSPATIAL_INTELLIGENCE_AGENCY" | "PROVIDER_US_NGA_GNS" | "PROVIDER_US_SSIBL" | "PROVIDER_US_BUREAU_OF_TRANSPORTATION_STATISTICS" | "PROVIDER_US_NATIONAL_OCEANIC_AND_ATMOSPHERIC_ADMINISTRATION" | "PROVIDER_US_POLAR_GEOSPATIAL_CENTER" | "PROVIDER_US_DEPARTMENT_OF_AGRICULTURE" | "PROVIDER_US_NPI_REGISTRY" | "PROVIDER_US_BUREAU_OF_INDIAN_AFFAIRS" | "PROVIDER_DMTI_SPATIAL" | "PROVIDER_INTERNATIONAL_HYDROGRAPHIC_ORGANIZATION" | "PROVIDER_MAPLINK" | "PROVIDER_KINGWAY" | "PROVIDER_GEOCENTRE" | "PROVIDER_CN_NATIONAL_FOUNDAMENTAL_GIS" | "PROVIDER_CN_MAPABC" | "PROVIDER_SMITHSONIAN_INSTITUTE" | "PROVIDER_TRACKS_FOR_AFRICA" | "PROVIDER_PPWK" | "PROVIDER_LEADDOG" | "PROVIDER_CENTRE_DONNEES_ASTRONOMIQUES_STRASBOURG" | "PROVIDER_GISRAEL" | "PROVIDER_BASARSOFT" | "PROVIDER_MAPINFO" | "PROVIDER_MAPIT" | "PROVIDER_GEOBASE" | "PROVIDER_ORION" | "PROVIDER_CENTRAL_EUROPEAN_DATA_AGENCY" | "PROVIDER_ANASAT" | "PROVIDER_MINED_POSTCODES" | "PROVIDER_DMAPAS" | "PROVIDER_COMMON_LOCALE_DATA_REPOSITORY" | "PROVIDER_CH_SBB" | "PROVIDER_SKENERGY" | "PROVIDER_GBRMPA" | "PROVIDER_KOREA_POST" | "PROVIDER_CN_AUTONAVI" | "PROVIDER_MINED_POI" | "PROVIDER_ML_INFOMAP" | "PROVIDER_SNOOPER" | "PROVIDER_GEOSISTEMAS" | "PROVIDER_AFRIGIS" | "PROVIDER_TRANSNAVICOM" | "PROVIDER_EASYCONNECT" | "PROVIDER_LANTMATERIET" | "PROVIDER_LOGICA" | "PROVIDER_MAPKING" | "PROVIDER_DIANPING" | "PROVIDER_GEONAV" | "PROVIDER_HEIBONSHA" | "PROVIDER_DEUTSCHE_TELEKOM" | "PROVIDER_LINGUISTIC_DATA_CONSORTIUM" | "PROVIDER_ACXIOM" | "PROVIDER_DUN_AND_BRADSTREET" | "PROVIDER_FEDERAL_AVIATION_ADMINISTRATION" | "PROVIDER_INFOUSA" | "PROVIDER_INFOUSA_NIXIE" | "PROVIDER_THOMSON_LOCAL" | "PROVIDER_TELEFONICA_PUBLICIDAD_E_INFORMACION" | "PROVIDER_WIKIPEDIA" | "PROVIDER_INFOBEL" | "PROVIDER_MX_GOVERNMENT" | "PROVIDER_MX_NATIONAL_INSTITUTE_STATISTICS_GEOGRAPHY" | "PROVIDER_MX_SERVICIO_POSTAL_MEXICANO" | "PROVIDER_TELEGATE" | "PROVIDER_TELELISTAS" | "PROVIDER_MAPCITY" | "PROVIDER_EXPLAINER_DC" | "PROVIDER_DAIKEI" | "PROVIDER_NL_CHAMBER_OF_COMMERCE" | "PROVIDER_KOREA_INFO_SERVICE" | "PROVIDER_WIKITRAVEL" | "PROVIDER_FLICKR" | "PROVIDER_DIANCO" | "PROVIDER_VOLT_DELTA" | "PROVIDER_SG_GOVERNMENT" | "PROVIDER_SG_LAND_TRANSPORT_AUTHORITY" | "PROVIDER_MAPBAR" | "PROVIDER_LONGTU" | "PROVIDER_SA_GOVERNMENT" | "PROVIDER_SA_SAUDI_POST" | "PROVIDER_PEAKLIST" | "PROVIDER_LOCAL_BUSINESS_CENTER" | "PROVIDER_LOCAL_FEED_XML" | "PROVIDER_WEB" | "PROVIDER_RAILS_TO_TRAILS" | "PROVIDER_INDIACOM" | "PROVIDER_INFOMEDIA" | "PROVIDER_PICASA" | "PROVIDER_AT_GOVERNMENT" | "PROVIDER_AT_BUNDESAMT_FUR_EICH_UND_VERMESSUNGSWESEN" | "PROVIDER_AT_NATIONAL_TOURIST_OFFICE" | "PROVIDER_AT_AUSTRIA_POST" | "PROVIDER_NO_GOVERNMENT" | "PROVIDER_NO_NORSK_EIENDOMSINFORMASJON" | "PROVIDER_NO_POSTEN_NORGE_AS" | "PROVIDER_CH_GOVERNMENT" | "PROVIDER_CH_SWISS_POST" | "PROVIDER_CH_SWISSTOPO" | "PROVIDER_CH_SWISS_NATIONAL_PARK" | "PROVIDER_NAVIT" | "PROVIDER_GEOSEARCH" | "PROVIDER_DE_GOVERNMENT" | "PROVIDER_BUNDESAMT_KARTOGRAPHIE_UND_GEODASIE" | "PROVIDER_BUNDESNETZAGENTUR" | "PROVIDER_SCHOBER_GROUP" | "PROVIDER_MIREO" | "PROVIDER_PUBLIC_MUNICIPALITY" | "PROVIDER_US_PUBLIC_MUNICIPALITY" | "PROVIDER_US_PUBLIC_MUNICIPALITY_WEBSTER_TEXAS" | "PROVIDER_US_PUBLIC_MUNICIPALITY_AMHERST_MASSACHUSETTS" | "PROVIDER_US_PUBLIC_MUNICIPALITY_BLOOMINGTON_INDIANA" | "PROVIDER_US_PUBLIC_MUNICIPALITY_PASADENA_CALIFORNIA" | "PROVIDER_US_PUBLIC_MUNICIPALITY_CHULA_VISTA_CALIFORNIA" | "PROVIDER_US_PUBLIC_MUNICIPALITY_TEMPE_ARIZONA" | "PROVIDER_US_PUBLIC_MUNICIPALITY_COLUMBUS_OHIO" | "PROVIDER_US_PUBLIC_MUNICIPALITY_PORTAGE_MICHIGAN" | "PROVIDER_US_PUBLIC_MUNICIPALITY_GEORGETOWN_KENTUCKY" | "PROVIDER_US_PUBLIC_MUNICIPALITY_GREENVILLE_SOUTH_CAROLINA" | "PROVIDER_US_PUBLIC_MUNICIPALITY_NASHVILLE_TENNESSEE" | "PROVIDER_US_PUBLIC_MUNICIPALITY_WASHINGTON_DISTRICT_OF_COLUMBIA" | "PROVIDER_US_PUBLIC_MUNICIPALITY_BOULDER_COLORADO" | "PROVIDER_NZ_PUBLIC_MUNICIPALITY" | "PROVIDER_NZ_PUBLIC_MUNICIPALITY_ENVIRONMENT_BAY" | "PROVIDER_PL_PUBLIC_MUNICIPALITY" | "PROVIDER_PL_PUBLIC_MUNICIPALITY_BIELSKO_BIALA" | "PROVIDER_DE_PUBLIC_MUNICIPALITY" | "PROVIDER_DE_PUBLIC_MUNICIPALITY_FRANKFURT" | "PROVIDER_DE_PUBLIC_MUNICIPALITY_HAMBURG" | "PROVIDER_DE_PUBLIC_MUNICIPALITY_KARLSRUHE" | "PROVIDER_PT_PUBLIC_MUNICIPALITY" | "PROVIDER_PT_PUBLIC_MUNICIPALITY_SANTA_CRUZ" | "PROVIDER_AT_PUBLIC_MUNICIPALITY" | "PROVIDER_AT_PUBLIC_MUNICIPALITY_KLAGENFURT" | "PROVIDER_AT_PUBLIC_MUNICIPALITY_LINZ" | "PROVIDER_ES_PUBLIC_MUNICIPALITY" | "PROVIDER_ES_PUBLIC_MUNICIPALITY_AZKOITIA" | "PROVIDER_ES_PUBLIC_MUNICIPALITY_BEASAIN" | "PROVIDER_ES_PUBLIC_MUNICIPALITY_GIRONA" | "PROVIDER_ES_PUBLIC_MUNICIPALITY_SAN_SEBASTIAN" | "PROVIDER_ES_PUBLIC_MUNICIPALITY_CATALUNYA" | "PROVIDER_ES_PUBLIC_MUNICIPALITY_HONDARRIBIA" | "PROVIDER_AU_PUBLIC_MUNICIPALITY" | "PROVIDER_AU_PUBLIC_MUNICIPALITY_LAUNCESTON_TASMANIA" | "PROVIDER_IS_PUBLIC_MUNICIPALITY" | "PROVIDER_IS_PUBLIC_MUNICIPALITY_REYKJAVIK" | "PROVIDER_NL_PUBLIC_MUNICIPALITY" | "PROVIDER_NL_PUBLIC_MUNICIPALITY_AMELSTEVEEN" | "PROVIDER_BE_PUBLIC_MUNICIPALITY" | "PROVIDER_BE_PUBLIC_MUNICIPALITY_ANTWERPEN" | "PROVIDER_CA_PUBLIC_MUNICIPALITY" | "PROVIDER_CA_PUBLIC_MUNICIPALITY_FREDERICTON_NEW_BRUNSWICK" | "PROVIDER_CA_PUBLIC_MUNICIPALITY_KAMLOOPS_BRITISH_COLUMBIA" | "PROVIDER_CA_PUBLIC_MUNICIPALITY_NANAIMO_BRITISH_COLUMBIA" | "PROVIDER_CA_PUBLIC_MUNICIPALITY_BANFF_ALBERTA" | "PROVIDER_CA_PUBLIC_MUNICIPALITY_CALGARY_ALBERTA" | "PROVIDER_CA_PUBLIC_MUNICIPALITY_TORONTO_ONTARIO" | "PROVIDER_SE_PUBLIC_MUNICIPALITY" | "PROVIDER_SE_PUBLIC_MUNICIPALITY_UMEA" | "PROVIDER_UA_PUBLIC_MUNICIPALITY" | "PROVIDER_UA_PUBLIC_MUNICIPALITY_KHARKIV" | "PROVIDER_OTHER_PUBLIC_MUNICIPALITY" | "PROVIDER_OTHER_PUBLIC_MUNICIPALITY_AQUA_CALIENTE_CAHUILLA_INDIANS" | "PROVIDER_FR_PUBLIC_MUNICIPALITY" | "PROVIDER_FR_PUBLIC_MUNICIPALITY_PONT_AUDEMER" | "PROVIDER_FR_PUBLIC_MUNICIPALITY_BORDEAUX" | "PROVIDER_SG_PUBLIC_MUNICIPALITY" | "PROVIDER_BR_PUBLIC_MUNICIPALITY" | "PROVIDER_BR_PUBLIC_MUNICIPALITY_RIO_DE_JANEIRO" | "PROVIDER_MAPCUBE" | "PROVIDER_3D_REALITYMAPS" | "PROVIDER_DEUTSCHES_ZENTRUM_FUR_LUFT_UND_RAUMFAHRT" | "PROVIDER_3D_CITIES_SOCIEDADE_ANONIMA" | "PROVIDER_DISNEY" | "PROVIDER_CYBERCITY" | "PROVIDER_PRECISION_LIGHTWORKS_MODELWORKS" | "PROVIDER_VIRTUAL_HUNGARY_LIMITED" | "PROVIDER_VIRTUEL_CITY" | "PROVIDER_SCREAMPOINT_INTERNATIONAL" | "PROVIDER_AGENTSCHAP_VOOR_GEOGRAFISCHE_INFORMATIE_VLAANDEREN" | "PROVIDER_FR_GOVERNMENT" | "PROVIDER_FR_INSTITUT_GEOGRAPHIQUE_NATIONAL" | "PROVIDER_FR_CADASTRE" | "PROVIDER_DIADIEM" | "PROVIDER_THE_WEATHER_CHANNEL" | "PROVIDER_COWI" | "PROVIDER_FALKPLAN_ANDES" | "PROVIDER_NL_GOVERNMENT" | "PROVIDER_NL_KADASTER" | "PROVIDER_NL_BOARD_OF_TOURISM_AND_CONVENTIONS" | "PROVIDER_DIGITAL_MAP_PRODUCTS" | "PROVIDER_SILICE_DIGITAL" | "PROVIDER_TYDAC" | "PROVIDER_ALBRECHT_GOLF" | "PROVIDER_HEALTH_CH" | "PROVIDER_VISITDENMARK" | "PROVIDER_FLYHERE" | "PROVIDER_DIGITAL_DATA_SERVICES" | "PROVIDER_MECOMO" | "PROVIDER_ZA_GOVERNMENT" | "PROVIDER_ZA_RURAL_DEVELOPMENT_LAND_REFORM" | "PROVIDER_SENSIS" | "PROVIDER_JJCONNECT" | "PROVIDER_OPPLYSNINGEN" | "PROVIDER_TELLUS" | "PROVIDER_IQONIA" | "PROVIDER_BE_GOVERNMENT" | "PROVIDER_BE_NATIONAAL_GEOGRAFISCH_INSTITUUT" | "PROVIDER_BE_BRUSSELS_MOBILITY" | "PROVIDER_YELLOWMAP_AG" | "PROVIDER_STIFTUNG_GESUNDHEIT" | "PROVIDER_GIATA" | "PROVIDER_SANPARKS" | "PROVIDER_CENTRE_DINFORMATIQUE_POUR_LA_REGION_BRUXELLOISE" | "PROVIDER_INFOPORTUGAL" | "PROVIDER_NEGOCIOS_DE_TELECOMUNICACOES_E_SISTEMAS_DE_INFORMACAO" | "PROVIDER_COLLINS_BARTHOLOMEW" | "PROVIDER_PROTECT_PLANET_OCEAN" | "PROVIDER_KARTTAKESKUS" | "PROVIDER_FI_GOVERNMENT" | "PROVIDER_FI_NATIONAL_ROAD_ADMINISTRATION" | "PROVIDER_FI_NATIONAL_LAND_SURVEY" | "PROVIDER_FI_STATISTICS_FINLAND" | "PROVIDER_GB_GOVERNMENT" | "PROVIDER_GB_ORDNANCE_SURVEY" | "PROVIDER_NATURAL_ENGLAND" | "PROVIDER_WELSH_GOVERNMENT" | "PROVIDER_GB_OFFICE_FOR_NATIONAL_STATISTICS" | "PROVIDER_EPSILON" | "PROVIDER_PARTNER_FRONT_END" | "PROVIDER_CARTESIA" | "PROVIDER_SE_GOVERNMENT" | "PROVIDER_SE_TRAFIKVERKET" | "PROVIDER_SE_NATURVARDSVERKET" | "PROVIDER_IE_GOVERNMENT" | "PROVIDER_IE_ORDNANCE_SURVEY_IRELAND" | "PROVIDER_LU_GOVERNMENT" | "PROVIDER_LU_P_AND_T_LUXEMBOURG" | "PROVIDER_LU_ADMINISTRATION_DU_CADASTRE_ET_DE_LA_TOPOGRAPHIE" | "PROVIDER_LU_NATIONAL_TOURIST_OFFICE" | "PROVIDER_MAPFLOW" | "PROVIDER_TKARTOR" | "PROVIDER_JUMPSTART" | "PROVIDER_EPTISA" | "PROVIDER_MC_GOVERNMENT" | "PROVIDER_MC_PRINCIPAUTE_DE_MONACO" | "PROVIDER_MONOLIT" | "PROVIDER_ENVIRONMENTAL_SYSTEMS_RESEARCH_INSTITUTE" | "PROVIDER_MODIS" | "PROVIDER_GEOX" | "PROVIDER_GEODIRECTORY" | "PROVIDER_GEOPLAN" | "PROVIDER_INFODIREKT" | "PROVIDER_GEOGLOBAL" | "PROVIDER_DEUTSCHE_POST" | "PROVIDER_TRACASA" | "PROVIDER_CORREOS" | "PROVIDER_ES_GOVERNMENT" | "PROVIDER_ES_CENTRO_NACIONAL_DE_INFORMACION_GEOGRAFICA" | "PROVIDER_EDIMAP" | "PROVIDER_VERIZON" | "PROVIDER_NATIONAL_GEOGRAPHIC_MAPS" | "PROVIDER_PROMAPS" | "PROVIDER_CONSODATA" | "PROVIDER_DE_AGOSTINI" | "PROVIDER_FEDERPARCHI" | "PROVIDER_NAVIGO" | "PROVIDER_ITALIAMAPPE" | "PROVIDER_CZECOT" | "PROVIDER_NATURAL_EARTH" | "PROVIDER_REGIO" | "PROVIDER_SHIPWRECK_CENTRAL" | "PROVIDER_RUTGERS_STATE_UNIVERSITY" | "PROVIDER_TWINICE" | "PROVIDER_NORTHERN_IRELAND_TOURIST_BOARD" | "PROVIDER_INFOGROUP" | "PROVIDER_TNET" | "PROVIDER_CTT_CORREIOS_DE_PORTUGAL" | "PROVIDER_EUROPARC" | "PROVIDER_IUPPITER" | "PROVIDER_MICHAEL_BAUER_INTERNATIONAL" | "PROVIDER_LEPTON" | "PROVIDER_MAPPOINT" | "PROVIDER_GEODATA" | "PROVIDER_RU_GOVERNMENT" | "PROVIDER_RU_FNS_KLADR" | "PROVIDER_BR_GOVERNMENT" | "PROVIDER_BR_INSTITUTO_BRASILEIRO_DO_MEIO_AMBIENTE_E_DOS_RECURSOS_NATURAIS_RENOVAVEIS" | "PROVIDER_BR_MINISTERIO_DO_MEIO_AMBIENTE" | "PROVIDER_BR_AGENCIA_NACIONAL_DE_AGUAS" | "PROVIDER_BR_INSTITUTO_BRASILEIRO_DE_GEOGRAFIA_E_ESTATISTICA" | "PROVIDER_BR_FUNDACAO_NACIONAL_DO_INDIO" | "PROVIDER_BR_DEPARTAMENTO_NACIONAL_DE_INFRAESTRUTURA_DE_TRANSPORTES" | "PROVIDER_AZAVEA" | "PROVIDER_NORTHSTAR" | "PROVIDER_COMMEDI" | "PROVIDER_NEXUS_GEOGRAFICS" | "PROVIDER_INFOERA" | "PROVIDER_AD_GOVERNMENT" | "PROVIDER_AD_AREA_DE_CARTOGRAFIA" | "PROVIDER_MAXXIMA" | "PROVIDER_SI_GOVERNMENT" | "PROVIDER_SI_AGENCY_FOR_ENVIRONMENT" | "PROVIDER_TRANSPORT_HI_TECH_CONSULTANTS" | "PROVIDER_L1_TECHNOLOGIES" | "PROVIDER_TELEMEDIA" | "PROVIDER_CDCOM_PROGOROD" | "PROVIDER_MIT_CITYGUIDE" | "PROVIDER_SUNCART" | "PROVIDER_MICROMAPPER" | "PROVIDER_RICHI" | "PROVIDER_FORUM44" | "PROVIDER_SEAT" | "PROVIDER_VALASSIS" | "PROVIDER_NAVICOM" | "PROVIDER_COLTRACK" | "PROVIDER_PSMA_AUSTRALIA" | "PROVIDER_PT_DUTA_ASTAKONA_GIRINDA" | "PROVIDER_CA_GOVERNMENT" | "PROVIDER_STATISTICS_CANADA" | "PROVIDER_TOCTOC" | "PROVIDER_RMSI" | "PROVIDER_TRUE_TECHNOLOGY" | "PROVIDER_INCREMENT_P_CORPORATION" | "PROVIDER_GOJAVAS" | "PROVIDER_GEOINFORMATION_GROUP" | "PROVIDER_CYBERSOFT" | "PROVIDER_TSENTR_EFFEKTIVNYKH_TEKHNOLOGIY" | "PROVIDER_EE_GOVERNMENT" | "PROVIDER_EE_MAA_AMET" | "PROVIDER_GASBUDDY" | "PROVIDER_DK_GOVERNMENT" | "PROVIDER_DK_GEODATASTYRELSEN" | "PROVIDER_MURCIA_REGION_GOVERNMENT" | "PROVIDER_CORREIOS" | "PROVIDER_WEST_WORLD_MEDIA" | "PROVIDER_INTERNATIONAL_MAPPING_ASSOCIATION" | "PROVIDER_MEDICARE" | "PROVIDER_POLARIS" | "PROVIDER_TW_GOVERNMENT" | "PROVIDER_TW_MINISTRY_OF_THE_INTERIOR_SURVEYING_AND_MAPPING_CENTER" | "PROVIDER_NORDECA" | "PROVIDER_AFRIMAPPING" | "PROVIDER_OVERDRIVE" | "PROVIDER_PROVIDER_NETWORK_DIRECTORIES" | "PROVIDER_BR_MINISTERIO_DA_SAUDE" | "PROVIDER_DIGITAL_EGYPT" | "PROVIDER_INRIX" | "PROVIDER_ARPINDO" | "PROVIDER_IT_GOVERNMENT" | "PROVIDER_ISTITUTO_GEOGRAFICO_MILITARE" | "PROVIDER_EAST_END_GROUP" | "PROVIDER_INGEOLAN" | "PROVIDER_SEMACONNECT" | "PROVIDER_BLINK" | "PROVIDER_EVGO" | "PROVIDER_CHARGEPOINT" | "PROVIDER_TPL_TRAKKER" | "PROVIDER_OI" | "PROVIDER_MAPARADAR" | "PROVIDER_SINGAPORE_POST" | "PROVIDER_CHARGEMASTER" | "PROVIDER_TESLA" | "PROVIDER_VISICOM" | "PROVIDER_GEOLYSIS" | "PROVIDER_ZEPHEIRA" | "PROVIDER_HUBJECT" | "PROVIDER_PODPOINT" | "PROVIDER_CHARGEFOX" | "PROVIDER_KR_GOVERNMENT" | "PROVIDER_KR_MOLIT" | "PROVIDER_KR_MINISTRY_OF_THE_INTERIOR_AND_SAFETY" | "PROVIDER_CRITCHLOW" | "PROVIDER_EIFRIG" | "PROVIDER_GIREVE" | "PROVIDER_CN_NAVINFO" | "PROVIDER_JAPAN_CHARGE_NETWORK" | "PROVIDER_NOBIL" | "PROVIDER_INDIA_BANKS" | "PROVIDER_INDONESIA_ELECTION_KPU" | "PROVIDER_CAREERS360" | "PROVIDER_SOURCE_LONDON" | "PROVIDER_EVBOX" | "PROVIDER_JP_GOVERNMENT" | "PROVIDER_JP_MINISTRY_OF_THE_ENVIRONMENT" | "PROVIDER_YUMYUM" | "PROVIDER_HWW_AUSTRALIA" | "PROVIDER_CINERGY" | "PROVIDER_MTIME" | "PROVIDER_KULTUNAUT" | "PROVIDER_BLITZ" | "PROVIDER_PIA" | "PROVIDER_INTERPARK" | "PROVIDER_CINEMA_ONLINE" | "PROVIDER_BELBIOS" | "PROVIDER_MOVIESEER" | "PROVIDER_SODAMEDYA" | "PROVIDER_ATMOVIES" | "PROVIDER_HOTELBEDS" | "PROVIDER_VERICRED" | "PROVIDER_CIRRANTIC" | "PROVIDER_GOGO_LABS" | "PROVIDER_ELECTRIFY_AMERICA" | "PROVIDER_CMS_MPPUF" | "PROVIDER_DIGIROAD" | "PROVIDER_KONTEX_GEOMATICS" | "PROVIDER_NZ_GOVERNMENT" | "PROVIDER_NZ_LINZ" | "PROVIDER_NZ_DOC" | "PROVIDER_FASTNED" | "PROVIDER_DESTINY_CS" | "PROVIDER_IONITY" | "PROVIDER_EV_CONNECT" | "PROVIDER_PANPAGES" | "PROVIDER_ETECNIC" | "PROVIDER_VOLTA" | "PROVIDER_NISSAN_MEXICO" | "PROVIDER_BMW_GROUP_LATIN_AMERICA" | "PROVIDER_FEDERAL_ELECTRICITY_COMMISSION_MEXICO" | "PROVIDER_VOLVO_CARS_BRASIL" | "PROVIDER_CHARGE_AND_PARKING" | "PROVIDER_DEDUCE_TECHNOLOGIES" | "PROVIDER_SK_TELECOM" | "PROVIDER_ECO_MOVEMENT" | "PROVIDER_GOOGLE_GMS" | "PROVIDER_EASYWAY" | "PROVIDER_PHYSICIAN_COMPARE" | "PROVIDER_HOSPITAL_COMPARE" | "PROVIDER_ENDOLLA_BARCELONA" | "PROVIDER_BE_CHARGE" | "PROVIDER_ONE_NETWORK" | "PROVIDER_CARENAV_DUPLEX" | "PROVIDER_CARENAV_POI" | "PROVIDER_IN_GOVERNMENT" | "PROVIDER_SURVEY_OF_INDIA" | "PROVIDER_E_ON" | "PROVIDER_ELECTRIFY_CANADA" | "PROVIDER_GRIDCARS" | "PROVIDER_DRIVECO" | "PROVIDER_GREEN_ACTION_STUDIOS" | "PROVIDER_GREEN_ACTION_STUDIO" | "PROVIDER_EVINY" | "PROVIDER_MASTERCARD" | "PROVIDER_VATTENFALL" | "PROVIDER_VIETGIS" | "PROVIDER_UNITE" | "PROVIDER_NEOGY" | "PROVIDER_AMPUP" | "PROVIDER_LOOP" | "PROVIDER_ZEST" | "PROVIDER_EZVOLT";
  /**
   * For every key that is used in raw_data from this source, there must be a
   * corresponding entry in raw_metadata that describes this key.
   */
  rawMetadata?: GeostoreRawMetadataProto[];
  /**
   * A release string that doesn't have to be a date. This is provided so that
   * we can preserve provider release strings that aren't based on dates. If you
   * don't set it, the release_date will get formatted into this field for
   * debugging purposes.
   */
  release?: string;
  /**
   * The release date of this data.
   */
  releaseDate?: GeostoreDateTimeProto;
  /**
   * A data provider defined string describing the source dataset from which
   * the features of this data source were generated. For example, the MultiNet
   * "fra" dataset produces features for both France and Monaco.
   */
  sourceDataset?: string;
}

/**
 * WARNING: Outside of FeatureProto, please avoid in favor of a standard civil
 * time type. Direct usage is error-prone due to the conflation of physical time
 * and civil time (go/httat). In a protocol buffer, please use google.type.Date,
 * with an additional google.type.TimeOfDay for precision finer-grained than a
 * day. (For google.type.DateTime, go/prototime#types cites
 * go/httat#zoned_datetime as a caveat). In a programming language, see
 * go/time-devguide/languages. Additionally in C++,
 * google3/geostore/base/public/datetime.h has conversion functions between
 * DateTimeProto and Abseil's civil time types.
 */
export interface GeostoreDateTimeProto {
  /**
   * This attribute describes the precision of the date and time. It would be
   * unusual for a data provider to provide a precision along with their date.
   * It is more likely that the precision of a date will be inferred from the
   * date format. For example "19th century" is likely to be correct to the
   * century, while "1800" is probably correct to the year. The precision should
   * be semantically interpreted as a cast, so a DateTimeProto object with a
   * seconds value corresponding to 2018-03-28 18:40:00 UTC and a precision of
   * MONTH should be interpreted as "March 2018". The enums above are only some
   * of the possible precision levels for dates and times. Clients may wish to
   * add more precision enums in the future. However, these enums must be
   * ordered by decreasing duration. Clients should be able to write date
   * formatting code that looks like this: if (datetime.precision() <=
   * DateTimeProto::PRECISION_CENTURY) { date =
   * FormatCenturyDate(proto.seconds()); } else if (proto.precision() <= case
   * DateTimeProto::PRECISION_DECADE) { date =
   * FormatDecadeDate(proto.seconds()); } else { ... } See
   * geostore/base/public/datetime.h for date formatting utility functions.
   */
  precision?:  | "PRECISION_CENTURY" | "PRECISION_DECADE" | "PRECISION_YEAR" | "PRECISION_MONTH" | "PRECISION_DAY" | "PRECISION_HOUR" | "PRECISION_MINUTE" | "PRECISION_SECOND";
  /**
   * Number of seconds since (or before) the UNIX epoch (January 1, 1970). This
   * is also the standard epoch for Java and Python time representations. If it
   * is important for this time be displayed correctly for different time zones,
   * convert the time to Coordinated Universal Time (UTC).
   */
  seconds?: number;
}

/**
 * A dimension value tagged with a comparison operator. This can be used for
 * height, width, or length.
 */
export interface GeostoreDimensionComparisonProto {
  comparisonOperator?:  | "UNSPECIFIED" | "EQUAL" | "LESS_THAN" | "LESS_THAN_OR_EQUAL" | "GREATER_THAN" | "GREATER_THAN_OR_EQUAL";
  dimensionWithUnit?: GeostoreDimensionProto;
}

/**
 * A dimension with a numerical value and unit. This can be a height, width, or
 * length.
 */
export interface GeostoreDimensionProto {
  dimension?: number;
  unit?:  | "UNIT_UNKNOWN" | "METERS" | "FEET";
}

/**
 * This holds data specific to rendering a POI on a map. It's derived from data
 * already in MapFacts, e.g. containing features and the feature's point field.
 * If empty, this proto should be ignored for rendering. See
 * go/maps-render-alignment for motivation and more details.
 */
export interface GeostoreDisplayDataProto {
  /**
   * The location where this feature should be rendered.
   */
  displayLocation?: GeostorePointProto;
}

/**
 * This protocol buffer holds the doodle-specific attributes for features of
 * type TYPE_DOODLE.
 */
export interface GeostoreDoodleProto {
  /**
   * The type of this feature -- see comments above.
   */
  type?:  | "TYPE_ANY" | "TYPE_USER_DEFINED_LABEL" | "TYPE_POINT_ANNOTATION" | "TYPE_LINE_ANNOTATION" | "TYPE_AREA_ANNOTATION";
}

/**
 * A single cost which will apply based on the duration of utilization. The
 * cost may apply once, or repeatedly on some interval, to account for the total
 * utilization. If the duration expressed by range_start_seconds and
 * range_end_seconds do not cover the entire duration of the utilization (i.e.
 * from 0 to some time greater than the total utilization time), this must be
 * combined with other DurationBasedRateProtos such that the entire duration of
 * the utilization is accounted for. See go/rate-schema for more details.
 */
export interface GeostoreDurationBasedRateProto {
  /**
   * If true, represents that the rate is free; i.e. the price is 0 in any
   * currency. If this is true, price must be empty.
   */
  isFree?: boolean;
  /**
   * The billable unit of the rate; i.e. after having utilized the service for
   * exactly periodicity_seconds, the total cost should increase by ‘price’. For
   * example, if the rate expresses a price per hour, then periodicity_seconds
   * should be set to 3600. If this is unset, then the rate does not vary based
   * on duration, and price represents a flat cost. May only be set if price is
   * nonempty.
   */
  periodicitySeconds?: number;
  /**
   * The total price, in each applicable currency, of utilizing the service for
   * periodicity_seconds, or for the entire duration expressed by
   * range_start_seconds and range_end_seconds if periodicity_seconds is 0. Each
   * entry should have an ID of /measurement_unit/money_value and consist of two
   * properties: one with an ID of /measurement_unit/money_value/amount and a
   * float value with the amount, and another with the ID
   * /measurement_unit/money_value/currency and an ID value with the MID of the
   * proper currency. May only be set if is_free is false.
   */
  price?: FreebaseTopic[];
  /**
   * Upper bound for durations to match, exclusive. Unset implies indefinite.
   */
  rangeEndSeconds?: number;
  /**
   * Lower bound for durations to match, inclusive. Required; a value of 0
   * expresses that the price applies from the start of the utilization period.
   */
  rangeStartSeconds?: number;
}

function serializeGeostoreDurationBasedRateProto(data: any): GeostoreDurationBasedRateProto {
  return {
    ...data,
    price: data["price"] !== undefined ? data["price"].map((item: any) => (serializeFreebaseTopic(item))) : undefined,
  };
}

function deserializeGeostoreDurationBasedRateProto(data: any): GeostoreDurationBasedRateProto {
  return {
    ...data,
    price: data["price"] !== undefined ? data["price"].map((item: any) => (deserializeFreebaseTopic(item))) : undefined,
  };
}

/**
 * Represents raster digital elevation model data.
 */
export interface GeostoreElevationModelProto {
  /**
   * Defines the relative order in which terrain data should be rendered.
   * Features with higher blend_order should be blended on top of features with
   * lower blend_order. NOTE: this is backwards from the way BlendRank works in
   * Magrathean.
   */
  blendOrder?: number;
  /**
   * The zoom level at which this data is defined. Level 0 is world level data,
   * and each increase in zoom level corresponds to a factor of 2 increase in
   * scale.
   */
  dataLevel?: number;
  /**
   * The maximum (finest) level at which this terrain data has sufficient
   * resolution to be displayed.
   */
  dataMaxlevel?: number;
  /**
   * A place to store an elevation data protocol buffer. Currently, this must
   * be a keyhole::AssetTileCompressed (see
   * google3/keyhole/common/proto/magrathean.protodevel).
   */
  elevationData?: Proto2BridgeMessageSet;
  /**
   * If true, all of the data contained in this feature is available at the
   * next highest (more detailed) level. If this is true,
   * partial_child_data_available should also be true.
   */
  fullChildDataAvailable?: boolean;
  /**
   * If true, at least part of the data contained in this feature is available
   * at the next highest (more detailed) level.
   */
  partialChildDataAvailable?: boolean;
}

/**
 * This protocol buffer holds elevation and related data.
 */
export interface GeostoreElevationProto {
  /**
   * The average elevation of the feature in meters above the local mean sea
   * level.
   */
  averageElevationMeters?: number;
  /**
   * Additional details for TYPE_PEAK and TYPE_VOLCANO features.
   */
  peak?: GeostorePeakProto;
}

/**
 * This protocol buffer holds entrance-specific attributes for features of type
 * TYPE_ENTRANCE.
 */
export interface GeostoreEntranceProto {
  allowance?:  | "ENTER_AND_EXIT" | "ENTER_ONLY" | "EXIT_ONLY";
  /**
   * DEPRECATED. Please use enter_or_exit instead.
   */
  canEnter?: boolean;
  /**
   * Whether the target can be entered through this entrance. Whether the
   * target can be exited through this entrance.
   */
  canExit?: boolean;
}

/**
 * Models a relationship between a feature and its entrance or exit.
 */
export interface GeostoreEntranceReferenceProto {
  /**
   * Feature ID of the related entrance. References should refer to
   * TYPE_ENTRANCE or TYPE_COMPOUND features that are entrances or exits of the
   * referencing feature.
   */
  featureId?: GeostoreFeatureIdProto;
}

function serializeGeostoreEntranceReferenceProto(data: any): GeostoreEntranceReferenceProto {
  return {
    ...data,
    featureId: data["featureId"] !== undefined ? serializeGeostoreFeatureIdProto(data["featureId"]) : undefined,
  };
}

function deserializeGeostoreEntranceReferenceProto(data: any): GeostoreEntranceReferenceProto {
  return {
    ...data,
    featureId: data["featureId"] !== undefined ? deserializeGeostoreFeatureIdProto(data["featureId"]) : undefined,
  };
}

/**
 * This protocol buffer holds establishment-specific attributes for features of
 * type TYPE_ESTABLISHMENT.
 */
export interface GeostoreEstablishmentProto {
  /**
   * Reference to BizBuilder data for this establishment. The
   * bizbuilder_reference field indicates that a feature is claimed in CBDB
   * (with the canonical state in MapFacts). The bizbuilder_reference is
   * different from the social_reference's claimed_gaia_id because some
   * BizBuilder clients will not have +Pages. All claimed businesses should have
   * a bizbuilder_reference.
   */
  bizbuilderReference?: GeostoreBizBuilderReferenceProto;
  /**
   * Regular opening hours for the establishment (weekly schedule).
   */
  hours?: GeostoreTimeScheduleProto;
  /**
   * Opening hours for this establishment, including regular weekly hours and
   * exceptional hours (e.g. on holidays). NOTE: in practice, only the
   * exceptional hours are filled in this message. A schema migration for
   * regular weekly hours was planned back in 2015 (see b/23105782) but was not
   * completed and is (as of May 2018) not prioritized. Clients should continue
   * getting regular opening hours from the `hours` field above. In
   * openinghours.h there is a utility function `GetOpeningHoursFromFeature`
   * that merges `EstablishmentProto.hours` into this proto.
   */
  openingHours?: GeostoreOpeningHoursProto;
  /**
   * Pricing for products and services offered. Example: menus for restaurants.
   */
  priceInfo?: GeostorePriceInfoProto;
  serviceArea?: GeostoreServiceAreaProto;
  /**
   * Telephone number and related information.
   */
  telephone?: GeostoreTelephoneProto[];
  /**
   * ** DEPRECATED ** This is deprecated in favor of the top-level (in
   * FeatureProto) set of GConcepts. The type of establishment -- see comments
   * above.
   */
  type?:  | "TYPE_ANY" | "TYPE_UNDEFINED" | "TYPE_DEPRECATED_AVIATION" | "TYPE_BUSINESS" | "TYPE_TRAVEL_SERVICE" | "TYPE_LODGING" | "TYPE_HOTEL" | "TYPE_RESORT" | "TYPE_MOTEL" | "TYPE_HOSTEL" | "TYPE_GUESTHOUSE" | "TYPE_VACATION_RENTAL" | "TYPE_GAS_STATION" | "TYPE_REST_AREA" | "TYPE_CASH_MACHINE" | "TYPE_CAR_RENTAL" | "TYPE_CAR_REPAIR" | "TYPE_TAXI_STAND" | "TYPE_TRAVEL_AGENT" | "TYPE_BICYCLE_RENTAL_POINT" | "TYPE_ELECTRIC_VEHICLE_CHARGING_STATION" | "TYPE_SHOPPING" | "TYPE_GROCERY" | "TYPE_ANTIQUES" | "TYPE_APPAREL" | "TYPE_GIFTS" | "TYPE_JEWELRY" | "TYPE_SPORTING_GOODS" | "TYPE_VEHICLE" | "TYPE_SHOPPING_CENTER" | "TYPE_SUPERMARKET" | "TYPE_FAIRGROUNDS" | "TYPE_MARKET" | "TYPE_PRODUCE_MARKET" | "TYPE_FARMERS_MARKET" | "TYPE_LIQUOR_STORE" | "TYPE_SOUVENIR_SHOP" | "TYPE_INDUSTRIAL" | "TYPE_CONSTRUCTION" | "TYPE_BUILDING_MATERIAL" | "TYPE_SECURITY_PRODUCTS" | "TYPE_MECHANICAL" | "TYPE_TEXTILE" | "TYPE_CHEMICAL" | "TYPE_METAL" | "TYPE_TRANSPORTATION" | "TYPE_FREIGHT" | "TYPE_AVIATION" | "TYPE_COURIER" | "TYPE_MOVING" | "TYPE_PACKAGING" | "TYPE_RAIL" | "TYPE_PUBLIC_TRANSIT" | "TYPE_WAREHOUSE" | "TYPE_DEFENSE" | "TYPE_AGRICULTURE" | "TYPE_PLANTATION" | "TYPE_PLANT_NURSERY" | "TYPE_DESIGN" | "TYPE_UTILITIES" | "TYPE_POWER_PLANT" | "TYPE_SEWAGE_TREATMENT_PLANT" | "TYPE_WATER_TREATMENT_PLANT" | "TYPE_SUBSTATION" | "TYPE_MANUFACTURING" | "TYPE_BIOTECH" | "TYPE_MATERIALS" | "TYPE_MINING" | "TYPE_QUARRY" | "TYPE_TANNERY" | "TYPE_OIL_REFINERY" | "TYPE_ADVERTISING_MARKETING" | "TYPE_LEGAL" | "TYPE_FAMILY_LAW" | "TYPE_IP_LAW" | "TYPE_LABOR_LAW" | "TYPE_PERSONAL_INJURY_LAW" | "TYPE_CRIMINAL_LAW" | "TYPE_PERSONAL_FINANCE" | "TYPE_LIFE_INSURANCE" | "TYPE_LENDING" | "TYPE_ACCOUNTING" | "TYPE_INVESTING" | "TYPE_BANKING" | "TYPE_HEALTH" | "TYPE_HEALTH_EQUIPMENT" | "TYPE_NURSING" | "TYPE_HEALTH_INSURANCE" | "TYPE_HEALTH_FACILITY" | "TYPE_DIAGNOSTIC_CENTER" | "TYPE_HEALTH_RESOURCES" | "TYPE_NUTRITION" | "TYPE_VISION" | "TYPE_COUNSELING" | "TYPE_MASSAGE" | "TYPE_BLOOD_BANK" | "TYPE_HEARING" | "TYPE_HOME_GARDEN" | "TYPE_INTERIOR_DECOR" | "TYPE_DOMESTIC_SERVICES" | "TYPE_APPLIANCES" | "TYPE_PEST_CONTROL" | "TYPE_GARDENING" | "TYPE_ELECTRONICS" | "TYPE_COMPUTER" | "TYPE_COMPUTER_HARDWARE" | "TYPE_COMPUTER_SECURITY" | "TYPE_COMPUTER_SOFTWARE" | "TYPE_COMPUTER_SUPPORT" | "TYPE_AUDIO_DEVICES" | "TYPE_VIDEO_DEVICES" | "TYPE_REAL_ESTATE" | "TYPE_OFFICE_SERVICES" | "TYPE_ENTERTAINMENT" | "TYPE_GAMES" | "TYPE_CASINO" | "TYPE_LOTTO" | "TYPE_VIDEO" | "TYPE_CLUBS" | "TYPE_DISCOTHEQUE" | "TYPE_ANIMATION" | "TYPE_MODELING" | "TYPE_HUMOR" | "TYPE_MOVIES" | "TYPE_MOVIE_RENTAL" | "TYPE_MOVIE_THEATER" | "TYPE_MUSIC" | "TYPE_RADIO" | "TYPE_TV" | "TYPE_BAR" | "TYPE_PRINT_MEDIA" | "TYPE_ADULT" | "TYPE_SEXUAL_SERVICES" | "TYPE_ANIMALS" | "TYPE_PETS" | "TYPE_FISHERY" | "TYPE_ARTS" | "TYPE_BOOKS" | "TYPE_PERFORMING_ARTS" | "TYPE_GALLERY" | "TYPE_AUTOMOTIVE" | "TYPE_PARTS" | "TYPE_AUTO_FINANCE" | "TYPE_AUTO_INSURANCE" | "TYPE_RV" | "TYPE_MOTORCYCLES" | "TYPE_CARS" | "TYPE_TRUCKS_SUVS" | "TYPE_LICENSING" | "TYPE_MAINTENANCE" | "TYPE_PERSONAL_CARE" | "TYPE_BODY_ART" | "TYPE_COSMETICS" | "TYPE_FITNESS" | "TYPE_YOGA_CENTER" | "TYPE_GYM" | "TYPE_HAIR_CARE" | "TYPE_SPA" | "TYPE_BEAUTY_SALON" | "TYPE_CORPORATE_EVENTS" | "TYPE_HUMAN_RESOURCES" | "TYPE_FOOD_AND_DRINK" | "TYPE_BEVERAGE" | "TYPE_RECIPES" | "TYPE_COOKWARE" | "TYPE_CULINARY" | "TYPE_RETAIL" | "TYPE_RESTAURANT" | "TYPE_COFFEE" | "TYPE_BAKERY" | "TYPE_FOOD_CENTER" | "TYPE_TEA" | "TYPE_CAFE" | "TYPE_WINERY" | "TYPE_BREWERY" | "TYPE_FAST_FOOD" | "TYPE_FOOD_DELIVERY" | "TYPE_INTERNET" | "TYPE_WEB_DESIGN" | "TYPE_WEB_HOSTING" | "TYPE_WEB_SERVICES" | "TYPE_LIFESTYLE" | "TYPE_PHOTO_VIDEO" | "TYPE_ACTIVITIES" | "TYPE_BOATING" | "TYPE_CYCLING" | "TYPE_EQUESTRIAN" | "TYPE_FISHING" | "TYPE_HIKING" | "TYPE_HUNTING" | "TYPE_SWIMMING" | "TYPE_GOLF" | "TYPE_GOLF_COURSE" | "TYPE_BASEBALL" | "TYPE_BASKETBALL" | "TYPE_HOCKEY" | "TYPE_MOTOR_SPORTS" | "TYPE_WINTER_SPORTS" | "TYPE_FOOTBALL" | "TYPE_SOCCER" | "TYPE_ICE_SKATING" | "TYPE_BOXING" | "TYPE_CRICKET" | "TYPE_ROWING" | "TYPE_RUGBY" | "TYPE_RACQUET_SPORTS" | "TYPE_ROCK_CLIMBING" | "TYPE_REFERENCES" | "TYPE_MAPS" | "TYPE_TIME" | "TYPE_SCIENTIFIC_EQUIPMENT" | "TYPE_TELECOMMUNICATIONS" | "TYPE_EVENT_VENUE" | "TYPE_BANQUET_HALL" | "TYPE_CONFERENCE_HALL" | "TYPE_WEDDING_HALL" | "TYPE_EXHIBITION_HALL" | "TYPE_COMMUNITY_CENTER" | "TYPE_AUDITORIUM" | "TYPE_FUNCTION_HALL" | "TYPE_CONCERT_HALL" | "TYPE_AMPHITHEATER" | "TYPE_LAUNDRY" | "TYPE_LAUNDROMAT" | "TYPE_DRY_CLEANER" | "TYPE_MORTUARY" | "TYPE_REPAIR_AND_MAINTENANCE" | "TYPE_GOVERNMENT" | "TYPE_BORDER_CROSSING" | "TYPE_CITY_HALL" | "TYPE_COURTHOUSE" | "TYPE_EMBASSY" | "TYPE_LIBRARY" | "TYPE_PRISON" | "TYPE_TAX_OFFICE" | "TYPE_PROSECUTORS_OFFICE" | "TYPE_CONGRESS" | "TYPE_TOWN_COUNCIL" | "TYPE_CAPITOL_BUILDING" | "TYPE_VOTING_FACILITY" | "TYPE_CHECKPOINT" | "TYPE_SCHOOL" | "TYPE_UNIVERSITY" | "TYPE_ORPHANAGE" | "TYPE_KINDERGARTEN" | "TYPE_DAYCARE" | "TYPE_ACADEMY" | "TYPE_TRADE_SCHOOL" | "TYPE_SKILL_INSTRUCTION" | "TYPE_EMERGENCY" | "TYPE_HOSPITAL" | "TYPE_PHARMACY" | "TYPE_POLICE" | "TYPE_FIRE" | "TYPE_DOCTOR" | "TYPE_DENTIST" | "TYPE_VETERINARIAN" | "TYPE_FIRST_AID" | "TYPE_CIVIL_DEFENSE" | "TYPE_TOURIST_DESTINATION" | "TYPE_ECO_TOURIST_DESTINATION" | "TYPE_BIRD_WATCHING" | "TYPE_NATURE_RESERVE" | "TYPE_MUSEUM" | "TYPE_VISITOR_CENTER" | "TYPE_OBSERVATION_DECK" | "TYPE_OBSERVATORY" | "TYPE_SCENIC_POINT" | "TYPE_ZOO" | "TYPE_AQUARIUM" | "TYPE_AMUSEMENT_PARK" | "TYPE_MONUMENT" | "TYPE_PALACE" | "TYPE_FORT" | "TYPE_TOWER" | "TYPE_LIGHTHOUSE" | "TYPE_TEMPLE" | "TYPE_CHURCH" | "TYPE_GURUDWARA" | "TYPE_HINDU_TEMPLE" | "TYPE_MOSQUE" | "TYPE_SYNAGOGUE" | "TYPE_BUDDHIST_TEMPLE" | "TYPE_JAIN_TEMPLE" | "TYPE_BAHAI_TEMPLE" | "TYPE_SHINTO_TEMPLE" | "TYPE_MORMON_TEMPLE" | "TYPE_SPORTS_COMPLEX" | "TYPE_STADIUM" | "TYPE_BOWLING" | "TYPE_BADMINTON" | "TYPE_TENNIS" | "TYPE_TABLE_TENNIS" | "TYPE_PARK" | "TYPE_LOCAL_PARK" | "TYPE_NATIONAL_PARK" | "TYPE_US_NATIONAL_PARK" | "TYPE_US_NATIONAL_MONUMENT" | "TYPE_NATIONAL_FOREST" | "TYPE_NATIONAL_GRASSLAND" | "TYPE_NATIONAL_PRESERVE" | "TYPE_NATIONAL_RECREATION_AREA" | "TYPE_NATIONAL_MONUMENT" | "TYPE_NATIONAL_HISTORIC_AREA" | "TYPE_NATIONAL_SCENIC_AREA" | "TYPE_NATIONAL_SCENIC_ROADWAY_AREA" | "TYPE_NATIONAL_SCENIC_RIVER_AREA" | "TYPE_PROVINCIAL_PARK" | "TYPE_PROVINCIAL_FOREST" | "TYPE_CAMPGROUNDS" | "TYPE_WILDERNESS_AREA" | "TYPE_WILDLIFE_AREA" | "TYPE_BOTANICAL_GARDEN" | "TYPE_GARDEN" | "TYPE_ARBORETUM" | "TYPE_MARINE_PROTECTED_AREA" | "TYPE_AIRPORT" | "TYPE_TARMAC" | "TYPE_HELIPORT" | "TYPE_SEAPLANE_BASE" | "TYPE_MILITARY_AIRBASE" | "TYPE_CEMETERY" | "TYPE_MILITARY" | "TYPE_ENCLOSED_TRAFFIC_AREA" | "TYPE_PARKING" | "TYPE_OFF_ROAD_AREA" | "TYPE_POST_OFFICE" | "TYPE_HOUSING_DEVELOPMENT" | "TYPE_BRIDGE" | "TYPE_ARCHAEOLOGICAL" | "TYPE_HISTORICAL" | "TYPE_RUINS" | "TYPE_TUNNEL" | "TYPE_RESIDENTIAL_DWELLING" | "TYPE_DETACHED_DWELLING" | "TYPE_ATTACHED_DWELLING" | "TYPE_APARTMENT" | "TYPE_GATED_COMMUNITY" | "TYPE_RETIREMENT_HOME" | "TYPE_TOLL_BOOTH" | "TYPE_CULTURAL" | "TYPE_CULTURAL_CENTER" | "TYPE_OVERPASS" | "TYPE_REST_ROOM" | "TYPE_PUBLIC_PHONE" | "TYPE_PHONE_BOOTH" | "TYPE_MANNED_PCO" | "TYPE_RESEARCH_INSTITUTE" | "TYPE_NON_GOVERNMENTAL_ORGANIZATION" | "TYPE_OFFICE_PARK" | "TYPE_MEDITATION_CENTER" | "TYPE_RELIGIOUS" | "TYPE_MONASTERY" | "TYPE_ASHRAM" | "TYPE_PAGODA" | "TYPE_MISSION" | "TYPE_PILGRIM_DESTINATION" | "TYPE_SOCIAL_SERVICE" | "TYPE_RANGER_STATION" | "TYPE_TRANSIT_STATION" | "TYPE_BUS_STATION" | "TYPE_TRAMWAY_STATION" | "TYPE_TRAIN_STATION" | "TYPE_SUBWAY_STATION" | "TYPE_FERRY_TERMINAL" | "TYPE_CABLE_CAR_STATION" | "TYPE_GONDOLA_LIFT_STATION" | "TYPE_FUNICULAR_STATION" | "TYPE_HORSE_CARRIAGE_STATION" | "TYPE_MONORAIL_STATION" | "TYPE_SEAPORT" | "TYPE_NATURAL_FEATURE" | "TYPE_ELEVATED" | "TYPE_PEAK";
}

function serializeGeostoreEstablishmentProto(data: any): GeostoreEstablishmentProto {
  return {
    ...data,
    bizbuilderReference: data["bizbuilderReference"] !== undefined ? serializeGeostoreBizBuilderReferenceProto(data["bizbuilderReference"]) : undefined,
    priceInfo: data["priceInfo"] !== undefined ? serializeGeostorePriceInfoProto(data["priceInfo"]) : undefined,
    serviceArea: data["serviceArea"] !== undefined ? serializeGeostoreServiceAreaProto(data["serviceArea"]) : undefined,
    telephone: data["telephone"] !== undefined ? data["telephone"].map((item: any) => (serializeGeostoreTelephoneProto(item))) : undefined,
  };
}

function deserializeGeostoreEstablishmentProto(data: any): GeostoreEstablishmentProto {
  return {
    ...data,
    bizbuilderReference: data["bizbuilderReference"] !== undefined ? deserializeGeostoreBizBuilderReferenceProto(data["bizbuilderReference"]) : undefined,
    priceInfo: data["priceInfo"] !== undefined ? deserializeGeostorePriceInfoProto(data["priceInfo"]) : undefined,
    serviceArea: data["serviceArea"] !== undefined ? deserializeGeostoreServiceAreaProto(data["serviceArea"]) : undefined,
    telephone: data["telephone"] !== undefined ? data["telephone"].map((item: any) => (deserializeGeostoreTelephoneProto(item))) : undefined,
  };
}

/**
 * An ExceptionalHoursProto holds information about exceptional (non-regular)
 * hours for a business, such as holiday hours.
 */
export interface GeostoreExceptionalHoursProto {
  /**
   * The weekly schedule to be applied for the dates that fall within the
   * range. The schedule may contain hours only for days of the week that occur
   * during the date range specified in the range field.
   */
  hours?: GeostoreBusinessHoursProto;
  /**
   * Field-level metadata for this exception.
   */
  metadata?: GeostoreFieldMetadataProto;
  /**
   * The dates for which this exception applies, expressed as a half open
   * interval. For example, an exception that applies for the entire month of
   * December 2015 should have a range December 1, 2015 to January 1, 2016. Any
   * regular hours that start on days in this range are ignored and replaced by
   * the exceptional hours for that day. The TimeIntervalProto for the range
   * must be a fully specified, non-empty, and non-inverted range of dates.
   * Concretely, the requirements are: * the range must be a TYPE_RANGE interval
   * * the interval may not be inverted * the endpoints of the interval must
   * specify a year, month, and day * the day_type of each endpoint must be type
   * DAY_OF_MONTH * the endpoints may not specify hour, minute, second, week, or
   * week_type * the begin endpoint must predate the end endpoint
   */
  range?: GeostoreTimeIntervalProto;
}

export interface GeostoreExistenceProto {
  /**
   * Indicates whether the place is closed (permanently or temporarily), i.e.,
   * not operational in the present, but was at in the past and/or will be in
   * the future. WARNING: New code should use Geo Schema's libraries instead,
   * specifically the OpeningStatus APIs, available in: * C++
   * (cs/f:google3/geostore/base/public/feature.h%20function:ExistenceState) *
   * Java
   * (cs/f:google3/java/com/google/geostore/base/Existence.java%20function:OpeningStatus)
   * * Python
   * (cs/f:google3/geostore/base/public/python/feature.clif%20existence_state)
   */
  closed?: boolean;
  /**
   * Structured reason for the permanent closure (if any).
   */
  closeReason?:  | "CLOSED" | "MOVED" | "REBRANDED";
  /**
   * RESERVED
   */
  endAsOfDate?: GeostoreDateTimeProto;
  endDate?: GeostoreDateTimeProto;
  /**
   * ** DEPRECATED ** This field is now deprecated (see b/22878252). Please use
   * the Geo Schema GetFeatureBirthTimestamp() API to extract the birth
   * timestamp of a feature. The timestamp in seconds since the UNIX epoch
   * (January 1, 1970) when this feature becomes live in the Geo repository.
   * Different from start_date in that this is the birth date of Google's
   * representation of the place whereas start_date is the birth date of the
   * place in the physical world.
   */
  featureBirthTimestampSeconds?: bigint;
  /**
   * Indicates whether the feature is marked as removed in the Geo repository.
   * Removed features are still present in the Geo repository but are considered
   * to be in an inactive state (not valid for lint purposes, not retrievable
   * except explicitly by feature ID, etc.). NOTE: If you have access to a
   * complete FeatureProto, do NOT read this bit directly to find out whether a
   * feature is removed. Instead, rely on the IsFeatureRemoved() API, available
   * in C++ (geostore/base/public/feature.h) and Java
   * (geostore/base/Feature.java).
   */
  removed?: boolean;
  /**
   * Structured reason why the feature is marked as removed. Relevant only when
   * removed == true.
   */
  removedReason?:  | "UNKNOWN" | "BOGUS" | "PRIVATE" | "PRIVATE_MUST_PURGE" | "SPAM" | "UNSUPPORTED" | "PENDING" | "DUPLICATE" | "OLD_SCHEMA" | "REPLACED" | "ROLLED_BACK";
  /**
   * (Initial) opening and (permanent) closing dates of the establishment, such
   * that start_date is the first day open and end_date is the first day closed.
   * The only allowed precisions are PRECISION_DAY, PRECISION_MONTH,
   * PRECISION_YEAR. DateTimeProto.seconds should have the lowest legal value
   * for the desired date/time and precision. E.g. for PRECISION_MONTH,
   * 2019-02-15 21:10:30 is not valid, it should be 2019-02-01 00:00:00 instead.
   * NOTE: The start_date and end_date are stored in UTC but should be
   * interpreted as being in the local timezone. So clients should convert the
   * DateTimeProto to local (civil) time using UTC+0, and then treat the result
   * as local to the feature.
   */
  startDate?: GeostoreDateTimeProto;
}

function serializeGeostoreExistenceProto(data: any): GeostoreExistenceProto {
  return {
    ...data,
    featureBirthTimestampSeconds: data["featureBirthTimestampSeconds"] !== undefined ? String(data["featureBirthTimestampSeconds"]) : undefined,
  };
}

function deserializeGeostoreExistenceProto(data: any): GeostoreExistenceProto {
  return {
    ...data,
    featureBirthTimestampSeconds: data["featureBirthTimestampSeconds"] !== undefined ? BigInt(data["featureBirthTimestampSeconds"]) : undefined,
  };
}

/**
 * Provenance information for sub-fields of this feature.
 */
export interface GeostoreFeatureFieldMetadataProto {
  fieldProvenance?: GeostoreFeatureFieldMetadataProtoFieldProvenance[];
}

export interface GeostoreFeatureFieldMetadataProtoFieldProvenance {
  /**
   * Represents all fields for which this SourceInfo is valid. NOTE: Field
   * paths are rooted at FeatureProto level.
   */
  fieldPath?: GeostoreStableFieldPathProto[];
  provenance?: GeostoreProvenanceProto;
}

/**
 * Metadata related to the history of a given feature in the Geo repository.
 */
export interface GeostoreFeatureHistoryMetadataProto {
  /**
   * The timestamp (in microseconds since the UNIX epoch) when this feature
   * first went live in the Geo repository. Note that this has no relation to
   * the birth data of that geographical entity in the real world.
   */
  featureBirthTimestampUs?: bigint;
  /**
   * The timestamp (in microseconds since the UNIX epoch) of the last
   * modification to the feature. Note this includes attachment modifications.
   * The feature's initial creation is also considered as a modification. This
   * is useful for those that consume features via both listening to
   * notifications and reading from repository snapshots. This timestamp can be
   * used to decide whether a feature in the snapshot was already seen in a more
   * recent state through the notifications.
   */
  lastModificationTimestampUs?: bigint;
  /**
   * The timestamp (in microseconds since the UNIX epoch) of the deletion time
   * of the feature. If the feature is currently removed, this field gets
   * populated with the timestamp the feature first became removed after being
   * live (or being removed from beginning). This field won't be set if the
   * feature is live.
   */
  removalTimestampUs?: bigint;
}

function serializeGeostoreFeatureHistoryMetadataProto(data: any): GeostoreFeatureHistoryMetadataProto {
  return {
    ...data,
    featureBirthTimestampUs: data["featureBirthTimestampUs"] !== undefined ? String(data["featureBirthTimestampUs"]) : undefined,
    lastModificationTimestampUs: data["lastModificationTimestampUs"] !== undefined ? String(data["lastModificationTimestampUs"]) : undefined,
    removalTimestampUs: data["removalTimestampUs"] !== undefined ? String(data["removalTimestampUs"]) : undefined,
  };
}

function deserializeGeostoreFeatureHistoryMetadataProto(data: any): GeostoreFeatureHistoryMetadataProto {
  return {
    ...data,
    featureBirthTimestampUs: data["featureBirthTimestampUs"] !== undefined ? BigInt(data["featureBirthTimestampUs"]) : undefined,
    lastModificationTimestampUs: data["lastModificationTimestampUs"] !== undefined ? BigInt(data["lastModificationTimestampUs"]) : undefined,
    removalTimestampUs: data["removalTimestampUs"] !== undefined ? BigInt(data["removalTimestampUs"]) : undefined,
  };
}

/**
 * Feature ID forwardings. There are many different types of ID forwardings,
 * some of which are attached to live features, others to removed features. This
 * information is available in multiple forms (with different completeness
 * guarantees): (1) in RPC responses to read requests to the live Geo
 * repository; (2) on disk, as part of the metadata section of features found in
 * the (inactive) features snapshots; (3) on disk, as part of a separate
 * feature_id_forwardings side table.
 */
export interface GeostoreFeatureIdForwardingsProto {
  /**
   * If the feature has been marked as a DUPLICATE of another feature, this is
   * the feature ID of that other feature. Note that the other feature may
   * itself be removed. This field is NOT set in (1).
   */
  duplicateOf?: GeostoreFeatureIdProto;
  /**
   * The feature ID of the forwarded feature. This field is only set in case
   * (3).
   */
  forwardedId?: GeostoreFeatureIdProto;
  /**
   * If other features have been marked as DUPLICATE of this feature, this is
   * the set of all such feature IDs. All feature IDs in this set should be for
   * removed (aka inactive) features. Note that in the context of historical
   * read requests against MapFacts (when
   * ReadRequest.version_selection.timestamp is set), this field won't be set.
   */
  inactiveDuplicate?: GeostoreFeatureIdProto[];
  /**
   * DEPRECATED - Use feature.metadata.feature_replacement_info instead. This
   * field was never populated.
   */
  replacedBy?: GeostoreFeatureIdListProto;
  /**
   * If the feature has been transitively marked as a DUPLICATE of another
   * feature (via a chain of size >= 1), this is the feature ID of that other
   * feature which is the end of the chain. The field is always set even if the
   * chain is of size 1. Note that the other feature may itself be removed. This
   * field is only set in case (3).
   */
  transitivelyDuplicateOf?: GeostoreFeatureIdProto;
}

function serializeGeostoreFeatureIdForwardingsProto(data: any): GeostoreFeatureIdForwardingsProto {
  return {
    ...data,
    duplicateOf: data["duplicateOf"] !== undefined ? serializeGeostoreFeatureIdProto(data["duplicateOf"]) : undefined,
    forwardedId: data["forwardedId"] !== undefined ? serializeGeostoreFeatureIdProto(data["forwardedId"]) : undefined,
    inactiveDuplicate: data["inactiveDuplicate"] !== undefined ? data["inactiveDuplicate"].map((item: any) => (serializeGeostoreFeatureIdProto(item))) : undefined,
    replacedBy: data["replacedBy"] !== undefined ? serializeGeostoreFeatureIdListProto(data["replacedBy"]) : undefined,
    transitivelyDuplicateOf: data["transitivelyDuplicateOf"] !== undefined ? serializeGeostoreFeatureIdProto(data["transitivelyDuplicateOf"]) : undefined,
  };
}

function deserializeGeostoreFeatureIdForwardingsProto(data: any): GeostoreFeatureIdForwardingsProto {
  return {
    ...data,
    duplicateOf: data["duplicateOf"] !== undefined ? deserializeGeostoreFeatureIdProto(data["duplicateOf"]) : undefined,
    forwardedId: data["forwardedId"] !== undefined ? deserializeGeostoreFeatureIdProto(data["forwardedId"]) : undefined,
    inactiveDuplicate: data["inactiveDuplicate"] !== undefined ? data["inactiveDuplicate"].map((item: any) => (deserializeGeostoreFeatureIdProto(item))) : undefined,
    replacedBy: data["replacedBy"] !== undefined ? deserializeGeostoreFeatureIdListProto(data["replacedBy"]) : undefined,
    transitivelyDuplicateOf: data["transitivelyDuplicateOf"] !== undefined ? deserializeGeostoreFeatureIdProto(data["transitivelyDuplicateOf"]) : undefined,
  };
}

/**
 * A simple list of feature IDs.
 */
export interface GeostoreFeatureIdListProto {
  /**
   * The list of feature IDs. While the exact semantics of these IDs are
   * usage-dependent, the list should never be empty or contain duplicates.
   */
  id?: GeostoreFeatureIdProto[];
}

function serializeGeostoreFeatureIdListProto(data: any): GeostoreFeatureIdListProto {
  return {
    ...data,
    id: data["id"] !== undefined ? data["id"].map((item: any) => (serializeGeostoreFeatureIdProto(item))) : undefined,
  };
}

function deserializeGeostoreFeatureIdListProto(data: any): GeostoreFeatureIdListProto {
  return {
    ...data,
    id: data["id"] !== undefined ? data["id"].map((item: any) => (deserializeGeostoreFeatureIdProto(item))) : undefined,
  };
}

/**
 * A globally unique identifier associated with each feature. We use 128-bit
 * identifiers so that we have lots of bits available to distinguish between
 * features. The feature id currently consists of a 64-bit "cell id" that
 * **sometimes** corresponds to the approximate centroid of the feature, plus a
 * 64-bit fingerprint of other identifying information. See more on each
 * respective field in its comments. Feature ids are first assigned when the
 * data is created in MapFacts. After initial creation of the feature, they are
 * immutable. This means that the only properties that you should rely on are
 * that they are unique, and that cell_ids often - but not always - preserve
 * spatial locality. The degree of locality varies as the feature undergoes
 * geometry changes, and should not in general be considered a firm guarantee of
 * the location of any particular feature. In fact, some locationless features
 * have randomized cell IDs! Consumers of FeatureProtos from Mapfacts are
 * guaranteed that fprints in the id field of features will be globally unique.
 * Using the fprint allows consumers who don't need the spatial benefit of cell
 * ids to uniquely identify features in a 64-bit address space. This property is
 * not guaranteed for other sources of FeatureProtos.
 */
export interface GeostoreFeatureIdProto {
  /**
   * The S2CellId corresponding to the approximate location of this feature as
   * of when it was first created. This can be of variable accuracy, ranging
   * from the exact centroid of the feature at creation, a very large S2 Cell,
   * or even being completely randomized for locationless features. Cell ids
   * have the nice property that they follow a space-filling curve over the
   * surface of the earth. (See s2cellid.h for details.) WARNING: Clients should
   * only use cell IDs to perform spatial locality optimizations. There is no
   * strict guarantee that the cell ID of a feature is related to the current
   * geometry of the feature in any way.
   */
  cellId?: bigint;
  /**
   * A 64-bit fingerprint used to identify features. Most clients should rely
   * on MapFacts or OneRing to choose fingerprints. If creating new fprints, the
   * strategy should be chosen so that the chance of collision is remote or
   * non-existent, and the distribution should be reasonably uniform. For
   * example, if the source data assigns unique ids to features, then a
   * fingerprint of the provider name, version, and source id is sufficient.
   */
  fprint?: bigint;
  /**
   * A place for clients to attach arbitrary data to a feature ID. Never set in
   * MapFacts.
   */
  temporaryData?: Proto2BridgeMessageSet;
}

function serializeGeostoreFeatureIdProto(data: any): GeostoreFeatureIdProto {
  return {
    ...data,
    cellId: data["cellId"] !== undefined ? String(data["cellId"]) : undefined,
    fprint: data["fprint"] !== undefined ? String(data["fprint"]) : undefined,
  };
}

function deserializeGeostoreFeatureIdProto(data: any): GeostoreFeatureIdProto {
  return {
    ...data,
    cellId: data["cellId"] !== undefined ? BigInt(data["cellId"]) : undefined,
    fprint: data["fprint"] !== undefined ? BigInt(data["fprint"]) : undefined,
  };
}

/**
 * General metadata related to a given feature in the Geo repository.
 */
export interface GeostoreFeatureMetadataProto {
  /**
   * This field indicates whether the feature is subject to bulk updates.
   * Caution must be exercised while editing such features since the changes
   * made by the edits will be overwritten by the bulk update (if the feature is
   * bulk updated). See go/mapfacts-abu for more information.
   */
  bulkUpdatable?:  | "NOT_BULK_UPDATABLE" | "BULK_UPDATABLE";
  /**
   * core_version_token is an opaque token representing the version of the core
   * fields of the feature. This field is not updated when attachments are
   * changed.
   */
  coreVersionToken?: Uint8Array;
  /**
   * Metadata for tracking when a feature is derived from or replaced by
   * another feature or set of features.
   */
  featureReplacementInfo?: GeostoreFeatureReplacementInfoProto;
  /**
   * Metadata about certain repeated fields and their subfields, for which
   * field type is not granular enough.
   */
  fieldMetadata?: GeostoreFeatureFieldMetadataProto;
  /**
   * Feature ID forwardings, if applicable.
   */
  forwardings?: GeostoreFeatureIdForwardingsProto;
  /**
   * Metadata related to the history.
   */
  history?: GeostoreFeatureHistoryMetadataProto;
  /**
   * version_token is an opaque token representing the version of this feature.
   * It can be used as a concurrency token when sending edits.
   */
  versionToken?: Uint8Array;
}

function serializeGeostoreFeatureMetadataProto(data: any): GeostoreFeatureMetadataProto {
  return {
    ...data,
    coreVersionToken: data["coreVersionToken"] !== undefined ? encodeBase64(data["coreVersionToken"]) : undefined,
    featureReplacementInfo: data["featureReplacementInfo"] !== undefined ? serializeGeostoreFeatureReplacementInfoProto(data["featureReplacementInfo"]) : undefined,
    forwardings: data["forwardings"] !== undefined ? serializeGeostoreFeatureIdForwardingsProto(data["forwardings"]) : undefined,
    history: data["history"] !== undefined ? serializeGeostoreFeatureHistoryMetadataProto(data["history"]) : undefined,
    versionToken: data["versionToken"] !== undefined ? encodeBase64(data["versionToken"]) : undefined,
  };
}

function deserializeGeostoreFeatureMetadataProto(data: any): GeostoreFeatureMetadataProto {
  return {
    ...data,
    coreVersionToken: data["coreVersionToken"] !== undefined ? decodeBase64(data["coreVersionToken"] as string) : undefined,
    featureReplacementInfo: data["featureReplacementInfo"] !== undefined ? deserializeGeostoreFeatureReplacementInfoProto(data["featureReplacementInfo"]) : undefined,
    forwardings: data["forwardings"] !== undefined ? deserializeGeostoreFeatureIdForwardingsProto(data["forwardings"]) : undefined,
    history: data["history"] !== undefined ? deserializeGeostoreFeatureHistoryMetadataProto(data["history"]) : undefined,
    versionToken: data["versionToken"] !== undefined ? decodeBase64(data["versionToken"] as string) : undefined,
  };
}

/**
 * Message to represent a "feature property" as an abstract construct. Most
 * feature properties are mapped one to one with the EditProto field types.
 * However in some cases the EditProto field type granularity is too coarse to
 * support use-cases that rely on feature properties (such as per-value rights
 * tracking). When that is the case, the feature property is augmented with a
 * secondary field.
 */
export interface GeostoreFeaturePropertyIdProto {
  /**
   * Required when field_type == ATTACHMENT.
   */
  attachmentTypeId?: bigint;
  /**
   * Required when field_type == FEATURE_ATTRIBUTE.
   */
  attributeId?: string;
  fieldType?:  | "NONE" | "ACCESS_POINT" | "ADDRESS" | "ANCHORED_GEOMETRY_GEOMETRY_ID" | "ATTACHMENT" | "BIZBUILDER_REFERENCE" | "BORDER_FEATURE_ID_LEFT" | "BORDER_FEATURE_ID_RIGHT" | "BORDER_OVERRIDE_STATUS" | "BORDER_STATUS" | "BORDER_TYPE" | "BORDER_LOGICAL_BORDER" | "BOUND" | "BUILDING_BASE_HEIGHT_METERS_AGL" | "BUILDING_DEFAULT_DISPLAY_LEVEL" | "BUILDING_FLOORS" | "BUILDING_HEIGHT_METERS" | "BUILDING_LEVEL" | "BUILDING_STRUCTURE" | "BUSINESS_CHAIN_CANONICAL_GCONCEPT" | "BUSINESS_HOURS" | "DATA_SOURCE" | "DISPLAY_DATA" | "ENTRANCE_ALLOWANCE" | "ESTABLISHMENT_OPENING_HOURS_EXCEPTION" | "ESTABLISHMENT_OPENING_HOURS_REGULAR_HOURS" | "ESTABLISHMENT_PRICE_INFO" | "ESTABLISHMENT_SERVICE_AREA_SERVED_FEATURE" | "EXISTENCE_STATUS" | "FEATURE_AVERAGE_ELEVATION" | "FEATURE_BEST_LOCALE" | "FEATURE_CELL_COVERING" | "FEATURE_CENTER" | "FEATURE_CHILD" | "FEATURE_EXEMPT_REGULATED_AREA" | "FEATURE_INTERIOR_CELL_COVERING" | "FEATURE_NAME" | "FEATURE_PARENT" | "FEATURE_POSE" | "FEATURE_PREFERRED_VIEWPORT" | "FEATURE_TRACK" | "FEATURE_TYPE" | "FEATURE_WEBSITE" | "FIELD_RIGHTS" | "FUTURE_GEOMETRY" | "FUTURE_GEOMETRY_FOR" | "GCONCEPT" | "GEOMETRY_PRECISION_METERS" | "GEOPOLITICAL_GEOMETRY_REST_OF_WORLD_POLYGON" | "GEOPOLITICAL_GEOMETRY_SELF_POLYGON" | "INFERRED_GEOMETRY_GEOMETRY_COMPOSITION" | "INFERRED_GEOMETRY_DEFINES_GEOMETRY_FOR" | "INTERSECTION" | "INTERSECTION_GROUP" | "INTERSECTION_GROUP_CHILD_GROUP" | "INTERSECTION_GROUP_GROUP_TYPE" | "INTERSECTION_GROUP_PARENT_GROUP" | "INTERSECTION_IN_GROUP" | "INTERSECTION_TOLL_CLUSTER" | "IN_SEGMENT" | "KNOWLEDGE_GRAPH_PROPERTY" | "LABEL_BACKGROUND_COLOR" | "LABEL_TEXT_COLOR" | "LANE_MARKER_BARRIER_MATERIALS" | "LANE_MARKER_CROSSING_PATTERN" | "LANE_MARKER_LINEAR_PATTERN" | "LEVEL_BUILDING" | "LEVEL_NUMBER" | "LOCALE_LANGUAGE" | "LOCALE_LOCALIZATION_POLICY_ID" | "LOGICAL_BORDER_BORDER_SEGMENT" | "LOGICAL_BORDER_STATUS" | "OPERATIONS_TEMPORARY_CLOSURE" | "PARKING_ALLOWANCE" | "PARKING_AVAILABLE" | "PARKING_OPENING_HOURS_EXCEPTION" | "PARKING_OPENING_HOURS_REGULAR_HOURS" | "PARKING_PROVIDER_FEATURE" | "PARKING_RESTRICTION" | "PEAK_PROMINENCE" | "PHONE_NUMBER" | "POINT" | "POLYGON" | "POLYGON_FOR_DISPLAY" | "POLYLINE" | "RANK" | "RANK_SIGNAL" | "REGULATED_AREA_RESTRICTION" | "RELATED_BORDER" | "RELATED_ENTRANCE" | "RELATED_FEATURE" | "RELATED_TERMINAL_POINT" | "RELATED_TIMEZONE" | "RESTRICTION_GROUP_SEGMENT" | "ROAD_MONITOR_MONITORED_ROAD" | "ROUTE_CHILD_TYPE" | "SCHOOL_DISTRICT_TYPE" | "SEGMENT_ADVISORY_MAXIMUM_SPEED" | "SEGMENT_AVERAGE_SPEED" | "SEGMENT_BARRIER" | "SEGMENT_BICYCLE_FACILITY" | "SEGMENT_BICYCLE_SAFETY" | "SEGMENT_CONDITION" | "SEGMENT_CONSTRUCTION_BEGIN_DATE" | "SEGMENT_CONSTRUCTION_END_DATE" | "SEGMENT_CONSTRUCTION_STATUS" | "SEGMENT_COVERED" | "SEGMENT_DISTANCE_TO_EDGE" | "SEGMENT_EDGE_FOLLOWS_SEGMENT_BEGIN_FRACTION" | "SEGMENT_EDGE_FOLLOWS_SEGMENT_END_FRACTION" | "SEGMENT_ELEVATION" | "SEGMENT_ENDPOINT" | "SEGMENT_GRADE_LEVEL_LIST" | "SEGMENT_INTERNAL_TRAVEL_ALLOWANCE" | "SEGMENT_INTERPOLATION_OFFSET_METERS" | "SEGMENT_IS_MAX_PERMITTED_SPEED_DERIVED" | "SEGMENT_LANE" | "SEGMENT_LEGAL_MAXIMUM_SPEED" | "SEGMENT_LEGAL_MINIMUM_SPEED" | "SEGMENT_MAX_SPEED" | "SEGMENT_ON_RIGHT" | "SEGMENT_PATH" | "SEGMENT_PEDESTRIAN_CROSSING" | "SEGMENT_PEDESTRIAN_FACILITY" | "SEGMENT_PEDESTRIAN_GRADE" | "SEGMENT_PRIORITY" | "SEGMENT_RESTRICTION" | "SEGMENT_ROAD_CAMERA" | "SEGMENT_ROAD_SIGN" | "SEGMENT_ROUTE" | "SEGMENT_ROUTE_ASSOCIATION" | "SEGMENT_SEPARATED_ROADWAYS" | "SEGMENT_SLOPE" | "SEGMENT_SURFACE" | "SEGMENT_SWEEP" | "SEGMENT_TOLL_ROAD" | "SEGMENT_USAGE" | "SEGMENT_VISIBLE_LANDMARK" | "SIGN_COMPONENT" | "SOCIAL_REFERENCE_CLAIMED_GAIA_ID" | "SOURCE_INFO" | "STATUS_CLOSED" | "STATUS_CLOSE_REASON" | "STATUS_END_AS_OF_DATE" | "STATUS_END_DATE" | "STATUS_REMOVED" | "STATUS_REMOVED_REASON" | "STATUS_START_DATE" | "STOREFRONT_GEOMETRY" | "SYNTHETIC_GEOMETRY" | "THREE_DIMENSIONAL_MODEL" | "TOLL_CLUSTER_INTERSECTION" | "TRANSIT_LINE_AGENCY" | "TRANSIT_LINE_STATION" | "TRANSIT_LINE_VARIANT_LINE_CONCEPT" | "TRANSIT_LINE_VARIANT_STOP" | "TRANSIT_LINE_VEHICLE_TYPE" | "TRANSIT_STATION_AGENCY" | "VERTICAL_ORDERING_LEVEL" | "WATER_REMOVED_POLYGON" | "DEPRECATED_DO_NOT_USE_EMAIL_ADDRESS" | "DEPRECATED_DO_NOT_USE_RANK_GEOMETRY" | "DEPRECATED_DO_NOT_USE_SEGMENT_INFO" | "DEPRECATED_DO_NOT_USE_SEGMENT_LANE_LIST" | "DEPRECATED_DO_NOT_USE_SEGMENT_WRONG_WAY" | "DEPRECATED_DO_NOT_USE_WEBSITE" | "FEATURE_ATTRIBUTE" | "SOCIAL_REFERENCE" | "CATEGORY" | "DEPRECATED_DO_NOT_USE_CAPITAL" | "DEPRECATED_DO_NOT_USE_DESCRIPTION" | "DEPRECATED_DO_NOT_USE_DISTINCT" | "DEPRECATED_DO_NOT_USE_DUPLICATE" | "EDIT_PRECEDENCE" | "DEPRECATED_DO_NOT_USE_EDIT_PRECEDENCE" | "DEPRECATED_DO_NOT_USE_ENTRANCE_TARGET" | "DEPRECATED_DO_NOT_USE_ESTABLISHMENT_PLACE_ACTION_PAGE" | "DEPRECATED_DO_NOT_USE_ESTABLISHMENT_TYPE" | "DEPRECATED_DO_NOT_USE_EVENT" | "DEPRECATED_DO_NOT_USE_GEOMETRIC_ACCURACY" | "DEPRECATED_DO_NOT_USE_HIGHEST_GRADE" | "DEPRECATED_DO_NOT_USE_ID_TO_OVERRIDE" | "DEPRECATED_DO_NOT_USE_ISSUE_HISTORY" | "DEPRECATED_DO_NOT_USE_ISSUE_METADATA" | "DEPRECATED_DO_NOT_USE_KNOWLEDGE_GRAPH_ID" | "DEPRECATED_DO_NOT_USE_LOWEST_GRADE" | "DEPRECATED_DO_NOT_USE_PAYMENT_TYPES" | "DEPRECATED_DO_NOT_USE_PHOTO" | "DEPRECATED_DO_NOT_USE_PHOTO_URL" | "DEPRECATED_DO_NOT_USE_PLACE_CLOSED" | "DEPRECATED_DO_NOT_USE_POPULATION" | "DEPRECATED_DO_NOT_USE_RANK_USER" | "DEPRECATED_DO_NOT_USE_REMOVE_DUPLICATE" | "DEPRECATED_DO_NOT_USE_REMOVE_PLACE" | "DEPRECATED_DO_NOT_USE_SCHOOL_TYPE" | "DEPRECATED_DO_NOT_USE_SEGMENT_ELEVATION_BEGIN" | "DEPRECATED_DO_NOT_USE_SEGMENT_ELEVATION_END" | "DEPRECATED_DO_NOT_USE_SEGMENT_ELEVATION_MIDDLE" | "DEPRECATED_DO_NOT_USE_SYLLABUS" | "DEPRECATED_DO_NOT_USE_TRACK_CLASS" | "DEPRECATED_DO_NOT_USE_VIEWCODE_INFO" | "DEPRECATED_DO_NOT_USE_WORKAREA" | "DEPRECATED_DO_NOT_USE_INFERRED_GEOMETRY_INCLUDES_GEOMETRY_OF" | "DEPRECATED_DO_NOT_USE_INFERRED_GEOMETRY_EXCLUDES_GEOMETRY_OF";
  /**
   * Required when field_type == KNOWLEDGE_GRAPH_PROPERTY.
   */
  kgPropertyId?: string;
  /**
   * RESERVED
   */
  nameLanguage?: string;
}

function serializeGeostoreFeaturePropertyIdProto(data: any): GeostoreFeaturePropertyIdProto {
  return {
    ...data,
    attachmentTypeId: data["attachmentTypeId"] !== undefined ? String(data["attachmentTypeId"]) : undefined,
  };
}

function deserializeGeostoreFeaturePropertyIdProto(data: any): GeostoreFeaturePropertyIdProto {
  return {
    ...data,
    attachmentTypeId: data["attachmentTypeId"] !== undefined ? BigInt(data["attachmentTypeId"]) : undefined,
  };
}

/**
 * Every entry in the GeoStore database is called a "feature". A feature is
 * represented as a discriminated union of all the different feature types,
 * where the actual feature type is specified by the "type" field. There are
 * also various fields that are meaningful for most or all feature types, such
 * as bounding regions and names. Every feature has a globally unique id that
 * can be used to refer to it from other features.
 */
export interface GeostoreFeatureProto {
  /**
   * Optional access point information. Access points hold detailed information
   * about routing endpoints. For example, the main Google office is at "1600
   * Amphitheatre Parkway". The feature representing that office has a polygon,
   * a center, and an address with components for the street number, route,
   * locality, etc. The access point information, on the other hand, identifies
   * the specific segment, the latitude/longitude of the driveway, and so forth.
   */
  accessPoint?: GeostoreAccessPointProto[];
  /**
   * Address for this feature. A Geo Schema address is designed to model a
   * mailing address, so only features that have mailing addresses in the real
   * world may have addresses. Each feature should have only one address. If you
   * want to describe the geographic location of a feature which does not have a
   * mailing address with respect to other well-known features, some other
   * schema constructs should be used. Note that the field is defined as
   * repeated though features that use this field with its intended semantics
   * are constrained to have a single address even if they may have multiple
   * mailing addresses in the real world. The “single address” rule is enforced
   * by lint. Current exceptions to the single address rule and mailing address
   * rule are described in the g3doc. Bear note that the schema team is actively
   * working on eliminating these exceptions. http://go/geo-addresses Note the
   * following conventions: - Addresses follow the postal hierarchy, not the
   * political hierarchy. Addresses may have components that refer to political
   * entities when those entities also appear in the postal hierarchy. - As
   * stated previously, but it bears repeating, addresses on features are
   * mailing addresses. In many cases the physical address and the mailing
   * address are the same but the address stored on a feature represents the
   * mailing address of the feature. An example of a non-physical mailing
   * address would be a PO Box. - These addresses are commonly defined and
   * verifiable by a governmental authority (e.g. the United States Postal
   * Service in the United States, Royal Mail in the United Kingdom, Correios in
   * Brazil, etc.) and should follow conventions and rules defined by those
   * authorities.
   */
  address?: GeostoreAddressProto[];
  /**
   * Represents information about the feature’s anchored geometry.
   */
  anchoredGeometry?: GeostoreAnchoredGeometryProto;
  /**
   * The collection of attachments for this feature. Documentation:
   * http://go/geo-attachments
   */
  attachment?: GeostoreAttachmentsAttachmentProto[];
  /**
   * ** DEPRECATED ** A list of attributes that describe defined aspects of
   * this feature. An attribute must be a concrete, high quality, and editable
   * piece of information about a feature, and must be used on some general
   * consumer facing Google property. The data types used for attributes must be
   * primitive types or reusable in a generic manner.
   */
  attribute?: GeostoreAttributeProto[];
  /**
   * Describes the best-match locale for this feature.
   */
  bestLocale?: GeostoreBestLocaleProto;
  border?: GeostoreBorderProto;
  /**
   * A latitude-longitude rectangle used by bucketing MapReduces. See the
   * documentation on bucketing MapReduce for details. This field can be a
   * source of confusion. Because it is called "bound", it is often assumed that
   * it is a tight bound on the geometry but it can be (and often is) much
   * larger. If a tight bound is needed then use the standard
   * GetFeatureGeometryBound() function instead. To be more explicit, if you are
   * using this field for *anything* else than a bucketing MapReduce, you are
   * doing the wrong thing. Not all features are required to have bounding
   * boxes. See geostore::IsBoundRequiredForFeatureType() for the list of
   * feature types required to have a bounding box. This bound field will be
   * updated when a feature changes in MapFacts to include its geometry. Also, a
   * GeoSchema pipeline, go/geo-schema-pipelines-docs#expand-bounds runs
   * periodically to update the field for strong references from other features.
   * Therefore, most editors don't need to edit this field explicitly. See
   * go/geo-changes:no-edit-for-feature-bound for the details.
   */
  bound?: GeostoreRectProto;
  building?: GeostoreBuildingProto;
  /**
   * Data specific to business chain features, e.g., Canonical GConcepts.
   */
  businessChain?: GeostoreBusinessChainProto;
  /**
   * The conceptual center of the feature, used for routing. For cities, this
   * would be the center of the downtown, or maybe the location of city hall.
   * For states and countries it might be the capital city. Most feature types
   * will not have a conceptual center - by default, routing will use the
   * centroid of the feature's geometry. If you need a feature center point
   * consider using GetFeatureGeometryCenter() function from
   * geostore/base/public/feature.h rather than reading from this field
   * directly.
   */
  center?: GeostorePointProto;
  /**
   * Features can define themselves as a collection of other features. For
   * example, a route is a collection of road segments, and a feature for the
   * "Great Lakes" could be defined as lakes Superior, Michigan, Huron, Erie,
   * and Ontario. It is not recommended to design a multi level tree using the
   * child field to build up a feature because it requires fetching many
   * features to see the details of the feature. In practice this is used to
   * model archipelago, route, transit (agencies, lines, trips, departures), and
   * river features. The geometry of a feature is implicitly defined by its
   * children, so if a feature has children then it should not have any points,
   * polylines, or polygons. In general, this field should not be used to
   * represent political or postal hierarchies. For example, a county would not
   * list its cities as children, because the county is not defined in terms of
   * its cities (it also contains unincorporated areas, etc.).
   */
  child?: GeostoreFeatureIdProto[];
  /**
   * S2 cell coverings for this feature. See util/geometry/s2cell_union.h for
   * more information about S2 cells. Coverings are useful for quick containment
   * or intersection tests. S2 covering that consists of cells that intersect
   * with the feature.
   */
  covering?: GeostoreCellCoveringProto;
  dataSource?: GeostoreDataSourceProto;
  /**
   * Data used to render this feature on a map.
   */
  displayData?: GeostoreDisplayDataProto;
  /**
   * ** DEPRECATED **
   */
  doodle?: GeostoreDoodleProto;
  elevation?: GeostoreElevationProto;
  /**
   * Captures elevation data used on TYPE_DIGITAL_ELEVATION_MODEL features.
   */
  elevationModel?: GeostoreElevationModelProto;
  entrance?: GeostoreEntranceProto;
  /**
   * Also allowed on TYPE_BUSINESS_CHAIN and TYPE_TRANSIT_AGENCY features, to
   * model the feature's phone number(s). Other fields within EstablishmentProto
   * are not permitted on non-TYPE_ESTABLISHMENT features.
   */
  establishment?: GeostoreEstablishmentProto;
  /**
   * A list of feature ids of polygon based restrictions that do not apply to
   * this feature. This may only include features of TYPE_REGULATED_AREA that
   * also have a feature.regulated_area.restriction field defined. Setting this
   * field opts the feature out of all restrictions set on that regulated area.
   */
  exemptRegulatedArea?: GeostoreFeatureIdProto[];
  /**
   * Specifies the TYPE_FUTURE_GEOMETRY whose geometry will replace this
   * feature's geometry. If this field is populated, the referenced future
   * geometry must have a future_geometry_for referencing this feature.
   */
  futureGeometry?: GeostoreFeatureIdProto;
  /**
   * Specifies the feature that this feature's geometry will replace. If this
   * field is populated, the referenced feature must have a future_geometry
   * reference back to this feature. This field is only allowed (and required)
   * for TYPE_FUTURE_GEOMETRY features.
   */
  futureGeometryFor?: GeostoreFeatureIdProto;
  /**
   * If set, the feature's actual location can be assumed to be somewhere
   * within a circle of this radius, centered on the feature's location. More
   * information on this field at go/gpm-definition-update. NOTE: Only
   * applicable to features with 'point' geometry. Please contact
   * geo-schema-team@ if you have non-point use cases for which this field would
   * be useful.
   */
  geometryPrecisionMeters?: number;
  /**
   * Geopolitical (unsimplified) polygons for a feature for different
   * geopolitical use cases.
   */
  geopoliticalGeometry?: GeostoreGeopoliticalGeometryProto;
  /**
   * ** DEPRECATED ** Features can have zero or more HTML texts associated with
   * them. These might be HTML balloons used by Google Earth, for example.
   */
  htmlText?: GeostoreHtmlTextProto[];
  /**
   * The globally unique id for this feature.
   */
  id?: GeostoreFeatureIdProto;
  inferredGeometry?: GeostoreInferredGeometryProto;
  /**
   * S2 interior covering that consists of cells completely enclosed within the
   * feature's geometry (for features with polygonal geometry).
   */
  interiorCovering?: GeostoreCellCoveringProto;
  /**
   * Additional internal feature-level attributes that may be set by data
   * providers to be used inside the Geo Data infrastructure. This field should
   * never be present in the output of the Geo Data infrastructure that
   * read-only clients consume.
   */
  internal?: GeostoreInternalFeatureProto;
  intersection?: GeostoreIntersectionProto;
  intersectionGroup?: GeostoreIntersectionGroupProto;
  /**
   * Properties that apply to this feature whose schema is defined in the
   * Knowledge Graph schema (see https://hume.google.com/graph/schema). Not all
   * properties that exist in the KG schema can be asserted via this mechanism.
   * The set of properties that are allowed to be set on a feature depends on
   * the feature's GConcepts (and feature type). For instance, only gcid:country
   * features may have the /geo/type/country/president property (made up
   * example, since that property doesn't actually exist in the KG schema).
   * GConcept hierarchy is taken into account for deciding the set of allowed
   * properties. Additionally, the specific properties allowed are further
   * constrained by the list specified at go/kg-property-allowlist. NOTE: not
   * all types of properties are allowed to appear in the Geo Schema. For now,
   * we limit ourselves to properties whose value type is TYPE_BOOL,
   * TYPE_COMPOUND, TYPE_DATETIME, TYPE_FLOAT, TYPE_ID, TYPE_INT,
   * TYPE_NESTED_STRUCT, TYPE_TEXT, or TYPE_URI. NOTE(b/35039936): We are in the
   * process of changing how a KG property with multiple values is stored in
   * this field. Currently, such a KG property is stored in a single instance of
   * the kg_property field. However, we will be changing this so that each value
   * will be stored in its own instance of kg_property. Any client that wants to
   * read from this field should be prepared to read data represented in either
   * format. See b/35039936 or the announcement at
   * http://g/geo-schema-announce/7IXR3Fex8to/7yFyT5UoAwAJ for an example and
   * more details. The mechanism to assert that a KG property has no value is
   * via the property_value_status field below.
   * freebase.PropertyValue.value_status is not allowed be set here for
   * consistency reason.
   */
  kgProperty?: FreebasePropertyValue[];
  /**
   * RESERVED
   */
  knowledgeGraphReference?: GeostoreKnowledgeGraphReferenceProto;
  laneMarker?: GeostoreLaneMarkerProto;
  /**
   * Represents information about TYPE_LEVEL features.
   */
  level?: GeostoreLevelProto;
  locale?: GeostoreLocaleProto;
  logicalBorder?: GeostoreLogicalBorderProto;
  /**
   * Metadata about this particular feature. Metadata is managed internally by
   * the Geo Data Infrastructure and in general should not be set by clients.
   * Features that don't ultimately come from the Geo repository (MapFacts)
   * won't have any metadata set.
   */
  metadata?: GeostoreFeatureMetadataProto;
  /**
   * The name(s) of this feature. A feature may have different names in
   * different languages, colloquial or "vanity" names, etc.
   */
  name?: GeostoreNameProto[];
  /**
   * Information about this feature's operations, e.g. when this feature is
   * temporarily closed. NOTE: for legacy reasons, some closure-specifc
   * information (e.g. permanent closure reason) lives in ExistenceProto
   * instead. In the future, such information should move here in
   * OperationsProto.
   */
  operations?: GeostoreOperationsProto;
  /**
   * This field is used internally by the pipeline for id stability. It should
   * not be set by individual importers, nor should it be read by consumer
   * clients. In particular, this field will not be present in features read or
   * snapshotted from the Mapfacts Repository.
   */
  originalId?: GeostoreFeatureIdProto;
  parent?: GeostoreFeatureIdProto[];
  /**
   * Describes parking details for the feature.
   */
  parking?: GeostoreParkingProto;
  /**
   * Defines the geometry of the feature. The geometry may be specified as an
   * arbitrary union of points, poses, polylines, tracks, and polygons. Points,
   * poses, polylines, and tracks are assumed to represent regions of
   * unspecified size or width rather than regions of zero area. Most features
   * should have some sort of geometry. Geometry may be synthesized if none is
   * available (e.g., polygons for postal codes). The synthetic_geometry flag
   * should be set in that case. Point is currently enforced as a non-repeating
   * field for all feature types, though it is defined as repeating in case
   * future modeling requires multiple points. The number of allowed polylines,
   * tracks, or polygons vary based on feature type. A feature can have at most
   * one pose (it is an optional field).
   */
  point?: GeostorePointProto[];
  /**
   * ** DEPRECATED ** Detail discussion could be found at b/18611003.
   */
  political?: GeostorePoliticalProto;
  polygon?: GeostorePolygonProto[];
  /**
   * Provide version of the geometry suitable for display. This has been
   * subject to water removal and (possibly) moderate simplification.
   */
  polygonForDisplay?: GeostorePolygonProto;
  polyline?: GeostorePolyLineProto[];
  /**
   * Defines the geometry of a feature as a 6D pose, including lat, lng,
   * altitude, roll, pitch, and yaw along the WGS-84 ellipsoid. Only the lat and
   * lng are strictly required.
   */
  pose?: GeostorePoseProto;
  /**
   * The preferred viewport for this feature. If present, this
   * latitude-longitude rectangle holds the preferred viewport for the feature.
   * For example, it might hold the bounds of the "central" portion of a large
   * city. There are no aspect ratio requirements. This is an optional field: if
   * no viewport is supplied, interested clients can use heuristics to determine
   * a viewport. Calling the standard GetFeatureGeometryBound() function would
   * be a good way to start but note that it can return an empty bounding box
   * (e.g., if the feature has no geometry). The preferred viewport is not
   * necessarily fully contained by the above bounding box.
   */
  preferredViewport?: GeostoreRectProto;
  /**
   * The value status of properties on this feature. For example, this
   * specifies whether the feature is known to have no name (this is the value
   * status of the 'FEATURE_NAME' property). Only property IDs which have no
   * specific value are allowed to have a value status. Note: not all field
   * types will be supported, please contact geo schema team if you want to
   * enable this field for a field type that is not currently supported.
   */
  propertyValueStatus?: GeostorePropertyValueStatusProto[];
  /**
   * WARNING: Please do NOT introduce new uses of this field; treat it as if it
   * were deprecated. For appropriate ranking contacts, see
   * g3doc/company/teams/gdeng/geo-schema-reference/home/feature-properties/rank.md.
   * A floating-point number between 0.0 and 1.0 indicating how "important" we
   * think this feature is. This can be used to decide which features to render
   * on maps, and how to rank results when the user does a search. The rank can
   * depend on any number of factors such as the number of references to this
   * feature in web pages, geographic size, population, number of referring
   * geographic entities, "priority" information encoded in the source data,
   * etc.
   */
  rank?: number;
  /**
   * The rank field is computed as a weighted sum of several signals. This
   * field contains a protocol buffer whose fields give those signals and their
   * weights. Clients should try very hard not to depend on these individual
   * signals and use the single rank field instead. At some point in the future,
   * this field will not be exposed anymore.
   */
  rankDetails?: GeostoreRankDetailsProto;
  /**
   * Geo Ontology GConcept Instances - Design doc linked off
   * http://go/geo-ontology - In order to shield clients from changes in
   * GConcept representation we provide an accessor library:
   * geostore/base/public/gconcept_instance.h
   */
  rawGconceptInstanceContainer?: GeostoreOntologyRawGConceptInstanceContainerProto;
  regulatedArea?: GeostoreRegulatedAreaProto;
  /**
   * For TYPE_COUNTRY or TYPE_ADMINISTRATIVE_AREA1 features, this field defines
   * the associated TYPE_BORDERs which reference this feature. The linked
   * TYPE_BORDERs must have the feature.border set, pointing to this feature.
   * TYPE_COUNTRY or TYPE_ADMINISTRATIVE_AREA1 features must have this field set
   * for each TYPE_BORDER referencing them.
   */
  relatedBorder?: GeostoreFeatureIdProto[];
  /**
   * Logical relationship to other features that are entrances or exits to this
   * feature.
   */
  relatedEntrance?: GeostoreEntranceReferenceProto[];
  /**
   * Geographic or logical relationships to other features. Importers don't
   * need to fill a geographic relationship in - it is handled by related
   * feature processing by a standalone pipeline. Adding "contained by" country
   * relations is however encouraged (and required for TYPE_ROUTE features).
   * WARNING: Updates to this field handled by standalone pipelines are NOT
   * atomic with regard to updates to the features being referenced; we do not
   * guarantee that a given MapFacts snapshot will be consistent between this
   * field and the related features.
   */
  relatedFeature?: GeostoreRelationProto[];
  /**
   * Terminal points associated with this feature. For instance, an airport
   * terminal may have specifically designated pickup and drop-off points.
   */
  relatedTerminalPoint?: GeostoreFeatureIdProto[];
  /**
   * Contains time zones known to be associated with a feature. Most features
   * are associated with the single time zone that contains them. However, some
   * larger features (countries, continents, etc.) are associated with all of
   * the time zones they contain. Most features can have any number of related
   * time zones, but TYPE_SEGMENT and TYPE_ESTABLISHMENT_POI features can have
   * at most 1.
   */
  relatedTimezone?: GeostoreTimezoneProto[];
  restrictionGroup?: GeostoreRestrictionGroupProto;
  roadMonitor?: GeostoreRoadMonitorProto;
  /**
   * Additional details on the feature types below can be found in the
   * individual protocol buffer definitions. These extensions capture data that
   * is specific to a set of feature types and which makes no sense for other
   * feature types.
   */
  route?: GeostoreRouteProto;
  schoolDistrict?: GeostoreSchoolDistrictProto;
  segment?: GeostoreSegmentProto;
  segmentPath?: GeostoreSegmentPathProto;
  sign?: GeostoreRoadSignProto;
  skiBoundary?: GeostoreSkiBoundaryProto;
  skiLift?: GeostoreSkiLiftProto;
  skiTrail?: GeostoreSkiTrailProto;
  /**
   * All establishments must have a social reference. WARNING: Aside from
   * creating new establishments, please do NOT introduce new uses; treat social
   * references as if they were deprecated. For alternatives and more, see
   * g3doc/company/teams/gdeng/geo-schema-reference/home/feature-types/establishments/social-reference.md.
   */
  socialReference?: GeostoreSocialReferenceProto;
  /**
   * A list of the data sources that were used to construct this feature,
   * together with optional "raw data" in the provider's format. Raw data should
   * not be used by production clients but may be useful for exploring data that
   * is not currently converted to a canonical form.
   */
  sourceInfo?: GeostoreSourceInfoProto[];
  /**
   * All features can have "existence" information associated with them.
   */
  status?: GeostoreExistenceProto;
  /**
   * Represents information about the store front geometry. Only
   * TYPE_ESTABLISHMENT_POI should have this field set.
   */
  storefrontGeometry?: GeostoreAnchoredGeometryProto[];
  /**
   * We prefer features that have geometry over those that do not. In some
   * cases we synthesize geometry (e.g., polygons for postal codes). This flag
   * is set to indicate features that have such synthetic geometry.
   */
  syntheticGeometry?: boolean;
  /**
   * A place for clients to attach arbitrary data to a feature. Never set in
   * MapFacts.
   */
  temporaryData?: Proto2BridgeMessageSet;
  /**
   * Captures full model representing the feature's 3D geometry. Should only be
   * found on TYPE_COMPOUND_BUILDING features for now, but not part of the
   * BuildingProto extension for possible future extensions.
   */
  threeDimModel?: GeostoreThreeDimensionalModelProto;
  /**
   * Represents information about TYPE_TOLL_CLUSTER features.
   */
  tollCluster?: GeostoreTollClusterProto;
  /**
   * Defines the geometry of a feature as a sequence of 6D poses, including
   * lat, lng, altitude, roll, pitch, and yaw. Only lat and lng are typically
   * required. Each track has an index so that they can be viewed in a stable
   * order.
   */
  track?: GeostoreTrackProto[];
  transitLine?: GeostoreTransitLineProto;
  /**
   * RESERVED
   */
  transitLineVariant?: GeostoreTransitLineVariantProto;
  /**
   * RESERVED
   */
  transitStation?: GeostoreTransitStationProto;
  /**
   * The type of this feature -- see comments above.
   */
  type?:  | "TYPE_ANY" | "TYPE_TRANSPORTATION" | "TYPE_ROUTE" | "TYPE_DEPRECATED_HIGHWAY_DO_NOT_USE" | "TYPE_HIGHWAY" | "TYPE_HIGHWAY_1" | "TYPE_HIGHWAY_2" | "TYPE_HIGHWAY_3" | "TYPE_HIGHWAY_4" | "TYPE_HIGHWAY_5" | "TYPE_HIGHWAY_6" | "TYPE_HIGHWAY_7" | "TYPE_HIGHWAY_8" | "TYPE_HIGHWAY_9" | "TYPE_BICYCLE_ROUTE" | "TYPE_TRAIL" | "TYPE_SEGMENT" | "TYPE_ROAD" | "TYPE_RAILWAY" | "TYPE_STANDARD_TRACK" | "TYPE_JR_TRACK" | "TYPE_NARROW_TRACK" | "TYPE_MONORAIL_TRACK" | "TYPE_SUBWAY_TRACK" | "TYPE_LIGHT_RAIL_TRACK" | "TYPE_BROAD_TRACK" | "TYPE_HIGH_SPEED_RAIL" | "TYPE_TROLLEY_TRACK" | "TYPE_FERRY" | "TYPE_FERRY_BOAT" | "TYPE_FERRY_TRAIN" | "TYPE_VIRTUAL_SEGMENT" | "TYPE_INTERSECTION" | "TYPE_TRANSIT" | "TYPE_TRANSIT_STATION" | "TYPE_BUS_STATION" | "TYPE_TRAMWAY_STATION" | "TYPE_TRAIN_STATION" | "TYPE_SUBWAY_STATION" | "TYPE_FERRY_TERMINAL" | "TYPE_AIRPORT" | "TYPE_AIRPORT_CIVIL" | "TYPE_AIRPORT_MILITARY" | "TYPE_AIRPORT_MIXED" | "TYPE_HELIPORT" | "TYPE_SEAPLANE_BASE" | "TYPE_AIRSTRIP" | "TYPE_CABLE_CAR_STATION" | "TYPE_GONDOLA_LIFT_STATION" | "TYPE_FUNICULAR_STATION" | "TYPE_SPECIAL_STATION" | "TYPE_HORSE_CARRIAGE_STATION" | "TYPE_MONORAIL_STATION" | "TYPE_SEAPORT" | "TYPE_TRANSIT_STOP" | "TYPE_TRANSIT_TRIP" | "TYPE_TRANSIT_DEPARTURE" | "TYPE_TRANSIT_LEG" | "TYPE_TRANSIT_LINE" | "TYPE_TRANSIT_AGENCY_DEPRECATED_VALUE" | "TYPE_TRANSIT_TRANSFER" | "TYPE_SEGMENT_PATH" | "TYPE_ROAD_SIGN" | "TYPE_INTERSECTION_GROUP" | "TYPE_PATHWAY" | "TYPE_RESTRICTION_GROUP" | "TYPE_TOLL_CLUSTER" | "TYPE_POLITICAL" | "TYPE_COUNTRY" | "TYPE_ADMINISTRATIVE_AREA" | "TYPE_ADMINISTRATIVE_AREA1" | "TYPE_US_STATE" | "TYPE_GB_COUNTRY" | "TYPE_JP_TODOUFUKEN" | "TYPE_ADMINISTRATIVE_AREA2" | "TYPE_GB_FORMER_POSTAL_COUNTY" | "TYPE_GB_TRADITIONAL_COUNTY" | "TYPE_ADMINISTRATIVE_AREA3" | "TYPE_ADMINISTRATIVE_AREA4" | "TYPE_ADMINISTRATIVE_AREA5" | "TYPE_ADMINISTRATIVE_AREA6" | "TYPE_ADMINISTRATIVE_AREA7" | "TYPE_ADMINISTRATIVE_AREA8" | "TYPE_ADMINISTRATIVE_AREA9" | "TYPE_COLLOQUIAL_AREA" | "TYPE_RESERVATION" | "TYPE_LOCALITY" | "TYPE_GB_POST_TOWN" | "TYPE_JP_GUN" | "TYPE_JP_SHIKUCHOUSON" | "TYPE_JP_SUB_SHIKUCHOUSON" | "TYPE_COLLOQUIAL_CITY" | "TYPE_SUBLOCALITY" | "TYPE_US_BOROUGH" | "TYPE_GB_DEPENDENT_LOCALITY" | "TYPE_JP_OOAZA" | "TYPE_JP_KOAZA" | "TYPE_JP_GAIKU" | "TYPE_GB_DOUBLE_DEPENDENT_LOCALITY" | "TYPE_JP_CHIBAN" | "TYPE_JP_EDABAN" | "TYPE_SUBLOCALITY1" | "TYPE_SUBLOCALITY2" | "TYPE_SUBLOCALITY3" | "TYPE_SUBLOCALITY4" | "TYPE_SUBLOCALITY5" | "TYPE_NEIGHBORHOOD" | "TYPE_CONSTITUENCY" | "TYPE_DESIGNATED_MARKET_AREA" | "TYPE_SCHOOL_DISTRICT" | "TYPE_LAND_PARCEL" | "TYPE_DISPUTED_AREA" | "TYPE_POLICE_JURISDICTION" | "TYPE_STATISTICAL_AREA" | "TYPE_CONSTITUENCY_FUTURE" | "TYPE_PARK" | "TYPE_GOLF_COURSE" | "TYPE_LOCAL_PARK" | "TYPE_NATIONAL_PARK" | "TYPE_US_NATIONAL_PARK" | "TYPE_US_NATIONAL_MONUMENT" | "TYPE_NATIONAL_FOREST" | "TYPE_PROVINCIAL_PARK" | "TYPE_PROVINCIAL_FOREST" | "TYPE_CAMPGROUNDS" | "TYPE_HIKING_AREA" | "TYPE_BUSINESS" | "TYPE_GOVERNMENT" | "TYPE_BORDER_CROSSING" | "TYPE_CITY_HALL" | "TYPE_COURTHOUSE" | "TYPE_EMBASSY" | "TYPE_LIBRARY" | "TYPE_SCHOOL" | "TYPE_UNIVERSITY" | "TYPE_EMERGENCY" | "TYPE_HOSPITAL" | "TYPE_PHARMACY" | "TYPE_POLICE" | "TYPE_FIRE" | "TYPE_DOCTOR" | "TYPE_DENTIST" | "TYPE_VETERINARIAN" | "TYPE_TRAVEL_SERVICE" | "TYPE_LODGING" | "TYPE_RESTAURANT" | "TYPE_GAS_STATION" | "TYPE_PARKING" | "TYPE_POST_OFFICE" | "TYPE_REST_AREA" | "TYPE_CASH_MACHINE" | "TYPE_CAR_RENTAL" | "TYPE_CAR_REPAIR" | "TYPE_SHOPPING" | "TYPE_GROCERY" | "TYPE_TOURIST_DESTINATION" | "TYPE_ECO_TOURIST_DESTINATION" | "TYPE_BIRD_WATCHING" | "TYPE_FISHING" | "TYPE_HUNTING" | "TYPE_NATURE_RESERVE" | "TYPE_TEMPLE" | "TYPE_CHURCH" | "TYPE_GURUDWARA" | "TYPE_HINDU_TEMPLE" | "TYPE_MOSQUE" | "TYPE_SYNAGOGUE" | "TYPE_STADIUM" | "TYPE_BAR" | "TYPE_MOVIE_RENTAL" | "TYPE_COFFEE" | "TYPE_GOLF" | "TYPE_BANK" | "TYPE_DOODLE" | "TYPE_GROUNDS" | "TYPE_AIRPORT_GROUNDS" | "TYPE_BUILDING_GROUNDS" | "TYPE_CEMETERY" | "TYPE_HOSPITAL_GROUNDS" | "TYPE_INDUSTRIAL" | "TYPE_MILITARY" | "TYPE_SHOPPING_CENTER" | "TYPE_SPORTS_COMPLEX" | "TYPE_UNIVERSITY_GROUNDS" | "TYPE_DEPRECATED_TARMAC" | "TYPE_ENCLOSED_TRAFFIC_AREA" | "TYPE_PARKING_LOT" | "TYPE_PARKING_GARAGE" | "TYPE_OFF_ROAD_AREA" | "TYPE_BORDER" | "TYPE_BUILDING" | "TYPE_GEOCODED_ADDRESS" | "TYPE_NATURAL_FEATURE" | "TYPE_TERRAIN" | "TYPE_SAND" | "TYPE_BEACH" | "TYPE_DUNE" | "TYPE_ROCKY" | "TYPE_ICE" | "TYPE_GLACIER" | "TYPE_BUILT_UP_AREA" | "TYPE_VEGETATION" | "TYPE_SHRUBBERY" | "TYPE_WOODS" | "TYPE_AGRICULTURAL" | "TYPE_GRASSLAND" | "TYPE_TUNDRA" | "TYPE_DESERT" | "TYPE_SALT_FLAT" | "TYPE_WATER" | "TYPE_OCEAN" | "TYPE_BAY" | "TYPE_BIGHT" | "TYPE_LAGOON" | "TYPE_SEA" | "TYPE_STRAIT" | "TYPE_INLET" | "TYPE_FJORD" | "TYPE_LAKE" | "TYPE_SEASONAL_LAKE" | "TYPE_RESERVOIR" | "TYPE_POND" | "TYPE_RIVER" | "TYPE_RAPIDS" | "TYPE_DISTRIBUTARY" | "TYPE_CONFLUENCE" | "TYPE_WATERFALL" | "TYPE_SPRING" | "TYPE_GEYSER" | "TYPE_HOT_SPRING" | "TYPE_SEASONAL_RIVER" | "TYPE_WADI" | "TYPE_ESTUARY" | "TYPE_WETLAND" | "TYPE_WATER_NAVIGATION" | "TYPE_FORD" | "TYPE_CANAL" | "TYPE_HARBOR" | "TYPE_CHANNEL" | "TYPE_REEF" | "TYPE_REEF_FLAT" | "TYPE_REEF_GROWTH" | "TYPE_REEF_EXTENT" | "TYPE_REEF_ROCK_SUBMERGED" | "TYPE_IRRIGATION" | "TYPE_DAM" | "TYPE_DRINKING_WATER" | "TYPE_CURRENT" | "TYPE_WATERING_HOLE" | "TYPE_TECTONIC" | "TYPE_WATERING_HOLE_DEPRECATED" | "TYPE_VOLCANO" | "TYPE_LAVA_FIELD" | "TYPE_FISSURE" | "TYPE_FAULT" | "TYPE_LAND_MASS" | "TYPE_CONTINENT" | "TYPE_ISLAND" | "TYPE_ATOLL" | "TYPE_OCEAN_ROCK_EXPOSED" | "TYPE_CAY" | "TYPE_PENINSULA" | "TYPE_ISTHMUS" | "TYPE_ELEVATED" | "TYPE_PEAK" | "TYPE_NUNATAK" | "TYPE_SPUR" | "TYPE_PASS" | "TYPE_PLATEAU" | "TYPE_RIDGE" | "TYPE_RAVINE" | "TYPE_CRATER" | "TYPE_KARST" | "TYPE_CLIFF" | "TYPE_VISTA" | "TYPE_DIGITAL_ELEVATION_MODEL" | "TYPE_UPLAND" | "TYPE_TERRACE" | "TYPE_SLOPE" | "TYPE_CONTOUR_LINE" | "TYPE_PAN" | "TYPE_UNSTABLE_HILLSIDE" | "TYPE_MOUNTAIN_RANGE" | "TYPE_UNDERSEA" | "TYPE_SUBMARINE_SEAMOUNT" | "TYPE_SUBMARINE_RIDGE" | "TYPE_SUBMARINE_GAP" | "TYPE_SUBMARINE_PLATEAU" | "TYPE_SUBMARINE_DEEP" | "TYPE_SUBMARINE_VALLEY" | "TYPE_SUBMARINE_BASIN" | "TYPE_SUBMARINE_SLOPE" | "TYPE_SUBMARINE_CLIFF" | "TYPE_SUBMARINE_PLAIN" | "TYPE_SUBMARINE_FRACTURE_ZONE" | "TYPE_CAVE" | "TYPE_ROCK" | "TYPE_ARCHIPELAGO" | "TYPE_POSTAL" | "TYPE_POSTAL_CODE" | "TYPE_POSTAL_CODE_PREFIX" | "TYPE_PREMISE" | "TYPE_SUB_PREMISE" | "TYPE_SUITE" | "TYPE_POST_TOWN" | "TYPE_POSTAL_ROUND" | "TYPE_META_FEATURE" | "TYPE_DATA_SOURCE" | "TYPE_LOCALE" | "TYPE_TIMEZONE" | "TYPE_BUSINESS_CHAIN" | "TYPE_PHONE_NUMBER_PREFIX" | "TYPE_PHONE_NUMBER_AREA_CODE" | "TYPE_BUSINESS_CORRIDOR" | "TYPE_ADDRESS_TEMPLATE" | "TYPE_TRANSIT_AGENCY" | "TYPE_FUTURE_GEOMETRY" | "TYPE_EVENT" | "TYPE_EARTHQUAKE" | "TYPE_HURRICANE" | "TYPE_WEATHER_CONDITION" | "TYPE_TRANSIENT" | "TYPE_ENTRANCE" | "TYPE_CARTOGRAPHIC" | "TYPE_HIGH_TENSION" | "TYPE_SKI_TRAIL" | "TYPE_SKI_LIFT" | "TYPE_SKI_BOUNDARY" | "TYPE_WATERSHED_BOUNDARY" | "TYPE_TARMAC" | "TYPE_WALL" | "TYPE_PICNIC_AREA" | "TYPE_PLAY_GROUND" | "TYPE_TRAIL_HEAD" | "TYPE_GOLF_TEEING_GROUND" | "TYPE_GOLF_PUTTING_GREEN" | "TYPE_GOLF_ROUGH" | "TYPE_GOLF_SAND_BUNKER" | "TYPE_GOLF_FAIRWAY" | "TYPE_GOLF_HOLE" | "TYPE_DEPRECATED_GOLF_SHOP" | "TYPE_CAMPING_SITE" | "TYPE_DESIGNATED_BARBECUE_PIT" | "TYPE_DESIGNATED_COOKING_AREA" | "TYPE_CAMPFIRE_PIT" | "TYPE_WATER_FOUNTAIN" | "TYPE_LITTER_RECEPTACLE" | "TYPE_LOCKER_AREA" | "TYPE_ANIMAL_ENCLOSURE" | "TYPE_CARTOGRAPHIC_LINE" | "TYPE_ESTABLISHMENT" | "TYPE_ESTABLISHMENT_GROUNDS" | "TYPE_ESTABLISHMENT_BUILDING" | "TYPE_ESTABLISHMENT_POI" | "TYPE_ESTABLISHMENT_SERVICE" | "TYPE_CELESTIAL" | "TYPE_ROAD_MONITOR" | "TYPE_PUBLIC_SPACES_AND_MONUMENTS" | "TYPE_STATUE" | "TYPE_TOWN_SQUARE" | "TYPE_LEVEL" | "TYPE_COMPOUND" | "TYPE_COMPOUND_GROUNDS" | "TYPE_COMPOUND_BUILDING" | "TYPE_COMPOUND_SECTION" | "TYPE_TERMINAL_POINT" | "TYPE_REGULATED_AREA" | "TYPE_LOGICAL_BORDER" | "TYPE_DO_NOT_USE_RESERVED_TO_CATCH_GENERATED_FILES" | "TYPE_UNKNOWN";
  /**
   * Represents vertical ordering for this feature relative to other
   * geometrically-overlaping features. See go/aboutgrades for more information
   * about distinction among different levels.
   */
  verticalOrdering?: GeostoreVerticalOrderingProto;
  /**
   * A version of the geometry which has water removed but is not simplified
   * (thus having equal or more vertices than polygon_for_display).
   */
  waterRemovedPolygon?: GeostorePolygonProto;
  /**
   * The official website of this feature. Stored as a repeated field to allow
   * for multilingual official websites (see comments in url.proto).
   */
  website?: GeostoreUrlProto[];
}

function serializeGeostoreFeatureProto(data: any): GeostoreFeatureProto {
  return {
    ...data,
    accessPoint: data["accessPoint"] !== undefined ? data["accessPoint"].map((item: any) => (serializeGeostoreAccessPointProto(item))) : undefined,
    address: data["address"] !== undefined ? data["address"].map((item: any) => (serializeGeostoreAddressProto(item))) : undefined,
    attachment: data["attachment"] !== undefined ? data["attachment"].map((item: any) => (serializeGeostoreAttachmentsAttachmentProto(item))) : undefined,
    attribute: data["attribute"] !== undefined ? data["attribute"].map((item: any) => (serializeGeostoreAttributeProto(item))) : undefined,
    bestLocale: data["bestLocale"] !== undefined ? serializeGeostoreBestLocaleProto(data["bestLocale"]) : undefined,
    border: data["border"] !== undefined ? serializeGeostoreBorderProto(data["border"]) : undefined,
    building: data["building"] !== undefined ? serializeGeostoreBuildingProto(data["building"]) : undefined,
    child: data["child"] !== undefined ? data["child"].map((item: any) => (serializeGeostoreFeatureIdProto(item))) : undefined,
    covering: data["covering"] !== undefined ? serializeGeostoreCellCoveringProto(data["covering"]) : undefined,
    establishment: data["establishment"] !== undefined ? serializeGeostoreEstablishmentProto(data["establishment"]) : undefined,
    exemptRegulatedArea: data["exemptRegulatedArea"] !== undefined ? data["exemptRegulatedArea"].map((item: any) => (serializeGeostoreFeatureIdProto(item))) : undefined,
    futureGeometry: data["futureGeometry"] !== undefined ? serializeGeostoreFeatureIdProto(data["futureGeometry"]) : undefined,
    futureGeometryFor: data["futureGeometryFor"] !== undefined ? serializeGeostoreFeatureIdProto(data["futureGeometryFor"]) : undefined,
    geopoliticalGeometry: data["geopoliticalGeometry"] !== undefined ? serializeGeostoreGeopoliticalGeometryProto(data["geopoliticalGeometry"]) : undefined,
    id: data["id"] !== undefined ? serializeGeostoreFeatureIdProto(data["id"]) : undefined,
    inferredGeometry: data["inferredGeometry"] !== undefined ? serializeGeostoreInferredGeometryProto(data["inferredGeometry"]) : undefined,
    interiorCovering: data["interiorCovering"] !== undefined ? serializeGeostoreCellCoveringProto(data["interiorCovering"]) : undefined,
    internal: data["internal"] !== undefined ? serializeGeostoreInternalFeatureProto(data["internal"]) : undefined,
    intersection: data["intersection"] !== undefined ? serializeGeostoreIntersectionProto(data["intersection"]) : undefined,
    intersectionGroup: data["intersectionGroup"] !== undefined ? serializeGeostoreIntersectionGroupProto(data["intersectionGroup"]) : undefined,
    kgProperty: data["kgProperty"] !== undefined ? data["kgProperty"].map((item: any) => (serializeFreebasePropertyValue(item))) : undefined,
    level: data["level"] !== undefined ? serializeGeostoreLevelProto(data["level"]) : undefined,
    logicalBorder: data["logicalBorder"] !== undefined ? serializeGeostoreLogicalBorderProto(data["logicalBorder"]) : undefined,
    metadata: data["metadata"] !== undefined ? serializeGeostoreFeatureMetadataProto(data["metadata"]) : undefined,
    originalId: data["originalId"] !== undefined ? serializeGeostoreFeatureIdProto(data["originalId"]) : undefined,
    parent: data["parent"] !== undefined ? data["parent"].map((item: any) => (serializeGeostoreFeatureIdProto(item))) : undefined,
    parking: data["parking"] !== undefined ? serializeGeostoreParkingProto(data["parking"]) : undefined,
    political: data["political"] !== undefined ? serializeGeostorePoliticalProto(data["political"]) : undefined,
    polygon: data["polygon"] !== undefined ? data["polygon"].map((item: any) => (serializeGeostorePolygonProto(item))) : undefined,
    polygonForDisplay: data["polygonForDisplay"] !== undefined ? serializeGeostorePolygonProto(data["polygonForDisplay"]) : undefined,
    propertyValueStatus: data["propertyValueStatus"] !== undefined ? data["propertyValueStatus"].map((item: any) => (serializeGeostorePropertyValueStatusProto(item))) : undefined,
    regulatedArea: data["regulatedArea"] !== undefined ? serializeGeostoreRegulatedAreaProto(data["regulatedArea"]) : undefined,
    relatedBorder: data["relatedBorder"] !== undefined ? data["relatedBorder"].map((item: any) => (serializeGeostoreFeatureIdProto(item))) : undefined,
    relatedEntrance: data["relatedEntrance"] !== undefined ? data["relatedEntrance"].map((item: any) => (serializeGeostoreEntranceReferenceProto(item))) : undefined,
    relatedFeature: data["relatedFeature"] !== undefined ? data["relatedFeature"].map((item: any) => (serializeGeostoreRelationProto(item))) : undefined,
    relatedTerminalPoint: data["relatedTerminalPoint"] !== undefined ? data["relatedTerminalPoint"].map((item: any) => (serializeGeostoreFeatureIdProto(item))) : undefined,
    restrictionGroup: data["restrictionGroup"] !== undefined ? serializeGeostoreRestrictionGroupProto(data["restrictionGroup"]) : undefined,
    roadMonitor: data["roadMonitor"] !== undefined ? serializeGeostoreRoadMonitorProto(data["roadMonitor"]) : undefined,
    segment: data["segment"] !== undefined ? serializeGeostoreSegmentProto(data["segment"]) : undefined,
    segmentPath: data["segmentPath"] !== undefined ? serializeGeostoreSegmentPathProto(data["segmentPath"]) : undefined,
    sign: data["sign"] !== undefined ? serializeGeostoreRoadSignProto(data["sign"]) : undefined,
    socialReference: data["socialReference"] !== undefined ? serializeGeostoreSocialReferenceProto(data["socialReference"]) : undefined,
    sourceInfo: data["sourceInfo"] !== undefined ? data["sourceInfo"].map((item: any) => (serializeGeostoreSourceInfoProto(item))) : undefined,
    status: data["status"] !== undefined ? serializeGeostoreExistenceProto(data["status"]) : undefined,
    tollCluster: data["tollCluster"] !== undefined ? serializeGeostoreTollClusterProto(data["tollCluster"]) : undefined,
    transitLine: data["transitLine"] !== undefined ? serializeGeostoreTransitLineProto(data["transitLine"]) : undefined,
    transitLineVariant: data["transitLineVariant"] !== undefined ? serializeGeostoreTransitLineVariantProto(data["transitLineVariant"]) : undefined,
    transitStation: data["transitStation"] !== undefined ? serializeGeostoreTransitStationProto(data["transitStation"]) : undefined,
    waterRemovedPolygon: data["waterRemovedPolygon"] !== undefined ? serializeGeostorePolygonProto(data["waterRemovedPolygon"]) : undefined,
  };
}

function deserializeGeostoreFeatureProto(data: any): GeostoreFeatureProto {
  return {
    ...data,
    accessPoint: data["accessPoint"] !== undefined ? data["accessPoint"].map((item: any) => (deserializeGeostoreAccessPointProto(item))) : undefined,
    address: data["address"] !== undefined ? data["address"].map((item: any) => (deserializeGeostoreAddressProto(item))) : undefined,
    attachment: data["attachment"] !== undefined ? data["attachment"].map((item: any) => (deserializeGeostoreAttachmentsAttachmentProto(item))) : undefined,
    attribute: data["attribute"] !== undefined ? data["attribute"].map((item: any) => (deserializeGeostoreAttributeProto(item))) : undefined,
    bestLocale: data["bestLocale"] !== undefined ? deserializeGeostoreBestLocaleProto(data["bestLocale"]) : undefined,
    border: data["border"] !== undefined ? deserializeGeostoreBorderProto(data["border"]) : undefined,
    building: data["building"] !== undefined ? deserializeGeostoreBuildingProto(data["building"]) : undefined,
    child: data["child"] !== undefined ? data["child"].map((item: any) => (deserializeGeostoreFeatureIdProto(item))) : undefined,
    covering: data["covering"] !== undefined ? deserializeGeostoreCellCoveringProto(data["covering"]) : undefined,
    establishment: data["establishment"] !== undefined ? deserializeGeostoreEstablishmentProto(data["establishment"]) : undefined,
    exemptRegulatedArea: data["exemptRegulatedArea"] !== undefined ? data["exemptRegulatedArea"].map((item: any) => (deserializeGeostoreFeatureIdProto(item))) : undefined,
    futureGeometry: data["futureGeometry"] !== undefined ? deserializeGeostoreFeatureIdProto(data["futureGeometry"]) : undefined,
    futureGeometryFor: data["futureGeometryFor"] !== undefined ? deserializeGeostoreFeatureIdProto(data["futureGeometryFor"]) : undefined,
    geopoliticalGeometry: data["geopoliticalGeometry"] !== undefined ? deserializeGeostoreGeopoliticalGeometryProto(data["geopoliticalGeometry"]) : undefined,
    id: data["id"] !== undefined ? deserializeGeostoreFeatureIdProto(data["id"]) : undefined,
    inferredGeometry: data["inferredGeometry"] !== undefined ? deserializeGeostoreInferredGeometryProto(data["inferredGeometry"]) : undefined,
    interiorCovering: data["interiorCovering"] !== undefined ? deserializeGeostoreCellCoveringProto(data["interiorCovering"]) : undefined,
    internal: data["internal"] !== undefined ? deserializeGeostoreInternalFeatureProto(data["internal"]) : undefined,
    intersection: data["intersection"] !== undefined ? deserializeGeostoreIntersectionProto(data["intersection"]) : undefined,
    intersectionGroup: data["intersectionGroup"] !== undefined ? deserializeGeostoreIntersectionGroupProto(data["intersectionGroup"]) : undefined,
    kgProperty: data["kgProperty"] !== undefined ? data["kgProperty"].map((item: any) => (deserializeFreebasePropertyValue(item))) : undefined,
    level: data["level"] !== undefined ? deserializeGeostoreLevelProto(data["level"]) : undefined,
    logicalBorder: data["logicalBorder"] !== undefined ? deserializeGeostoreLogicalBorderProto(data["logicalBorder"]) : undefined,
    metadata: data["metadata"] !== undefined ? deserializeGeostoreFeatureMetadataProto(data["metadata"]) : undefined,
    originalId: data["originalId"] !== undefined ? deserializeGeostoreFeatureIdProto(data["originalId"]) : undefined,
    parent: data["parent"] !== undefined ? data["parent"].map((item: any) => (deserializeGeostoreFeatureIdProto(item))) : undefined,
    parking: data["parking"] !== undefined ? deserializeGeostoreParkingProto(data["parking"]) : undefined,
    political: data["political"] !== undefined ? deserializeGeostorePoliticalProto(data["political"]) : undefined,
    polygon: data["polygon"] !== undefined ? data["polygon"].map((item: any) => (deserializeGeostorePolygonProto(item))) : undefined,
    polygonForDisplay: data["polygonForDisplay"] !== undefined ? deserializeGeostorePolygonProto(data["polygonForDisplay"]) : undefined,
    propertyValueStatus: data["propertyValueStatus"] !== undefined ? data["propertyValueStatus"].map((item: any) => (deserializeGeostorePropertyValueStatusProto(item))) : undefined,
    regulatedArea: data["regulatedArea"] !== undefined ? deserializeGeostoreRegulatedAreaProto(data["regulatedArea"]) : undefined,
    relatedBorder: data["relatedBorder"] !== undefined ? data["relatedBorder"].map((item: any) => (deserializeGeostoreFeatureIdProto(item))) : undefined,
    relatedEntrance: data["relatedEntrance"] !== undefined ? data["relatedEntrance"].map((item: any) => (deserializeGeostoreEntranceReferenceProto(item))) : undefined,
    relatedFeature: data["relatedFeature"] !== undefined ? data["relatedFeature"].map((item: any) => (deserializeGeostoreRelationProto(item))) : undefined,
    relatedTerminalPoint: data["relatedTerminalPoint"] !== undefined ? data["relatedTerminalPoint"].map((item: any) => (deserializeGeostoreFeatureIdProto(item))) : undefined,
    restrictionGroup: data["restrictionGroup"] !== undefined ? deserializeGeostoreRestrictionGroupProto(data["restrictionGroup"]) : undefined,
    roadMonitor: data["roadMonitor"] !== undefined ? deserializeGeostoreRoadMonitorProto(data["roadMonitor"]) : undefined,
    segment: data["segment"] !== undefined ? deserializeGeostoreSegmentProto(data["segment"]) : undefined,
    segmentPath: data["segmentPath"] !== undefined ? deserializeGeostoreSegmentPathProto(data["segmentPath"]) : undefined,
    sign: data["sign"] !== undefined ? deserializeGeostoreRoadSignProto(data["sign"]) : un