googleapis
Version:
Google APIs Client Library for Node.js
1,116 lines • 2.44 MB
TypeScript
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace discoveryengine_v1 {
export interface Options extends GlobalOptions {
version: 'v1';
}
interface StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | BaseExternalAccountClient | GoogleAuth;
/**
* V1 error format.
*/
'$.xgafv'?: string;
/**
* OAuth access token.
*/
access_token?: string;
/**
* Data format for response.
*/
alt?: string;
/**
* JSONP
*/
callback?: string;
/**
* Selector specifying which fields to include in a partial response.
*/
fields?: string;
/**
* API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
*/
key?: string;
/**
* OAuth 2.0 token for the current user.
*/
oauth_token?: string;
/**
* Returns response with indentations and line breaks.
*/
prettyPrint?: boolean;
/**
* Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
*/
quotaUser?: string;
/**
* Legacy upload protocol for media (e.g. "media", "multipart").
*/
uploadType?: string;
/**
* Upload protocol for media (e.g. "raw", "multipart").
*/
upload_protocol?: string;
}
/**
* Discovery Engine API
*
* Discovery Engine API.
*
* @example
* ```js
* const {google} = require('googleapis');
* const discoveryengine = google.discoveryengine('v1');
* ```
*/
export class Discoveryengine {
context: APIRequestContext;
billingAccounts: Resource$Billingaccounts;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* Defines the A2A feature set supported by the agent
*/
export interface Schema$A2aV1AgentCapabilities {
/**
* Extensions supported by this agent.
*/
extensions?: Schema$A2aV1AgentExtension[];
/**
* If the agent can send push notifications to the clients webhook
*/
pushNotifications?: boolean | null;
/**
* If the agent will support streaming responses
*/
streaming?: boolean | null;
}
/**
* AgentCard conveys key information: - Overall details (version, name, description, uses) - Skills; a set of actions/solutions the agent can perform - Default modalities/content types supported by the agent. - Authentication requirements Next ID: 19
*/
export interface Schema$A2aV1AgentCard {
/**
* Announcement of additional supported transports. Client can use any of the supported transports.
*/
additionalInterfaces?: Schema$A2aV1AgentInterface[];
/**
* A2A Capability set supported by the agent.
*/
capabilities?: Schema$A2aV1AgentCapabilities;
/**
* protolint:enable REPEATED_FIELD_NAMES_PLURALIZED The set of interaction modes that the agent supports across all skills. This can be overridden per skill. Defined as mime types.
*/
defaultInputModes?: string[] | null;
/**
* The mime types supported as outputs from this agent.
*/
defaultOutputModes?: string[] | null;
/**
* A description of the agent's domain of action/solution space. Example: "Agent that helps users with recipes and cooking."
*/
description?: string | null;
/**
* A url to provide additional documentation about the agent.
*/
documentationUrl?: string | null;
/**
* An optional URL to an icon for the agent.
*/
iconUrl?: string | null;
/**
* A human readable name for the agent. Example: "Recipe Agent"
*/
name?: string | null;
/**
* The transport of the preferred endpoint. If empty, defaults to JSONRPC.
*/
preferredTransport?: string | null;
/**
* The version of the A2A protocol this agent supports.
*/
protocolVersion?: string | null;
/**
* The service provider of the agent.
*/
provider?: Schema$A2aV1AgentProvider;
/**
* protolint:disable REPEATED_FIELD_NAMES_PLURALIZED Security requirements for contacting the agent. This list can be seen as an OR of ANDs. Each object in the list describes one possible set of security requirements that must be present on a request. This allows specifying, for example, "callers must either use OAuth OR an API Key AND mTLS." Example: security { schemes { key: "oauth" value { list: ["read"] \} \} \} security { schemes { key: "api-key" \} schemes { key: "mtls" \} \}
*/
security?: Schema$A2aV1Security[];
/**
* The security scheme details used for authenticating with this agent.
*/
securitySchemes?: {
[key: string]: Schema$A2aV1SecurityScheme;
} | null;
/**
* JSON Web Signatures computed for this AgentCard.
*/
signatures?: Schema$A2aV1AgentCardSignature[];
/**
* Skills represent a unit of ability an agent can perform. This may somewhat abstract but represents a more focused set of actions that the agent is highly likely to succeed at.
*/
skills?: Schema$A2aV1AgentSkill[];
/**
* Whether the agent supports providing an extended agent card when the user is authenticated, i.e. is the card from .well-known different than the card from GetAgentCard.
*/
supportsAuthenticatedExtendedCard?: boolean | null;
/**
* A URL to the address the agent is hosted at. This represents the preferred endpoint as declared by the agent.
*/
url?: string | null;
/**
* The version of the agent. Example: "1.0.0"
*/
version?: string | null;
}
/**
* AgentCardSignature represents a JWS signature of an AgentCard. This follows the JSON format of an RFC 7515 JSON Web Signature (JWS).
*/
export interface Schema$A2aV1AgentCardSignature {
/**
* The unprotected JWS header values.
*/
header?: {
[key: string]: any;
} | null;
/**
* Required. The protected JWS header for the signature. This is always a base64url-encoded JSON object. Required.
*/
protected?: string | null;
/**
* Required. The computed signature, base64url-encoded. Required.
*/
signature?: string | null;
}
/**
* A declaration of an extension supported by an Agent.
*/
export interface Schema$A2aV1AgentExtension {
/**
* A description of how this agent uses this extension. Example: "Google OAuth 2.0 authentication"
*/
description?: string | null;
/**
* Optional configuration for the extension.
*/
params?: {
[key: string]: any;
} | null;
/**
* Whether the client must follow specific requirements of the extension. Example: false
*/
required?: boolean | null;
/**
* The URI of the extension. Example: "https://developers.google.com/identity/protocols/oauth2"
*/
uri?: string | null;
}
/**
* Defines additional transport information for the agent.
*/
export interface Schema$A2aV1AgentInterface {
/**
* Tenant to be set in the request when calling the agent. Experimental, might still change for 1.0 release.
*/
tenant?: string | null;
/**
* The transport supported this url. This is an open form string, to be easily extended for many transport protocols. The core ones officially supported are JSONRPC, GRPC and HTTP+JSON.
*/
transport?: string | null;
/**
* The url this interface is found at.
*/
url?: string | null;
}
/**
* Represents information about the service provider of an agent.
*/
export interface Schema$A2aV1AgentProvider {
/**
* The providers organization name Example: "Google"
*/
organization?: string | null;
/**
* The providers reference url Example: "https://ai.google.dev"
*/
url?: string | null;
}
/**
* AgentSkill represents a unit of action/solution that the agent can perform. One can think of this as a type of highly reliable solution that an agent can be tasked to provide. Agents have the autonomy to choose how and when to use specific skills, but clients should have confidence that if the skill is defined that unit of action can be reliably performed.
*/
export interface Schema$A2aV1AgentSkill {
/**
* A human (or llm) readable description of the skill details and behaviors.
*/
description?: string | null;
/**
* A set of example queries that this skill is designed to address. These examples should help the caller to understand how to craft requests to the agent to achieve specific goals. Example: ["I need a recipe for bread"]
*/
examples?: string[] | null;
/**
* Unique identifier of the skill within this agent.
*/
id?: string | null;
/**
* Possible input modalities supported.
*/
inputModes?: string[] | null;
/**
* A human readable name for the skill.
*/
name?: string | null;
/**
* Possible output modalities produced
*/
outputModes?: string[] | null;
/**
* protolint:disable REPEATED_FIELD_NAMES_PLURALIZED Security schemes necessary for the agent to leverage this skill. As in the overall AgentCard.security, this list represents a logical OR of security requirement objects. Each object is a set of security schemes that must be used together (a logical AND). protolint:enable REPEATED_FIELD_NAMES_PLURALIZED
*/
security?: Schema$A2aV1Security[];
/**
* A set of tags for the skill to enhance categorization/utilization. Example: ["cooking", "customer support", "billing"]
*/
tags?: string[] | null;
}
export interface Schema$A2aV1APIKeySecurityScheme {
/**
* Description of this security scheme.
*/
description?: string | null;
/**
* Location of the API key, valid values are "query", "header", or "cookie"
*/
location?: string | null;
/**
* Name of the header, query or cookie parameter to be used.
*/
name?: string | null;
}
/**
* Artifacts are the container for task completed results. These are similar to Messages but are intended to be the product of a task, as opposed to point-to-point communication.
*/
export interface Schema$A2aV1Artifact {
/**
* Unique identifier (e.g. UUID) for the artifact. It must be at least unique within a task.
*/
artifactId?: string | null;
/**
* A human readable description of the artifact, optional.
*/
description?: string | null;
/**
* The URIs of extensions that are present or contributed to this Artifact.
*/
extensions?: string[] | null;
/**
* Optional metadata included with the artifact.
*/
metadata?: {
[key: string]: any;
} | null;
/**
* A human readable name for the artifact.
*/
name?: string | null;
/**
* The content of the artifact.
*/
parts?: Schema$A2aV1Part[];
}
/**
* Defines authentication details, used for push notifications.
*/
export interface Schema$A2aV1AuthenticationInfo {
/**
* Optional credentials
*/
credentials?: string | null;
/**
* Supported authentication schemes - e.g. Basic, Bearer, etc
*/
schemes?: string[] | null;
}
export interface Schema$A2aV1AuthorizationCodeOAuthFlow {
/**
* The authorization URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS
*/
authorizationUrl?: string | null;
/**
* The URL to be used for obtaining refresh tokens. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.
*/
refreshUrl?: string | null;
/**
* The available scopes for the OAuth2 security scheme. A map between the scope name and a short description for it. The map MAY be empty.
*/
scopes?: {
[key: string]: string;
} | null;
/**
* The token URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.
*/
tokenUrl?: string | null;
}
export interface Schema$A2aV1CancelTaskRequest {
}
export interface Schema$A2aV1ClientCredentialsOAuthFlow {
/**
* The URL to be used for obtaining refresh tokens. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.
*/
refreshUrl?: string | null;
/**
* The available scopes for the OAuth2 security scheme. A map between the scope name and a short description for it. The map MAY be empty.
*/
scopes?: {
[key: string]: string;
} | null;
/**
* The token URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.
*/
tokenUrl?: string | null;
}
/**
* DataPart represents a structured blob. This is most commonly a JSON payload.
*/
export interface Schema$A2aV1DataPart {
data?: {
[key: string]: any;
} | null;
}
/**
* FilePart represents the different ways files can be provided. If files are small, directly feeding the bytes is supported via file_with_bytes. If the file is large, the agent should read the content as appropriate directly from the file_with_uri source.
*/
export interface Schema$A2aV1FilePart {
fileWithBytes?: string | null;
fileWithUri?: string | null;
mimeType?: string | null;
name?: string | null;
}
export interface Schema$A2aV1HTTPAuthSecurityScheme {
/**
* A hint to the client to identify how the bearer token is formatted. Bearer tokens are usually generated by an authorization server, so this information is primarily for documentation purposes.
*/
bearerFormat?: string | null;
/**
* Description of this security scheme.
*/
description?: string | null;
/**
* The name of the HTTP Authentication scheme to be used in the Authorization header as defined in RFC7235. The values used SHOULD be registered in the IANA Authentication Scheme registry. The value is case-insensitive, as defined in RFC7235.
*/
scheme?: string | null;
}
export interface Schema$A2aV1ImplicitOAuthFlow {
/**
* The authorization URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS
*/
authorizationUrl?: string | null;
/**
* The URL to be used for obtaining refresh tokens. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.
*/
refreshUrl?: string | null;
/**
* The available scopes for the OAuth2 security scheme. A map between the scope name and a short description for it. The map MAY be empty.
*/
scopes?: {
[key: string]: string;
} | null;
}
export interface Schema$A2aV1ListTaskPushNotificationConfigResponse {
/**
* The list of push notification configurations.
*/
configs?: Schema$A2aV1TaskPushNotificationConfig[];
/**
* A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
*/
nextPageToken?: string | null;
}
/**
* Message is one unit of communication between client and server. It is associated with a context and optionally a task. Since the server is responsible for the context definition, it must always provide a context_id in its messages. The client can optionally provide the context_id if it knows the context to associate the message to. Similarly for task_id, except the server decides if a task is created and whether to include the task_id.
*/
export interface Schema$A2aV1Message {
/**
* protolint:disable REPEATED_FIELD_NAMES_PLURALIZED Content is the container of the message content.
*/
content?: Schema$A2aV1Part[];
/**
* The context id of the message. This is optional and if set, the message will be associated with the given context.
*/
contextId?: string | null;
/**
* The URIs of extensions that are present or contributed to this Message.
*/
extensions?: string[] | null;
/**
* The unique identifier (e.g. UUID)of the message. This is required and created by the message creator.
*/
messageId?: string | null;
/**
* protolint:enable REPEATED_FIELD_NAMES_PLURALIZED Any optional metadata to provide along with the message.
*/
metadata?: {
[key: string]: any;
} | null;
/**
* A role for the message.
*/
role?: string | null;
/**
* The task id of the message. This is optional and if set, the message will be associated with the given task.
*/
taskId?: string | null;
}
export interface Schema$A2aV1MutualTlsSecurityScheme {
/**
* Description of this security scheme.
*/
description?: string | null;
}
export interface Schema$A2aV1OAuth2SecurityScheme {
/**
* Description of this security scheme.
*/
description?: string | null;
/**
* An object containing configuration information for the flow types supported
*/
flows?: Schema$A2aV1OAuthFlows;
/**
* URL to the oauth2 authorization server metadata [RFC8414](https://datatracker.ietf.org/doc/html/rfc8414). TLS is required.
*/
oauth2MetadataUrl?: string | null;
}
export interface Schema$A2aV1OAuthFlows {
authorizationCode?: Schema$A2aV1AuthorizationCodeOAuthFlow;
clientCredentials?: Schema$A2aV1ClientCredentialsOAuthFlow;
implicit?: Schema$A2aV1ImplicitOAuthFlow;
password?: Schema$A2aV1PasswordOAuthFlow;
}
export interface Schema$A2aV1OpenIdConnectSecurityScheme {
/**
* Description of this security scheme.
*/
description?: string | null;
/**
* Well-known URL to discover the [[OpenID-Connect-Discovery]] provider metadata.
*/
openIdConnectUrl?: string | null;
}
/**
* Part represents a container for a section of communication content. Parts can be purely textual, some sort of file (image, video, etc) or a structured data blob (i.e. JSON).
*/
export interface Schema$A2aV1Part {
data?: Schema$A2aV1DataPart;
file?: Schema$A2aV1FilePart;
/**
* Optional metadata associated with this part.
*/
metadata?: {
[key: string]: any;
} | null;
text?: string | null;
}
export interface Schema$A2aV1PasswordOAuthFlow {
/**
* The URL to be used for obtaining refresh tokens. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.
*/
refreshUrl?: string | null;
/**
* The available scopes for the OAuth2 security scheme. A map between the scope name and a short description for it. The map MAY be empty.
*/
scopes?: {
[key: string]: string;
} | null;
/**
* The token URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.
*/
tokenUrl?: string | null;
}
/**
* Configuration for setting up push notifications for task updates.
*/
export interface Schema$A2aV1PushNotificationConfig {
/**
* Information about the authentication to sent with the notification
*/
authentication?: Schema$A2aV1AuthenticationInfo;
/**
* A unique identifier (e.g. UUID) for this push notification.
*/
id?: string | null;
/**
* Token unique for this task/session
*/
token?: string | null;
/**
* Url to send the notification too
*/
url?: string | null;
}
export interface Schema$A2aV1Security {
schemes?: {
[key: string]: Schema$A2aV1StringList;
} | null;
}
export interface Schema$A2aV1SecurityScheme {
apiKeySecurityScheme?: Schema$A2aV1APIKeySecurityScheme;
httpAuthSecurityScheme?: Schema$A2aV1HTTPAuthSecurityScheme;
mtlsSecurityScheme?: Schema$A2aV1MutualTlsSecurityScheme;
oauth2SecurityScheme?: Schema$A2aV1OAuth2SecurityScheme;
openIdConnectSecurityScheme?: Schema$A2aV1OpenIdConnectSecurityScheme;
}
/**
* Configuration of a send message request.
*/
export interface Schema$A2aV1SendMessageConfiguration {
/**
* The output modes that the agent is expected to respond with.
*/
acceptedOutputModes?: string[] | null;
/**
* If true, the message will be blocking until the task is completed. If false, the message will be non-blocking and the task will be returned immediately. It is the caller's responsibility to check for any task updates.
*/
blocking?: boolean | null;
/**
* The maximum number of messages to include in the history. if 0, the history will be unlimited.
*/
historyLength?: number | null;
/**
* A configuration of a webhook that can be used to receive updates
*/
pushNotification?: Schema$A2aV1PushNotificationConfig;
}
/**
* /////////// Request Messages ///////////
*/
export interface Schema$A2aV1SendMessageRequest {
/**
* Configuration for the send request.
*/
configuration?: Schema$A2aV1SendMessageConfiguration;
/**
* Required. The message to send to the agent.
*/
message?: Schema$A2aV1Message;
/**
* Optional metadata for the request.
*/
metadata?: {
[key: string]: any;
} | null;
}
/**
* ////// Response Messages ///////////
*/
export interface Schema$A2aV1SendMessageResponse {
message?: Schema$A2aV1Message;
task?: Schema$A2aV1Task;
}
/**
* The stream response for a message. The stream should be one of the following sequences: If the response is a message, the stream should contain one, and only one, message and then close If the response is a task lifecycle, the first response should be a Task object followed by zero or more TaskStatusUpdateEvents and TaskArtifactUpdateEvents. The stream should complete when the Task if in an interrupted or terminal state. A stream that ends before these conditions are met are
*/
export interface Schema$A2aV1StreamResponse {
artifactUpdate?: Schema$A2aV1TaskArtifactUpdateEvent;
message?: Schema$A2aV1Message;
statusUpdate?: Schema$A2aV1TaskStatusUpdateEvent;
task?: Schema$A2aV1Task;
}
/**
* protolint:disable REPEATED_FIELD_NAMES_PLURALIZED
*/
export interface Schema$A2aV1StringList {
list?: string[] | null;
}
/**
* Task is the core unit of action for A2A. It has a current status and when results are created for the task they are stored in the artifact. If there are multiple turns for a task, these are stored in history.
*/
export interface Schema$A2aV1Task {
/**
* A set of output artifacts for a Task.
*/
artifacts?: Schema$A2aV1Artifact[];
/**
* Unique identifier (e.g. UUID) for the contextual collection of interactions (tasks and messages). Created by the A2A server.
*/
contextId?: string | null;
/**
* protolint:disable REPEATED_FIELD_NAMES_PLURALIZED The history of interactions from a task.
*/
history?: Schema$A2aV1Message[];
/**
* Unique identifier (e.g. UUID) for the task, generated by the server for a new task.
*/
id?: string | null;
/**
* protolint:enable REPEATED_FIELD_NAMES_PLURALIZED A key/value object to store custom metadata about a task.
*/
metadata?: {
[key: string]: any;
} | null;
/**
* The current status of a Task, including state and a message.
*/
status?: Schema$A2aV1TaskStatus;
}
/**
* TaskArtifactUpdateEvent represents a task delta where an artifact has been generated.
*/
export interface Schema$A2aV1TaskArtifactUpdateEvent {
/**
* Whether this should be appended to a prior one produced
*/
append?: boolean | null;
/**
* The artifact itself
*/
artifact?: Schema$A2aV1Artifact;
/**
* The id of the context that this task belongs too
*/
contextId?: string | null;
/**
* Whether this represents the last part of an artifact
*/
lastChunk?: boolean | null;
/**
* Optional metadata associated with the artifact update.
*/
metadata?: {
[key: string]: any;
} | null;
/**
* The id of the task for this artifact
*/
taskId?: string | null;
}
export interface Schema$A2aV1TaskPushNotificationConfig {
/**
* The resource name of the config. Format: tasks/{task_id\}/pushNotificationConfigs/{config_id\}
*/
name?: string | null;
/**
* The push notification configuration details.
*/
pushNotificationConfig?: Schema$A2aV1PushNotificationConfig;
}
/**
* A container for the status of a task
*/
export interface Schema$A2aV1TaskStatus {
/**
* A message associated with the status.
*/
message?: Schema$A2aV1Message;
/**
* The current state of this task
*/
state?: string | null;
/**
* Timestamp when the status was recorded. Example: "2023-10-27T10:00:00Z"
*/
timestamp?: string | null;
}
/**
* TaskStatusUpdateEvent is a delta even on a task indicating that a task has changed.
*/
export interface Schema$A2aV1TaskStatusUpdateEvent {
/**
* The id of the context that the task belongs to
*/
contextId?: string | null;
/**
* Whether this is the last status update expected for this task.
*/
final?: boolean | null;
/**
* Optional metadata to associate with the task update.
*/
metadata?: {
[key: string]: any;
} | null;
/**
* The new status of the task.
*/
status?: Schema$A2aV1TaskStatus;
/**
* The id of the task that is changed
*/
taskId?: string | null;
}
/**
* `Distribution` contains summary statistics for a population of values. It optionally contains a histogram representing the distribution of those values across a set of buckets. The summary statistics are the count, mean, sum of the squared deviation from the mean, the minimum, and the maximum of the set of population of values. The histogram is based on a sequence of buckets and gives a count of values that fall into each bucket. The boundaries of the buckets are given either explicitly or by formulas for buckets of fixed or exponentially increasing widths. Although it is not forbidden, it is generally a bad idea to include non-finite values (infinities or NaNs) in the population of values, as this will render the `mean` and `sum_of_squared_deviation` fields meaningless.
*/
export interface Schema$GoogleApiDistribution {
/**
* The number of values in each bucket of the histogram, as described in `bucket_options`. If the distribution does not have a histogram, then omit this field. If there is a histogram, then the sum of the values in `bucket_counts` must equal the value in the `count` field of the distribution. If present, `bucket_counts` should contain N values, where N is the number of buckets specified in `bucket_options`. If you supply fewer than N values, the remaining values are assumed to be 0. The order of the values in `bucket_counts` follows the bucket numbering schemes described for the three bucket types. The first value must be the count for the underflow bucket (number 0). The next N-2 values are the counts for the finite buckets (number 1 through N-2). The N'th value in `bucket_counts` is the count for the overflow bucket (number N-1).
*/
bucketCounts?: string[] | null;
/**
* Defines the histogram bucket boundaries. If the distribution does not contain a histogram, then omit this field.
*/
bucketOptions?: Schema$GoogleApiDistributionBucketOptions;
/**
* The number of values in the population. Must be non-negative. This value must equal the sum of the values in `bucket_counts` if a histogram is provided.
*/
count?: string | null;
/**
* Must be in increasing order of `value` field.
*/
exemplars?: Schema$GoogleApiDistributionExemplar[];
/**
* The arithmetic mean of the values in the population. If `count` is zero then this field must be zero.
*/
mean?: number | null;
/**
* If specified, contains the range of the population values. The field must not be present if the `count` is zero.
*/
range?: Schema$GoogleApiDistributionRange;
/**
* The sum of squared deviations from the mean of the values in the population. For values x_i this is: Sum[i=1..n]((x_i - mean)^2) Knuth, "The Art of Computer Programming", Vol. 2, page 232, 3rd edition describes Welford's method for accumulating this sum in one pass. If `count` is zero then this field must be zero.
*/
sumOfSquaredDeviation?: number | null;
}
/**
* `BucketOptions` describes the bucket boundaries used to create a histogram for the distribution. The buckets can be in a linear sequence, an exponential sequence, or each bucket can be specified explicitly. `BucketOptions` does not include the number of values in each bucket. A bucket has an inclusive lower bound and exclusive upper bound for the values that are counted for that bucket. The upper bound of a bucket must be strictly greater than the lower bound. The sequence of N buckets for a distribution consists of an underflow bucket (number 0), zero or more finite buckets (number 1 through N - 2) and an overflow bucket (number N - 1). The buckets are contiguous: the lower bound of bucket i (i \> 0) is the same as the upper bound of bucket i - 1. The buckets span the whole range of finite values: lower bound of the underflow bucket is -infinity and the upper bound of the overflow bucket is +infinity. The finite buckets are so-called because both bounds are finite.
*/
export interface Schema$GoogleApiDistributionBucketOptions {
/**
* The explicit buckets.
*/
explicitBuckets?: Schema$GoogleApiDistributionBucketOptionsExplicit;
/**
* The exponential buckets.
*/
exponentialBuckets?: Schema$GoogleApiDistributionBucketOptionsExponential;
/**
* The linear bucket.
*/
linearBuckets?: Schema$GoogleApiDistributionBucketOptionsLinear;
}
/**
* Specifies a set of buckets with arbitrary widths. There are `size(bounds) + 1` (= N) buckets. Bucket `i` has the following boundaries: Upper bound (0 <= i < N-1): bounds[i] Lower bound (1 <= i < N); bounds[i - 1] The `bounds` field must contain at least one element. If `bounds` has only one element, then there are no finite buckets, and that single element is the common boundary of the overflow and underflow buckets.
*/
export interface Schema$GoogleApiDistributionBucketOptionsExplicit {
/**
* The values must be monotonically increasing.
*/
bounds?: number[] | null;
}
/**
* Specifies an exponential sequence of buckets that have a width that is proportional to the value of the lower bound. Each bucket represents a constant relative uncertainty on a specific value in the bucket. There are `num_finite_buckets + 2` (= N) buckets. Bucket `i` has the following boundaries: Upper bound (0 <= i < N-1): scale * (growth_factor ^ i). Lower bound (1 <= i < N): scale * (growth_factor ^ (i - 1)).
*/
export interface Schema$GoogleApiDistributionBucketOptionsExponential {
/**
* Must be greater than 1.
*/
growthFactor?: number | null;
/**
* Must be greater than 0.
*/
numFiniteBuckets?: number | null;
/**
* Must be greater than 0.
*/
scale?: number | null;
}
/**
* Specifies a linear sequence of buckets that all have the same width (except overflow and underflow). Each bucket represents a constant absolute uncertainty on the specific value in the bucket. There are `num_finite_buckets + 2` (= N) buckets. Bucket `i` has the following boundaries: Upper bound (0 <= i < N-1): offset + (width * i). Lower bound (1 <= i < N): offset + (width * (i - 1)).
*/
export interface Schema$GoogleApiDistributionBucketOptionsLinear {
/**
* Must be greater than 0.
*/
numFiniteBuckets?: number | null;
/**
* Lower bound of the first bucket.
*/
offset?: number | null;
/**
* Must be greater than 0.
*/
width?: number | null;
}
/**
* Exemplars are example points that may be used to annotate aggregated distribution values. They are metadata that gives information about a particular value added to a Distribution bucket, such as a trace ID that was active when a value was added. They may contain further information, such as a example values and timestamps, origin, etc.
*/
export interface Schema$GoogleApiDistributionExemplar {
/**
* Contextual information about the example value. Examples are: Trace: type.googleapis.com/google.monitoring.v3.SpanContext Literal string: type.googleapis.com/google.protobuf.StringValue Labels dropped during aggregation: type.googleapis.com/google.monitoring.v3.DroppedLabels There may be only a single attachment of any given message type in a single exemplar, and this is enforced by the system.
*/
attachments?: Array<{
[key: string]: any;
}> | null;
/**
* The observation (sampling) time of the above value.
*/
timestamp?: string | null;
/**
* Value of the exemplar point. This value determines to which bucket the exemplar belongs.
*/
value?: number | null;
}
/**
* The range of the population values.
*/
export interface Schema$GoogleApiDistributionRange {
/**
* The maximum of the population values.
*/
max?: number | null;
/**
* The minimum of the population values.
*/
min?: number | null;
}
/**
* Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; \} service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); \} Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); \} Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged.
*/
export interface Schema$GoogleApiHttpBody {
/**
* The HTTP Content-Type header value specifying the content type of the body.
*/
contentType?: string | null;
/**
* The HTTP request/response body as raw binary.
*/
data?: string | null;
/**
* Application specific response metadata. Must be set in the first response for streaming APIs.
*/
extensions?: Array<{
[key: string]: any;
}> | null;
}
/**
* A specific metric, identified by specifying values for all of the labels of a `MetricDescriptor`.
*/
export interface Schema$GoogleApiMetric {
/**
* The set of label values that uniquely identify this metric. All labels listed in the `MetricDescriptor` must be assigned values.
*/
labels?: {
[key: string]: string;
} | null;
/**
* An existing metric type, see google.api.MetricDescriptor. For example, `custom.googleapis.com/invoice/paid/amount`.
*/
type?: string | null;
}
/**
* An object representing a resource that can be used for monitoring, logging, billing, or other purposes. Examples include virtual machine instances, databases, and storage devices such as disks. The `type` field identifies a MonitoredResourceDescriptor object that describes the resource's schema. Information in the `labels` field identifies the actual resource and its attributes according to the schema. For example, a particular Compute Engine VM instance could be represented by the following object, because the MonitoredResourceDescriptor for `"gce_instance"` has labels `"project_id"`, `"instance_id"` and `"zone"`: { "type": "gce_instance", "labels": { "project_id": "my-project", "instance_id": "12345678901234", "zone": "us-central1-a" \}\}
*/
export interface Schema$GoogleApiMonitoredResource {
/**
* Required. Values for all of the labels listed in the associated monitored resource descriptor. For example, Compute Engine VM instances use the labels `"project_id"`, `"instance_id"`, and `"zone"`.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Required. The monitored resource type. This field must match the `type` field of a MonitoredResourceDescriptor object. For example, the type of a Compute Engine VM instance is `gce_instance`. Some descriptors include the service name in the type; for example, the type of a Datastream stream is `datastream.googleapis.com/Stream`.
*/
type?: string | null;
}
/**
* Auxiliary metadata for a MonitoredResource object. MonitoredResource objects contain the minimum set of information to uniquely identify a monitored resource instance. There is some other useful auxiliary metadata. Monitoring and Logging use an ingestion pipeline to extract metadata for cloud resources of all types, and store the metadata in this message.
*/
export interface Schema$GoogleApiMonitoredResourceMetadata {
/**
* Output only. Values for predefined system metadata labels. System labels are a kind of metadata extracted by Google, including "machine_image", "vpc", "subnet_id", "security_group", "name", etc. System label values can be only strings, Boolean values, or a list of strings. For example: { "name": "my-test-instance", "security_group": ["a", "b", "c"], "spot_instance": false \}
*/
systemLabels?: {
[key: string]: any;
} | null;
/**
* Output only. A map of user-defined metadata labels.
*/
userLabels?: {
[key: string]: string;
} | null;
}
/**
* The error payload that is populated on LRO sync APIs, including the following: * `google.cloud.discoveryengine.v1main.DataConnectorService.SetUpDataConnector` * `google.cloud.discoveryengine.v1main.DataConnectorService.StartConnectorRun`
*/
export interface Schema$GoogleCloudDiscoveryengineLoggingConnectorRunErrorContext {
/**
* The full resource name of the Connector Run. Format: `projects/x/locations/x/collections/x/dataConnector/connectorRuns/x`. The `connector_run_id` is system-generated.
*/
connectorRun?: string | null;
/**
* The full resource name of the DataConnector. Format: `projects/x/locations/x/collections/x/dataConnector`.
*/
dataConnector?: string | null;
/**
* The time when the connector run ended.
*/
endTime?: string | null;
/**
* The entity to sync for the connector run.
*/
entity?: string | null;
/**
* The operation resource name of the LRO to sync the connector.
*/
operation?: string | null;
/**
* The time when the connector run started.
*/
startTime?: string | null;
/**
* The type of sync run. Can be one of the following: * `FULL` * `INCREMENTAL`
*/
syncType?: string | null;
}
/**
* A description of the context in which an error occurred.
*/
export interface Schema$GoogleCloudDiscoveryengineLoggingErrorContext {
/**
* The HTTP request which was processed when the error was triggered.
*/
httpRequest?: Schema$GoogleCloudDiscoveryengineLoggingHttpRequestContext;
/**
* The location in the source code where the decision was made to report the error, usually the place where it was logged.
*/
reportLocation?: Schema$GoogleCloudDiscoveryengineLoggingSourceLocation;
}
/**
* An error log which is reported to the Error Reporting system.
*/
export interface Schema$GoogleCloudDiscoveryengineLoggingErrorLog {
/**
* The error payload that is populated on LRO connector sync APIs.
*/
connectorRunPayload?: Schema$GoogleCloudDiscoveryengineLoggingConnectorRunErrorContext;
/**
* A description of the context in which the error occurred.
*/
context?: Schema$GoogleCloudDiscoveryengineLoggingErrorContext;
/**
* The error payload that is populated on LRO import APIs.
*/
importPayload?: Schema$GoogleCloudDiscoveryengineLoggingImportErrorContext;
/**
* A message describing the error.
*/
message?: string | null;
/**
* The API request payload, represented as a protocol buffer. Most API request types are supported—for example: * `type.googleapis.com/google.cloud.discoveryengine.v1alpha.DocumentService.CreateDocumentRequest` * `type.googleapis.com/google.cloud.discoveryengine.v1alpha.UserEventService.WriteUserEventRequest`
*/
requestPayload?: {
[key: string]: any;
} | null;
/**
* The API response payload, represented as a protocol buffer. This is used to log some "soft errors", where the response is valid but we consider there are some quality issues like unjoined events. The following API responses are supported, and no PII is included: * `google.cloud.discoveryengine.v1alpha.RecommendationService.Recommend` * `google.cloud.discoveryengine.v1alpha.UserEventService.WriteUserEvent` * `google.cloud.discoveryengine.v1alpha.UserEventService.CollectUserEvent`
*/
responsePayload?: {
[key: string]: any;
} | null;
/**
* The service context in which this error has occurred.
*/
serviceContext?: Schema$GoogleCloudDiscoveryengineLoggingServiceContext;
/**
* The RPC status associated with the error log.
*/
status?: Schema$GoogleRpcStatus;
}
/**
* HTTP request data that is related to a reported error.
*/
export interface Schema$GoogleCloudDiscoveryengineLoggingHttpRequestContext {
/**
* The HTTP response status code for the request.
*/
responseStatusCode?: number | null;
}
/**
* The error payload that is populated on LRO import APIs, including the following: * `google.cloud.discoveryengine.v1alpha.DocumentService.ImportDocuments` * `google.cloud.discoveryengine.v1alpha.UserEventService.ImportUserEvents`
*/
export interface Schema$GoogleCloudDiscoveryengineLoggingImportErrorContext {
/**
* The detailed content which caused the error on importing a document.
*/
document?: string | null;
/**
* Google Cloud Storage file path of the import source. Can be set for batch operation error.
*/
gcsPath?: string | null;
/**
* Line number of the content in file. Should be empty for permission or batch operation error.
*/
lineNumber?: string | null;
/**
* The operation resource name of the LRO.
*/
operation?: string | null;
/**
* The detailed content which caused the error on importing a user event.
*/
userEvent?: string | null;
}
/**
* Describes a running service that sends errors.
*/
export interface Schema$GoogleCloudDiscoveryengineLoggingServiceContext {
/**
* An identifier of the service—for example, `discoveryengine.googleapis.com`.
*/
service?: string | null;
}
/**
* Indicates a location in the source code of the service for which errors are reported.
*/
export interface Schema$GoogleCloudDiscoveryengineLoggingSourceLocation {
/**
* Human-readable name of a function or method—for example, `google.cloud.discoveryengine.v1alpha.RecommendationService.Recommend`.
*/
functionName?: string | null;
}
/**
* Access Control Configuration.
*/
export interface Schema$GoogleCloudDiscoveryengineV1AclConfig {
/**
* Identity provider config.
*/
idpConfig?: Schema$GoogleCloudDiscoveryengineV1IdpConfig;
/**
* Immutable. The full resource name of the acl configuration. Format: `projects/{project\}/locations/{location\}/aclConfig`. This field must be a UTF-8 encoded string with a length limit of 1024 characters.
*/
name?: string | null;
}
/**
* Informations to support actions on the connector.
*/
export interface Schema$GoogleCloudDiscoveryengineV1ActionConfig {
/**
* Optional. Action parameters in structured json format.
*/
actionParams?: {
[key: string]: any;
} | null;
/**
* Optional. Whether to create a BAP connection for the connector.
*/
createBapConnection?: boolean | null;
/**
* Output only. The connector contains the necessary parameters and is configured to support actions.
*/
isActionConfigured?: boolean | null;
/**
* Optional. Action parameters in json string format.
*/
jsonActionParams?: string | null;
/**
* Optional. The Service Directory resource name (projects/x/locations/x/namespaces/x/services/x) representing a VPC network endpoint used to connect to the data source's `instance_uri`, defined in DataConnector.params. Required when VPC Service Controls are enabled.
*/
serviceName?: string | null;
/**
* Optional. Mapping from operation name to the list of scopes. Only be populated if there are user specified scopes.
*/
userDefinedScopesMa