// 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 (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