common.ts

/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

// Code generated by the Google Gen AI SDK generator DO NOT EDIT.

import * as genaiTypes from '@google/genai';

/** The identity type to use for the Reasoning Engine. If not specified, the `service_account` field will be used if set, otherwise the default Vertex AI Reasoning Engine Service Agent in the project will be used. */
export enum IdentityType {
  /**
   * Default value. Use a custom service account if the `service_account` field is set, otherwise use the default Vertex AI Reasoning Engine Service Agent in the project. Same behavior as SERVICE_ACCOUNT.
   */
  IDENTITY_TYPE_UNSPECIFIED = 'IDENTITY_TYPE_UNSPECIFIED',
  /**
   * Use a custom service account if the `service_account` field is set, otherwise use the default Vertex AI Reasoning Engine Service Agent in the project.
   */
  SERVICE_ACCOUNT = 'SERVICE_ACCOUNT',
  /**
   * Use Agent Identity. The `service_account` field must not be set.
   */
  AGENT_IDENTITY = 'AGENT_IDENTITY',
}

/** The agent server mode. */
export enum AgentServerMode {
  /**
   * Unspecified agent server mode. Do not use.
   */
  AGENT_SERVER_MODE_UNSPECIFIED = 'AGENT_SERVER_MODE_UNSPECIFIED',
  /**
   * Stable agent server mode. This mode has everything stable and well-tested features agent engine offers.
   */
  STABLE = 'STABLE',
  /**
   * Experimental agent server mode. This mode contains experimental features.
   */
  EXPERIMENTAL = 'EXPERIMENTAL',
}

/** Represents the managed memory topic. */
export enum ManagedTopicEnum {
  /**
   * Represents an unspecified topic. This value should not be used.
   */
  MANAGED_TOPIC_ENUM_UNSPECIFIED = 'MANAGED_TOPIC_ENUM_UNSPECIFIED',
  /**
   * Represents significant personal information about the User like first names, relationships, hobbies, important dates.
   */
  USER_PERSONAL_INFO = 'USER_PERSONAL_INFO',
  /**
   * Represents stated or implied likes, dislikes, preferred styles, or patterns.
   */
  USER_PREFERENCES = 'USER_PREFERENCES',
  /**
   * Represents important milestones or conclusions within the dialogue.
   */
  KEY_CONVERSATION_DETAILS = 'KEY_CONVERSATION_DETAILS',
  /**
   * Represents information that the user explicitly requested to remember or forget.
   */
  EXPLICIT_INSTRUCTIONS = 'EXPLICIT_INSTRUCTIONS',
}

/** The type of the memory. */
export enum MemoryType {
  /**
   * Represents an unspecified memory type. This value should not be used.
   */
  MEMORY_TYPE_UNSPECIFIED = 'MEMORY_TYPE_UNSPECIFIED',
  /**
   * Indicates belonging to a collection of natural language memories.
   */
  NATURAL_LANGUAGE_COLLECTION = 'NATURAL_LANGUAGE_COLLECTION',
  /**
   * Indicates belonging to a structured profile.
   */
  STRUCTURED_PROFILE = 'STRUCTURED_PROFILE',
}

/** Represents the operator to apply to the filter. If not set, then EQUAL will be used. */
export enum Operator {
  /**
   * Represents an unspecified operator. Defaults to EQUAL.
   */
  OPERATOR_UNSPECIFIED = 'OPERATOR_UNSPECIFIED',
  /**
   * Equal to.
   */
  EQUAL = 'EQUAL',
  /**
   * Greater than.
   */
  GREATER_THAN = 'GREATER_THAN',
  /**
   * Less than.
   */
  LESS_THAN = 'LESS_THAN',
}

/** The coding language supported in this environment. */
export enum Language {
  /**
   * The default value. This value is unused.
   */
  LANGUAGE_UNSPECIFIED = 'LANGUAGE_UNSPECIFIED',
  /**
   * The coding language is Python.
   */
  LANGUAGE_PYTHON = 'LANGUAGE_PYTHON',
  /**
   * The coding language is JavaScript.
   */
  LANGUAGE_JAVASCRIPT = 'LANGUAGE_JAVASCRIPT',
}

/** The machine config of the code execution environment. */
export enum MachineConfig {
  /**
   * The default value: milligcu 2000, memory 1.5Gib
   */
  MACHINE_CONFIG_UNSPECIFIED = 'MACHINE_CONFIG_UNSPECIFIED',
  /**
   * The default value: milligcu 4000, memory 4 Gib
   */
  MACHINE_CONFIG_VCPU4_RAM4GIB = 'MACHINE_CONFIG_VCPU4_RAM4GIB',
}

/** Output only. The runtime state of the SandboxEnvironment. */
export enum SandboxState {
  /**
   * The default value. This value is unused.
   */
  STATE_UNSPECIFIED = 'STATE_UNSPECIFIED',
  /**
   * Runtime resources are being allocated for the sandbox environment.
   */
  STATE_PROVISIONING = 'STATE_PROVISIONING',
  /**
   * Sandbox runtime is ready for serving.
   */
  STATE_RUNNING = 'STATE_RUNNING',
  /**
   * Sandbox runtime is halted, performing tear down tasks.
   */
  STATE_DEPROVISIONING = 'STATE_DEPROVISIONING',
  /**
   * Sandbox has terminated with underlying runtime failure.
   */
  STATE_TERMINATED = 'STATE_TERMINATED',
  /**
   * Sandbox runtime has been deleted.
   */
  STATE_DELETED = 'STATE_DELETED',
}

/** Protocol for port. Defaults to TCP if not specified. */
export enum Protocol {
  /**
   * Unspecified protocol. Defaults to TCP.
   */
  PROTOCOL_UNSPECIFIED = 'PROTOCOL_UNSPECIFIED',
  /**
   * TCP protocol.
   */
  TCP = 'TCP',
  /**
   * UDP protocol.
   */
  UDP = 'UDP',
}

/** The category of the default container image. */
export enum DefaultContainerCategory {
  /**
   * The default value. This value is unused.
   */
  DEFAULT_CONTAINER_CATEGORY_UNSPECIFIED = 'DEFAULT_CONTAINER_CATEGORY_UNSPECIFIED',
  /**
   * The default container image for Computer Use.
   */
  DEFAULT_CONTAINER_CATEGORY_COMPUTER_USE = 'DEFAULT_CONTAINER_CATEGORY_COMPUTER_USE',
  /**
   * The default container image for Shell Sandbox.
   */
  DEFAULT_CONTAINER_CATEGORY_SHELL_SANDBOX = 'DEFAULT_CONTAINER_CATEGORY_SHELL_SANDBOX',
}

/** Output only. The state of the PSC service automation. */
export enum PscAutomationState {
  /**
   * Should not be used.
   */
  PSC_AUTOMATION_STATE_UNSPECIFIED = 'PSC_AUTOMATION_STATE_UNSPECIFIED',
  /**
   * The PSC service automation is successful.
   */
  PSC_AUTOMATION_STATE_SUCCESSFUL = 'PSC_AUTOMATION_STATE_SUCCESSFUL',
  /**
   * The PSC service automation has failed.
   */
  PSC_AUTOMATION_STATE_FAILED = 'PSC_AUTOMATION_STATE_FAILED',
}

/** Input only. Action to take on the source SandboxEnvironment after the snapshot is taken. This field is only used in CreateSandboxEnvironmentSnapshotRequest and it is not stored in the resource. */
export enum PostSnapshotAction {
  /**
   * The default value. This value is unused.
   */
  POST_SNAPSHOT_ACTION_UNSPECIFIED = 'POST_SNAPSHOT_ACTION_UNSPECIFIED',
  /**
   * Sandbox environment will continue to run after snapshot is taken.
   */
  RUNNING = 'RUNNING',
  /**
   * Sandbox environment will be paused after snapshot is taken.
   */
  PAUSE = 'PAUSE',
}

/** Output only. The source of the Skill. */
export enum SkillSource {
  /**
   * The skill source is unspecified.
   */
  SKILL_SOURCE_UNSPECIFIED = 'SKILL_SOURCE_UNSPECIFIED',
  /**
   * The skill is created by a user.
   */
  USER = 'USER',
  /**
   * The skill is a system skill.
   */
  SYSTEM = 'SYSTEM',
}

/** State of the Skill. */
export enum SkillState {
  /**
   * The state of the Skill is unspecified.
   */
  STATE_UNSPECIFIED = 'STATE_UNSPECIFIED',
  /**
   * The Skill is active.
   */
  ACTIVE = 'ACTIVE',
  /**
   * The Skill is being created.
   */
  CREATING = 'CREATING',
  /**
   * The Skill was created, but failed to process.
   */
  FAILED = 'FAILED',
  /**
   * The Skill is being deleted.
   */
  DELETING = 'DELETING',
}

/** Output only. The state of the Skill Revision. */
export enum State {
  /**
   * The state of the Skill Revision is unspecified.
   */
  STATE_UNSPECIFIED = 'STATE_UNSPECIFIED',
  /**
   * The Skill Revision is active.
   */
  ACTIVE = 'ACTIVE',
  /**
   * The Skill Revision is being created.
   */
  CREATING = 'CREATING',
  /**
   * The Skill Revision was created, but failed to process.
   */
  FAILED = 'FAILED',
  /**
   * The Skill Revision is being deleted.
   */
  DELETING = 'DELETING',
}

/** Framework used to build the application. */
export enum Framework {
  /**
   * Unspecified framework.
   */
  FRAMEWORK_UNSPECIFIED = 'FRAMEWORK_UNSPECIFIED',
  /**
   * React framework.
   */
  REACT = 'REACT',
  /**
   * Angular framework.
   */
  ANGULAR = 'ANGULAR',
}

/** The strategy to use when applying metadata to existing memories during consolidation. */
export enum MemoryMetadataMergeStrategy {
  /**
   * The metadata merge strategy is unspecified.
   */
  METADATA_MERGE_STRATEGY_UNSPECIFIED = 'METADATA_MERGE_STRATEGY_UNSPECIFIED',
  /**
   * Replace the metadata of the updated memories with the new metadata.
   */
  OVERWRITE = 'OVERWRITE',
  /**
   * Append new metadata to the existing metadata. If there are duplicate keys, the existing values will be overwritten.
   */
  MERGE = 'MERGE',
  /**
   * Restrict consolidation to memories that have exactly the same metadata as the request. If a memory doesn't have the same metadata, it is not eligible for consolidation.
   */
  REQUIRE_EXACT_MATCH = 'REQUIRE_EXACT_MATCH',
}

/** The action to take. */
export enum GenerateMemoriesResponseGeneratedMemoryAction {
  /**
   * The action is unspecified.
   */
  ACTION_UNSPECIFIED = 'ACTION_UNSPECIFIED',
  /**
   * The memory was created.
   */
  CREATED = 'CREATED',
  /**
   * The memory was updated. The `fact` field may not be updated if the existing fact is still accurate.
   */
  UPDATED = 'UPDATED',
  /**
   * The memory was deleted.
   */
  DELETED = 'DELETED',
}

/** State of the Skill Revision. */
export enum SkillRevisionState {
  /**
   * The state of the Skill Revision is unspecified.
   */
  STATE_UNSPECIFIED = 'STATE_UNSPECIFIED',
  /**
   * The Skill Revision is active.
   */
  ACTIVE = 'ACTIVE',
  /**
   * The Skill Revision is being created.
   */
  CREATING = 'CREATING',
  /**
   * The Skill Revision was created, but failed to process.
   */
  FAILED = 'FAILED',
  /**
   * The Skill Revision is being deleted.
   */
  DELETING = 'DELETING',
}

/** Represents an environment variable present in a Container or Python Module. */
export declare interface EnvVar {
  /** Required. Name of the environment variable. Must be a valid C identifier. */
  name?: string;
  /** Required. Variables that reference a $(VAR_NAME) are expanded using the previous defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. */
  value?: string;
}

/** DNS peering configuration. These configurations are used to create DNS peering zones in the Vertex tenant project VPC, enabling resolution of records within the specified domain hosted in the target network's Cloud DNS. */
export declare interface DnsPeeringConfig {
  /** Required. The DNS name suffix of the zone being peered to, e.g., "my-internal-domain.corp.". Must end with a dot. */
  domain?: string;
  /** Required. The VPC network name in the target_project where the DNS zone specified by 'domain' is visible. */
  targetNetwork?: string;
  /** Required. The project ID hosting the Cloud DNS managed zone that contains the 'domain'. The Vertex AI Service Agent requires the dns.peer role on this project. */
  targetProject?: string;
}

/** Configuration for PSC-I. */
export declare interface PscInterfaceConfig {
  /** Optional. DNS peering configurations. When specified, Vertex AI will attempt to configure DNS peering zones in the tenant project VPC to resolve the specified domains using the target network's Cloud DNS. The user must grant the dns.peer role to the Vertex AI Service Agent on the target project. */
  dnsPeeringConfigs?: DnsPeeringConfig[];
  /** Optional. The name of the Compute Engine [network attachment](https://cloud.google.com/vpc/docs/about-network-attachments) to attach to the resource within the region and user project. To specify this field, you must have already [created a network attachment] (https://cloud.google.com/vpc/docs/create-manage-network-attachments#create-network-attachments). This field is only used for resources using PSC-I. */
  networkAttachment?: string;
}

/** Reference to a secret stored in the Cloud Secret Manager that will provide the value for this environment variable. */
export declare interface SecretRef {
  /** Required. The name of the secret in Cloud Secret Manager. Format: {secret_name}. */
  secret?: string;
  /** The Cloud Secret Manager secret version. Can be 'latest' for the latest version, an integer for a specific version, or a version alias. */
  version?: string;
}

/** Represents an environment variable where the value is a secret in Cloud Secret Manager. */
export declare interface SecretEnvVar {
  /** Required. Name of the secret environment variable. */
  name?: string;
  /** Required. Reference to a secret stored in the Cloud Secret Manager that will provide the value for this environment variable. */
  secretRef?: SecretRef;
}

/** Configuration for traffic originating from a Reasoning Engine. */
export declare interface ReasoningEngineSpecDeploymentSpecAgentGatewayConfigAgentToAnywhereConfig {
  /** Required. The resource name of the Agent Gateway for outbound traffic. It must be set to a Google-managed gateway whose `governed_access_path` is `AGENT_TO_ANYWHERE`. Format: `projects/{project}/locations/{location}/agentGateways/{agent_gateway}` */
  agentGateway?: string;
}

/** Configuration for traffic targeting a Reasoning Engine. */
export declare interface ReasoningEngineSpecDeploymentSpecAgentGatewayConfigClientToAgentConfig {
  /** Required. The resource name of the Agent Gateway to use for inbound traffic. It must be set to a Google-managed gateway whose `governed_access_path` is `CLIENT_TO_AGENT`. Format: `projects/{project}/locations/{location}/agentGateways/{agent_gateway}` */
  agentGateway?: string;
}

/** Agent Gateway configuration for a Reasoning Engine deployment. */
export declare interface ReasoningEngineSpecDeploymentSpecAgentGatewayConfig {
  /** Optional. Configuration for traffic originating from the Reasoning Engine. When unset, outgoing traffic is not routed through an Agent Gateway. */
  agentToAnywhereConfig?: ReasoningEngineSpecDeploymentSpecAgentGatewayConfigAgentToAnywhereConfig;
  /** Optional. Configuration for traffic targeting the Reasoning Engine. When unset, incoming traffic is not routed through an Agent Gateway. */
  clientToAgentConfig?: ReasoningEngineSpecDeploymentSpecAgentGatewayConfigClientToAgentConfig;
}

/** Specifies the HTTP GET configuration for the probe. */
export declare interface KeepAliveProbeHttpGet {
  /** Required. Specifies the path of the HTTP GET request (e.g., `"/is_busy"`). */
  path?: string;
  /** Optional. Specifies the port number on the container to which the request is sent. */
  port?: number;
}

/** Represents the configuration for keep-alive probe. Contains configuration on a specified endpoint that a deployment host should use to keep the container alive based on the probe settings. */
export declare interface KeepAliveProbe {
  /** Optional. Specifies the HTTP GET configuration for the probe. */
  httpGet?: KeepAliveProbeHttpGet;
  /** Optional. Specifies the maximum duration (in seconds) to keep the instance alive via this probe. Can be a maximum of 3600 seconds (1 hour). */
  maxSeconds?: number;
}

/** The specification of a Reasoning Engine deployment. */
export declare interface ReasoningEngineSpecDeploymentSpec {
  /** The agent server mode. */
  agentServerMode?: AgentServerMode;
  /** Optional. Concurrency for each container and agent server. Recommended value: 2 * cpu + 1. Defaults to 9. */
  containerConcurrency?: number;
  /** Optional. Environment variables to be set with the Reasoning Engine deployment. The environment variables can be updated through the UpdateReasoningEngine API. */
  env?: EnvVar[];
  /** Optional. The maximum number of application instances that can be launched to handle increased traffic. Defaults to 100. Range: [1, 1000]. If VPC-SC or PSC-I is enabled, the acceptable range is [1, 100]. */
  maxInstances?: number;
  /** Optional. The minimum number of application instances that will be kept running at all times. Defaults to 1. Range: [0, 75]. */
  minInstances?: number;
  /** Optional. Configuration for PSC-I. */
  pscInterfaceConfig?: PscInterfaceConfig;
  /** Optional. Resource limits for each container. Only 'cpu' and 'memory' keys are supported. Defaults to {"cpu": "4", "memory": "4Gi"}. * The only supported values for CPU are '1', '2', '4', '6' and '8'. For more information, go to https://cloud.google.com/run/docs/configuring/cpu. * The only supported values for memory are '1Gi', '2Gi', ... '32 Gi'. * For required cpu on different memory values, go to https://cloud.google.com/run/docs/configuring/memory-limits */
  resourceLimits?: Record<string, string>;
  /** Optional. Environment variables where the value is a secret in Cloud Secret Manager. To use this feature, add 'Secret Manager Secret Accessor' role (roles/secretmanager.secretAccessor) to AI Platform Reasoning Engine Service Agent. */
  secretEnv?: SecretEnvVar[];
  /** Optional. Agent Gateway configuration for the Reasoning Engine deployment. */
  agentGatewayConfig?: ReasoningEngineSpecDeploymentSpecAgentGatewayConfig;
  /** Optional. Specifies the configuration for keep-alive probe. Contains configuration on a specified endpoint that a deployment host should use to keep the container alive based on the probe settings. */
  keepAliveProbe?: KeepAliveProbe;
}

/** User-provided package specification, containing pickled object and package requirements. */
export declare interface ReasoningEngineSpecPackageSpec {
  /** Optional. The Cloud Storage URI of the dependency files in tar.gz format. */
  dependencyFilesGcsUri?: string;
  /** Optional. The Cloud Storage URI of the pickled python object. */
  pickleObjectGcsUri?: string;
  /** Optional. The Python version. Supported values are 3.10, 3.11, 3.12, 3.13, 3.14. If not specified, the default value is 3.10. */
  pythonVersion?: string;
  /** Optional. The Cloud Storage URI of the `requirements.txt` file */
  requirementsGcsUri?: string;
}

/** Configuration for the Agent Development Kit (ADK). */
export declare interface ReasoningEngineSpecSourceCodeSpecAgentConfigSourceAdkConfig {
  /** Required. The value of the ADK config in JSON format. */
  jsonConfig?: Record<string, unknown>;
}

/** Specifies source code provided as a byte stream. */
export declare interface ReasoningEngineSpecSourceCodeSpecInlineSource {
  /** Required. Input only. The application source code archive. It must be a compressed tarball (.tar.gz) file.
   * @remarks Encoded as base64 string. */
  sourceArchive?: string;
}

/** Specification for the deploying from agent config. */
export declare interface ReasoningEngineSpecSourceCodeSpecAgentConfigSource {
  /** Required. The ADK configuration. */
  adkConfig?: ReasoningEngineSpecSourceCodeSpecAgentConfigSourceAdkConfig;
  /** Optional. Any additional files needed to interpret the config. If a `requirements.txt` file is present in the `inline_source`, the corresponding packages will be installed. If no `requirements.txt` file is present in `inline_source`, then the latest version of `google-adk` will be installed for interpreting the ADK config. */
  inlineSource?: ReasoningEngineSpecSourceCodeSpecInlineSource;
}

/** Specifies the configuration for fetching source code from a Git repository that is managed by Developer Connect.

This includes the repository, revision, and directory to use. */
export declare interface ReasoningEngineSpecSourceCodeSpecDeveloperConnectConfig {
  /** Required. The Developer Connect Git repository link, formatted as `projects/{project_id}/locations/{location_id}/connections/{connection_id}/gitRepositoryLink/{repository_link_id}`. */
  gitRepositoryLink?: string;
  /** Required. Directory, relative to the source root, in which to run the build. */
  dir?: string;
  /** Required. The revision to fetch from the Git repository such as a branch, a tag, a commit SHA, or any Git ref. */
  revision?: string;
}

/** Specifies source code to be fetched from a Git repository managed through the Developer Connect service. */
export declare interface ReasoningEngineSpecSourceCodeSpecDeveloperConnectSource {
  /** Required. The Developer Connect configuration that defines the specific repository, revision, and directory to use as the source code root. */
  config?: ReasoningEngineSpecSourceCodeSpecDeveloperConnectConfig;
}

/** The image spec for building an image (within a single build step), based on the config file (i.e. Dockerfile) in the source directory. */
export declare interface ReasoningEngineSpecSourceCodeSpecImageSpec {
  /** Optional. Build arguments to be used. They will be passed through --build-arg flags. */
  buildArgs?: Record<string, string>;
}

/** Specification for running a Python application from source. */
export declare interface ReasoningEngineSpecSourceCodeSpecPythonSpec {
  /** Optional. The Python module to load as the entrypoint, specified as a fully qualified module name. For example: path.to.agent. If not specified, defaults to "agent". The project root will be added to Python sys.path, allowing imports to be specified relative to the root. This field should not be set if the source is `agent_config_source`. */
  entrypointModule?: string;
  /** Optional. The name of the callable object within the `entrypoint_module` to use as the application If not specified, defaults to "root_agent". This field should not be set if the source is `agent_config_source`. */
  entrypointObject?: string;
  /** Optional. The path to the requirements file, relative to the source root. If not specified, defaults to "requirements.txt". */
  requirementsFile?: string;
  /** Optional. The version of Python to use. Supported versions include 3.10, 3.11, 3.12, 3.13, 3.14. If not specified, default value is 3.10. */
  version?: string;
}

/** Specification for deploying from source code. */
export declare interface ReasoningEngineSpecSourceCodeSpec {
  /** Source code is generated from the agent config. */
  agentConfigSource?: ReasoningEngineSpecSourceCodeSpecAgentConfigSource;
  /** Source code is in a Git repository managed by Developer Connect. */
  developerConnectSource?: ReasoningEngineSpecSourceCodeSpecDeveloperConnectSource;
  /** Optional. Configuration for building an image with custom config file. */
  imageSpec?: ReasoningEngineSpecSourceCodeSpecImageSpec;
  /** Source code is provided directly in the request. */
  inlineSource?: ReasoningEngineSpecSourceCodeSpecInlineSource;
  /** Configuration for a Python application. */
  pythonSpec?: ReasoningEngineSpecSourceCodeSpecPythonSpec;
}

/** Specification for deploying from a container image. */
export declare interface ReasoningEngineSpecContainerSpec {
  /** Required. The Artifact Registry Docker image URI (e.g., us-central1-docker.pkg.dev/my-project/my-repo/my-image:tag) of the container image that is to be run on each worker replica. */
  imageUri?: string;
  /** Optional. The port the container listens on. Defaults to 8080 if unset. */
  port?: number;
}

/** The specification of an agent engine. */
export declare interface ReasoningEngineSpec {
  /** Optional. The A2A Agent Card for the agent (if available). It follows the specification at https://a2a-protocol.org/latest/specification/#5-agent-discovery-the-agent-card. */
  agentCard?: Record<string, unknown>;
  /** Optional. The OSS agent framework used to develop the agent. Currently supported values: "google-adk", "langchain", "langgraph", "ag2", "llama-index", "custom". */
  agentFramework?: string;
  /** Optional. Declarations for object class methods in OpenAPI specification format. */
  classMethods?: Record<string, unknown>[];
  /** Optional. The specification of a Reasoning Engine deployment. */
  deploymentSpec?: ReasoningEngineSpecDeploymentSpec;
  /** Output only. The identity to use for the Reasoning Engine. It can contain one of the following values: * service-{project}@gcp-sa-aiplatform-re.googleapis.com (for SERVICE_AGENT identity type) * {name}@{project}.gserviceaccount.com (for SERVICE_ACCOUNT identity type) * agents.global.{org}.system.id.goog/resources/aiplatform/projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine} (for AGENT_IDENTITY identity type) */
  effectiveIdentity?: string;
  /** Optional. The identity type to use for the Reasoning Engine. If not specified, the `service_account` field will be used if set, otherwise the default Vertex AI Reasoning Engine Service Agent in the project will be used. */
  identityType?: IdentityType;
  /** Optional. User provided package spec of the ReasoningEngine. Ignored when users directly specify a deployment image through `deployment_spec.first_party_image_override`, but keeping the field_behavior to avoid introducing breaking changes. The `deployment_source` field should not be set if `package_spec` is specified. */
  packageSpec?: ReasoningEngineSpecPackageSpec;
  /** Optional. The service account that the Reasoning Engine artifact runs as. It should have "roles/storage.objectViewer" for reading the user project's Cloud Storage and "roles/aiplatform.user" for using Vertex extensions. If not specified, the Vertex AI Reasoning Engine Service Agent in the project will be used. */
  serviceAccount?: string;
  /** Deploy from source code files with a defined entrypoint. */
  sourceCodeSpec?: ReasoningEngineSpecSourceCodeSpec;
  /** Deploy from a container image with a defined entrypoint and commands. */
  containerSpec?: ReasoningEngineSpecContainerSpec;
}

/** The conversation source event for generating memories. */
export declare interface MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSourceEvent {
  /** Required. Represents the content of the event. */
  content?: genaiTypes.Content;
}

/** A conversation source for the example. This is similar to `DirectContentsSource`. */
export declare interface MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSource {
  /** Optional. Represents the input conversation events for the example. */
  events?: MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSourceEvent[];
}

/** The topic ID for a memory. */
export declare interface MemoryTopicId {
  /** Optional. Represents the custom memory topic label. */
  customMemoryTopicLabel?: string;
  /** Optional. Represents the managed memory topic. */
  managedMemoryTopic?: ManagedTopicEnum;
}

/** A memory generated by the operation. */
export declare interface MemoryBankCustomizationConfigGenerateMemoriesExampleGeneratedMemory {
  /** Required. Represents the fact to generate a memory from. */
  fact?: string;
  /** Optional. Represents the list of topics that the memory should be associated with. For example, use `custom_memory_topic_label = "jargon"` if the extracted memory is an example of memory extraction for the custom topic `jargon`. */
  topics?: MemoryTopicId[];
}

/** An example of how to generate memories for a particular scope. */
export declare interface MemoryBankCustomizationConfigGenerateMemoriesExample {
  /** A conversation source for the example. */
  conversationSource?: MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSource;
  /** Optional. Represents the memories that are expected to be generated from the input conversation. An empty list indicates that no memories are expected to be generated for the input conversation. */
  generatedMemories?: MemoryBankCustomizationConfigGenerateMemoriesExampleGeneratedMemory[];
}

/** A custom memory topic defined by the developer. */
export declare interface MemoryBankCustomizationConfigMemoryTopicCustomMemoryTopic {
  /** Required. Represents the label of the topic. */
  label?: string;
  /** Required. Represents the description of the memory topic. This should explain what information should be extracted for this topic. */
  description?: string;
}

/** A managed memory topic defined by the system. */
export declare interface MemoryBankCustomizationConfigMemoryTopicManagedMemoryTopic {
  /** Required. Represents the managed topic. */
  managedTopicEnum?: ManagedTopicEnum;
}

/** A topic of information that should be extracted from conversations and stored as memories. */
export declare interface MemoryBankCustomizationConfigMemoryTopic {
  /** A custom memory topic defined by the developer. */
  customMemoryTopic?: MemoryBankCustomizationConfigMemoryTopicCustomMemoryTopic;
  /** A managed memory topic defined by Memory Bank. */
  managedMemoryTopic?: MemoryBankCustomizationConfigMemoryTopicManagedMemoryTopic;
}

/** Represents configuration for customizing how memories are consolidated. */
export declare interface MemoryBankCustomizationConfigConsolidationConfig {
  /** Optional. Represents the maximum number of revisions to consider for each candidate memory. If not set, then the default value (1) will be used, which means that only the latest revision will be considered. */
  revisionsPerCandidateCount?: number;
}

/** Represents configuration for organizing natural language memories. */
export declare interface MemoryBankCustomizationConfig {
  /** Optional. Indicates whether the memories will be generated in the third person (i.e. "The user generates memories with Memory Bank."). By default, the memories will be generated in the first person (i.e. "I generate memories with Memory Bank.") */
  enableThirdPersonMemories?: boolean;
  /** Optional. Provides examples of how to generate memories for a particular scope. */
  generateMemoriesExamples?: MemoryBankCustomizationConfigGenerateMemoriesExample[];
  /** Optional. Represents topics of information that should be extracted from conversations and stored as memories. If not set, then Memory Bank's default topics will be used. */
  memoryTopics?: MemoryBankCustomizationConfigMemoryTopic[];
  /** Optional. Represents the scope keys (i.e. 'user_id') for which to use this config. A request's scope must include all of the provided keys for the config to be used (order does not matter). If empty, then the config will be used for all requests that do not have a more specific config. Only one default config is allowed per Memory Bank. */
  scopeKeys?: string[];
  /** Optional. Represents configuration for customizing how memories are consolidated together. */
  consolidationConfig?: MemoryBankCustomizationConfigConsolidationConfig;
  /** Optional. Indicates whether natural language memory generation should be disabled for all requests. By default, natural language memory generation is enabled. Set this to `true` when you only want to generate structured memories. */
  disableNaturalLanguageMemories?: boolean;
}

/** Represents the active rule that determines when to flush the buffer. */
export declare interface MemoryGenerationTriggerConfigGenerationTriggerRule {
  /** Optional. Specifies to trigger generation when the event count reaches this limit. */
  eventCount?: number;
  /** Optional. Specifies to trigger generation at a fixed interval. The duration must have a minute-level granularity. */
  fixedInterval?: string;
  /** Optional. Specifies to trigger generation if the stream is inactive for the specified duration after the most recent event. The duration must have a minute-level granularity. */
  idleDuration?: string;
  /** Optional. Re-include the last N already-processed events in the next window. */
  overlapEventCount?: number;
}

/** The configuration for triggering memory generation for ingested events. */
export declare interface MemoryGenerationTriggerConfig {
  /** Optional. Represents the active rule that determines when to flush the buffer. If not set, then the stream will be force flushed immediately. */
  generationRule?: MemoryGenerationTriggerConfigGenerationTriggerRule;
}

/** Configuration for how to generate memories. */
export declare interface ReasoningEngineContextSpecMemoryBankConfigGenerationConfig {
  /** Optional. The model used to generate memories. Format: `projects/{project}/locations/{location}/publishers/google/models/{model}`. */
  model?: string;
  /** Optional. Specifies the default trigger configuration for generating memories using `IngestEvents`. */
  generationTriggerConfig?: MemoryGenerationTriggerConfig;
}

/** Configuration for how to perform similarity search on memories. */
export declare interface ReasoningEngineContextSpecMemoryBankConfigSimilaritySearchConfig {
  /** Required. The model used to generate embeddings to lookup similar memories. Format: `projects/{project}/locations/{location}/publishers/google/models/{model}`. */
  embeddingModel?: string;
}

/** Configuration for TTL of the memories in the Memory Bank based on the action that created or updated the memory. */
export declare interface ReasoningEngineContextSpecMemoryBankConfigTtlConfigGranularTtlConfig {
  /** Optional. The TTL duration for memories uploaded via CreateMemory. */
  createTtl?: string;
  /** Optional. The TTL duration for memories newly generated via GenerateMemories (GenerateMemoriesResponse.GeneratedMemory.Action.CREATED). */
  generateCreatedTtl?: string;
  /** Optional. The TTL duration for memories updated via GenerateMemories (GenerateMemoriesResponse.GeneratedMemory.Action.UPDATED). In the case of an UPDATE action, the `expire_time` of the existing memory will be updated to the new value (now + TTL). */
  generateUpdatedTtl?: string;
}

/** Configuration for automatically setting the TTL ("time-to-live") of the memories in the Memory Bank. */
export declare interface ReasoningEngineContextSpecMemoryBankConfigTtlConfig {
  /** Optional. The default TTL duration of the memories in the Memory Bank. This applies to all operations that create or update a memory. */
  defaultTtl?: string;
  /** Optional. The granular TTL configuration of the memories in the Memory Bank. */
  granularTtlConfig?: ReasoningEngineContextSpecMemoryBankConfigTtlConfigGranularTtlConfig;
  /** Optional. The default TTL duration of the memory revisions in the Memory Bank. This applies to all operations that create a memory revision. If not set, a default TTL of 365 days will be used. */
  memoryRevisionDefaultTtl?: string;
}

/** Represents the OpenAPI schema of the structured memories. */
export declare interface StructuredMemorySchemaConfig {
  /** Required. Represents the OpenAPI schema of the structured memories. */
  memorySchema?: genaiTypes.Schema;
  /** Required. Represents the ID of the schema. Must be 1-63 characters, start with a lowercase letter, and consist of lowercase letters, numbers, and hyphens. */
  id?: string;
  /** Optional. Represents the type of the structured memories associated with the schema. If not set, then `STRUCTURED_PROFILE` will be used. */
  memoryType?: MemoryType;
}

/** Configuration for organizing structured memories within a scope. */
export declare interface StructuredMemoryConfig {
  /** Optional. Represents configuration of the structured memories' schemas. */
  schemaConfigs?: StructuredMemorySchemaConfig[];
  /** Optional. Represents the scope keys (i.e. 'user_id') for which to use this config. A request's scope must include all of the provided keys for the config to be used (order does not matter). If empty, then the config will be used for all requests that do not have a more specific config. Only one default config is allowed per Memory Bank. */
  scopeKeys?: string[];
}

/** Specification for a Memory Bank. */
export declare interface ReasoningEngineContextSpecMemoryBankConfig {
  /** Optional. Configuration for how to customize Memory Bank behavior for a particular scope. */
  customizationConfigs?: MemoryBankCustomizationConfig[];
  /** If true, no memory revisions will be created for any requests to the Memory Bank. */
  disableMemoryRevisions?: boolean;
  /** Optional. Configuration for how to generate memories for the Memory Bank. */
  generationConfig?: ReasoningEngineContextSpecMemoryBankConfigGenerationConfig;
  /** Optional. Configuration for how to perform similarity search on memories. If not set, the Memory Bank will use the default embedding model `text-embedding-005`. */
  similaritySearchConfig?: ReasoningEngineContextSpecMemoryBankConfigSimilaritySearchConfig;
  /** Optional. Configuration for automatic TTL ("time-to-live") of the memories in the Memory Bank. If not set, TTL will not be applied automatically. The TTL can be explicitly set by modifying the `expire_time` of each Memory resource. */
  ttlConfig?: ReasoningEngineContextSpecMemoryBankConfigTtlConfig;
  /** Optional. Configuration for organizing structured memories for a particular scope. */
  structuredMemoryConfigs?: StructuredMemoryConfig[];
}

/** Configuration for how Agent Engine sub-resources should manage context. */
export declare interface ReasoningEngineContextSpec {
  /** Optional. Specification for a Memory Bank, which manages memories for the Agent Engine. */
  memoryBankConfig?: ReasoningEngineContextSpecMemoryBankConfig;
}

/** Config for create agent engine. */
export declare interface CreateAgentEngineConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The user-defined name of the Agent Engine.

      The display name can be up to 128 characters long and can comprise any
      UTF-8 characters.
       */
  displayName?: string;
  /** The description of the Agent Engine. */
  description?: string;
  /** Optional. Configurations of the Agent Engine. */
  spec?: ReasoningEngineSpec;
  /** Optional. The context spec to be used for the Agent Engine. */
  contextSpec?: ReasoningEngineContextSpec;
  /** Optional. The PSC interface config for PSC-I to be used for the
      Agent Engine. */
  pscInterfaceConfig?: PscInterfaceConfig;
  /** The minimum number of instances to run for the Agent Engine.
      Defaults to 1. Range: [0, 10].
       */
  minInstances?: number;
  /** The maximum number of instances to run for the Agent Engine.
      Defaults to 100. Range: [1, 1000].
      If VPC-SC or PSC-I is enabled, the acceptable range is [1, 100].
       */
  maxInstances?: number;
  /** The resource limits to be applied to the Agent Engine.
      Required keys: 'cpu' and 'memory'.
      Supported values for 'cpu': '1', '2', '4', '6', '8'.
      Supported values for 'memory': '1Gi', '2Gi', ..., '32Gi'.
       */
  resourceLimits?: Record<string, string>;
  /** The container concurrency to be used for the Agent Engine.
      Recommended value: 2 * cpu + 1. Defaults to 9.
       */
  containerConcurrency?: number;
  /** The encryption spec to be used for the Agent Engine. */
  encryptionSpec?: genaiTypes.EncryptionSpec;
  /** The labels to be used for the Agent Engine. */
  labels?: Record<string, string>;
  /** The class methods to be used for the Agent Engine.
      If specified, they'll override the class methods that are autogenerated by
      default. By default, methods are generated by inspecting the agent object
      and generating a corresponding method for each method defined on the
      agent class.
       */
  classMethods?: Record<string, unknown>[];
  /** The user-provided paths to the source packages (if any).
      If specified, the files in the source packages will be packed into a
      a tarball file, uploaded to Agent Engine's API, and deployed to the
      Agent Engine.
      The following fields will be ignored:
        - agent
        - extra_packages
        - staging_bucket
        - requirements
      The following fields will be used to install and use the agent from the
      source packages:
        - entrypoint_module (required)
        - entrypoint_object (required)
        - requirements_file (optional)
        - class_methods     (required)
       */
  sourcePackages?: string[];
  /** Specifies the configuration for fetching source code from a Git repository that is managed by Developer Connect. This includes the repository, revision, and directory to use. */
  developerConnectSource?: ReasoningEngineSpecSourceCodeSpecDeveloperConnectConfig;
  /** The entrypoint module to be used for the Agent Engine
      This field only used when source_packages is specified. */
  entrypointModule?: string;
  /** The entrypoint object to be used for the Agent Engine.
      This field only used when source_packages is specified. */
  entrypointObject?: string;
  /** The user-provided path to the requirements file (if any).
      This field is only used when source_packages is specified.
      If not specified, agent engine will find and use the `requirements.txt` in
      the source package.
       */
  requirementsFile?: string;
  /** The agent framework to be used for the Agent Engine.
      The OSS agent framework used to develop the agent.
      Currently supported values: "google-adk", "langchain", "langgraph",
      "ag2", "llama-index", "custom".
      If not specified:
      - If `agent` is specified, the agent framework will be auto-detected.
      - If `source_packages` is specified, the agent framework will
        default to "custom". */
  agentFramework?:
    | 'google-adk'
    | 'langchain'
    | 'langgraph'
    | 'ag2'
    | 'llama-index'
    | 'custom';
  /** The Python version to be used for the Agent Engine.
      If not specified, it will use the current Python version of the environment.
      Supported versions: "3.10", "3.11", "3.12", "3.13", "3.14".
       */
  pythonVersion?: '3.10' | '3.11' | '3.12' | '3.13' | '3.14';
  /** The build options for the Agent Engine.
      The following keys are supported:
      - installation_scripts:
          Optional. The paths to the installation scripts to be
          executed in the Docker image.
          The scripts must be located in the `installation_scripts`
          subdirectory and the path must be added to `extra_packages`.
       */
  buildOptions?: Record<string, string[]>;
  /** Agent Gateway configuration for a Reasoning Engine deployment. */
  agentGatewayConfig?: ReasoningEngineSpecDeploymentSpecAgentGatewayConfig;
  /** Optional. Specifies the configuration for keep-alive probe.
      Contains configuration on a specified endpoint that a deployment host
      should use to keep the container alive based on the probe settings. */
  keepAliveProbe?: KeepAliveProbe;
}

/** Parameters for creating agent engines. */
export declare interface CreateAgentEngineRequestParameters {
  config?: CreateAgentEngineConfig;
}

/** Traffic distribution configuration, where all traffic is sent to the latest Runtime Revision. */
export declare interface ReasoningEngineTrafficConfigTrafficSplitAlwaysLatest {}

/** A single target for the traffic split, specifying a Runtime Revision and the percentage of traffic to send to it. */
export declare interface ReasoningEngineTrafficConfigTrafficSplitManualTarget {
  /** Required. Specifies percent of the traffic to this Runtime Revision. */
  percent?: number;
  /** Required. The Runtime Revision name to which to send this portion of traffic, if traffic allocation is by Runtime Revision. */
  runtimeRevisionName?: string;
}

/** Manual traffic distribution configuration, where the user specifies the Runtime Revision IDs and the percentage of traffic to send to each. */
export declare interface ReasoningEngineTrafficConfigTrafficSplitManual {
  /** A list of traffic targets for the Runtimes Revisions. The sum of percentages must equal to 100. */
  targets?: ReasoningEngineTrafficConfigTrafficSplitManualTarget[];
}

/** Traffic distribution configuration. */
export declare interface ReasoningEngineTrafficConfig {
  /** Optional. Traffic distribution configuration, where all traffic is sent to the latest Runtime Revision. */
  trafficSplitAlwaysLatest?: ReasoningEngineTrafficConfigTrafficSplitAlwaysLatest;
  /** Optional. Manual traffic distribution configuration, where the user specifies the Runtime Revision IDs and the percentage of traffic to send to each. */
  trafficSplitManual?: ReasoningEngineTrafficConfigTrafficSplitManual;
}

/** An agent engine. */
export declare interface ReasoningEngine {
  /** Customer-managed encryption key spec for a ReasoningEngine. If set, this ReasoningEngine and all sub-resources of this ReasoningEngine will be secured by this key. */
  encryptionSpec?: genaiTypes.EncryptionSpec;
  /** Optional. Configuration for how Agent Engine sub-resources should manage context. */
  contextSpec?: ReasoningEngineContextSpec;
  /** Output only. Timestamp when this ReasoningEngine was created. */
  createTime?: string;
  /** Optional. The description of the ReasoningEngine. */
  description?: string;
  /** Required. The display name of the ReasoningEngine. */
  displayName?: string;
  /** Optional. Used to perform consistent read-modify-write updates. If not set, a blind "overwrite" update happens. */
  etag?: string;
  /** Labels for the ReasoningEngine. */
  labels?: Record<string, string>;
  /** Identifier. The resource name of the ReasoningEngine. Format: `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}` */
  name?: string;
  /** Optional. Configurations of the ReasoningEngine */
  spec?: ReasoningEngineSpec;
  /** Output only. Timestamp when this ReasoningEngine was most recently updated. */
  updateTime?: string;
  /** Optional. Traffic distribution configuration for the Reasoning Engine. */
  trafficConfig?: ReasoningEngineTrafficConfig;
}

/** Operation that has an agent engine as a response. */
export declare interface AgentEngineOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
  /** The created Agent Engine. */
  response?: ReasoningEngine;
}

/** Config for deleting agent engine. */
export declare interface DeleteAgentEngineConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for deleting agent engines. */
export declare interface DeleteAgentEngineRequestParameters {
  /** Name of the agent engine. */
  name: string;
  /** If set to true, any child resources will also be deleted. */
  force?: boolean;
  config?: DeleteAgentEngineConfig;
}

/** Operation for deleting agent engines. */
export declare interface DeleteAgentEngineOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

/** Config for create agent engine. */
export declare interface GetAgentEngineConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for getting agent engines. */
export declare interface GetAgentEngineRequestParameters {
  /** Name of the agent engine. */
  name: string;
  config?: GetAgentEngineConfig;
}

/** Config for listing agent engines. */
export declare interface ListAgentEngineConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  pageSize?: number;
  pageToken?: string;
  /** An expression for filtering the results of the request.
      For field names both snake_case and camelCase are supported. */
  filter?: string;
}

/** Parameters for listing agent engines. */
export declare interface ListAgentEngineRequestParameters {
  config?: ListAgentEngineConfig;
}

/** Response for listing agent engines. */
export class ListReasoningEnginesResponse {
  /** Used to retain the full HTTP response. */
  sdkHttpResponse?: genaiTypes.HttpResponse;
  nextPageToken?: string;
  /** List of agent engines.
   */
  reasoningEngines?: ReasoningEngine[];
}

export declare interface GetAgentEngineOperationConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for getting an operation with an agent engine as a response. */
export declare interface GetAgentEngineOperationParameters {
  /** The server-assigned name for the operation. */
  operationName: string;
  /** Used to override the default configuration. */
  config?: GetAgentEngineOperationConfig;
}

/** Config for querying agent engines. */
export declare interface QueryAgentEngineConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The class method to call. */
  classMethod?: string;
  /** The input to the class method. */
  input?: Record<string, unknown>;
  includeAllFields?: boolean;
}

/** Parameters for querying agent engines. */
export declare interface QueryAgentEngineRequestParameters {
  /** Name of the agent engine. */
  name: string;
  config?: QueryAgentEngineConfig;
}

/** The response for querying an agent engine. */
export class QueryReasoningEngineResponse {
  /** Response provided by users in JSON object format. */
  output?: unknown;
}

/** Config for updating agent engine. */
export declare interface UpdateAgentEngineConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The user-defined name of the Agent Engine.

      The display name can be up to 128 characters long and can comprise any
      UTF-8 characters.
       */
  displayName?: string;
  /** The description of the Agent Engine. */
  description?: string;
  /** Optional. Configurations of the Agent Engine. */
  spec?: ReasoningEngineSpec;
  /** Optional. The context spec to be used for the Agent Engine. */
  contextSpec?: ReasoningEngineContextSpec;
  /** Optional. The PSC interface config for PSC-I to be used for the
      Agent Engine. */
  pscInterfaceConfig?: PscInterfaceConfig;
  /** The minimum number of instances to run for the Agent Engine.
      Defaults to 1. Range: [0, 10].
       */
  minInstances?: number;
  /** The maximum number of instances to run for the Agent Engine.
      Defaults to 100. Range: [1, 1000].
      If VPC-SC or PSC-I is enabled, the acceptable range is [1, 100].
       */
  maxInstances?: number;
  /** The resource limits to be applied to the Agent Engine.
      Required keys: 'cpu' and 'memory'.
      Supported values for 'cpu': '1', '2', '4', '6', '8'.
      Supported values for 'memory': '1Gi', '2Gi', ..., '32Gi'.
       */
  resourceLimits?: Record<string, string>;
  /** The container concurrency to be used for the Agent Engine.
      Recommended value: 2 * cpu + 1. Defaults to 9.
       */
  containerConcurrency?: number;
  /** The encryption spec to be used for the Agent Engine. */
  encryptionSpec?: genaiTypes.EncryptionSpec;
  /** The labels to be used for the Agent Engine. */
  labels?: Record<string, string>;
  /** The class methods to be used for the Agent Engine.
      If specified, they'll override the class methods that are autogenerated by
      default. By default, methods are generated by inspecting the agent object
      and generating a corresponding method for each method defined on the
      agent class.
       */
  classMethods?: Record<string, unknown>[];
  /** The user-provided paths to the source packages (if any).
      If specified, the files in the source packages will be packed into a
      a tarball file, uploaded to Agent Engine's API, and deployed to the
      Agent Engine.
      The following fields will be ignored:
        - agent
        - extra_packages
        - staging_bucket
        - requirements
      The following fields will be used to install and use the agent from the
      source packages:
        - entrypoint_module (required)
        - entrypoint_object (required)
        - requirements_file (optional)
        - class_methods     (required)
       */
  sourcePackages?: string[];
  /** Specifies the configuration for fetching source code from a Git repository that is managed by Developer Connect. This includes the repository, revision, and directory to use. */
  developerConnectSource?: ReasoningEngineSpecSourceCodeSpecDeveloperConnectConfig;
  /** The entrypoint module to be used for the Agent Engine
      This field only used when source_packages is specified. */
  entrypointModule?: string;
  /** The entrypoint object to be used for the Agent Engine.
      This field only used when source_packages is specified. */
  entrypointObject?: string;
  /** The user-provided path to the requirements file (if any).
      This field is only used when source_packages is specified.
      If not specified, agent engine will find and use the `requirements.txt` in
      the source package.
       */
  requirementsFile?: string;
  /** The agent framework to be used for the Agent Engine.
      The OSS agent framework used to develop the agent.
      Currently supported values: "google-adk", "langchain", "langgraph",
      "ag2", "llama-index", "custom".
      If not specified:
      - If `agent` is specified, the agent framework will be auto-detected.
      - If `source_packages` is specified, the agent framework will
        default to "custom". */
  agentFramework?:
    | 'google-adk'
    | 'langchain'
    | 'langgraph'
    | 'ag2'
    | 'llama-index'
    | 'custom';
  /** The Python version to be used for the Agent Engine.
      If not specified, it will use the current Python version of the environment.
      Supported versions: "3.10", "3.11", "3.12", "3.13", "3.14".
       */
  pythonVersion?: '3.10' | '3.11' | '3.12' | '3.13' | '3.14';
  /** The build options for the Agent Engine.
      The following keys are supported:
      - installation_scripts:
          Optional. The paths to the installation scripts to be
          executed in the Docker image.
          The scripts must be located in the `installation_scripts`
          subdirectory and the path must be added to `extra_packages`.
       */
  buildOptions?: Record<string, string[]>;
  /** Agent Gateway configuration for a Reasoning Engine deployment. */
  agentGatewayConfig?: ReasoningEngineSpecDeploymentSpecAgentGatewayConfig;
  /** Optional. Specifies the configuration for keep-alive probe.
      Contains configuration on a specified endpoint that a deployment host
      should use to keep the container alive based on the probe settings. */
  keepAliveProbe?: KeepAliveProbe;
  /** The update mask to apply. For the `FieldMask` definition, see
      https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask. */
  updateMask?: string;
}

/** Parameters for updating agent engines. */
export declare interface UpdateAgentEngineRequestParameters {
  /** Name of the agent engine. */
  name: string;
  config?: UpdateAgentEngineConfig;
}

/** Config for create memory bank. */
export declare interface CreateMemoryBankConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The user-defined name of the Memory Bank.

      The display name can be up to 128 characters long and can comprise any
      UTF-8 characters.
       */
  displayName?: string;
  /** The description of the Memory Bank. */
  description?: string;
  /** The encryption spec to be used for the Memory Bank. */
  encryptionSpec?: genaiTypes.EncryptionSpec;
}

/** Parameters for creating memory banks. */
export declare interface CreateMemoryBankRequestParameters {
  memoryBankConfig?: ReasoningEngineContextSpecMemoryBankConfig;
  config?: CreateMemoryBankConfig;
}

/** The configuration for generating memories. */
export declare interface ManagedSemanticMemoryConfigGenerationConfig {
  /** The model used to generate memories.

      Format:
      `projects/{project}/locations/{location}/publishers/google/models/{model}`. */
  model?: string;
  /** The configuration for triggering memory generation. */
  generationTriggerConfig?: MemoryGenerationTriggerConfig;
}

/** The configuration for similarity search. */
export declare interface ManagedSemanticMemoryConfigSimilaritySearchConfig {
  /** The model used to generate embeddings to look up similar memories.
      Format:
      `projects/{project}/locations/{location}/publishers/google/models/{model}`. */
  embeddingModel?: string;
}

/** The configuration for granular TTL. */
export declare interface ManagedSemanticMemoryConfigTtlConfigGranularTtlConfig {
  /** Optional. The TTL duration for memories uploaded via
      CreateMemory. */
  createTtl?: string;
  /** Optional. The TTL duration for memories generated via
      GenerateMemories. */
  generateCreatedTtl?: string;
  /** Optional. The TTL duration for memories updated via
      GenerateMemories (GenerateMemoriesResponse.GeneratedMemory.Action.UPDATED).
      In the case of an UPDATE action, the `expire_time` of the existing memory
      will be updated to the new value (now + TTL). */
  generateUpdatedTtl?: string;
}

/** The configuration for automatic TTL ('time-to-live') of the memories. */
export declare interface ManagedSemanticMemoryConfigTtlConfig {
  /** The default TTL for memories in the Memory Bank. If not set, TTL will not be applied automatically. The TTL can be explicitly set by modifying the `expire_time` of each Memory resource. */
  defaultTtl?: string;
  /** The granular TTL config for memories. */
  granularTtlConfig?: ManagedSemanticMemoryConfigTtlConfigGranularTtlConfig;
  /** The default TTL for memory revisions in the Memory Bank. If not set, TTL will not be applied automatically. The TTL can be explicitly set by modifying the `expire_time` of each Memory resource. */
  memoryRevisionDefaultTtl?: string;
}

/** The configuration for managed semantic memory. */
export declare interface ManagedSemanticMemoryConfig {
  /** Represents configuration for LLMs calls. */
  generationConfig?: ManagedSemanticMemoryConfigGenerationConfig;
  /** Configuration for how to perform similarity search on memories. */
  similaritySearchConfig?: ManagedSemanticMemoryConfigSimilaritySearchConfig;
  /** Configuration for how to customize Memory Bank behavior for a
      particular scope for unstructured memories. */
  unstructuredMemoryConfigs?: MemoryBankCustomizationConfig[];
  /** Configuration for organizing structured memories for a particular
      scope. */
  structuredMemoryConfigs?: StructuredMemoryConfig[];
  /** Configuration for automatic TTL ('time-to-live') of the memories in
      the Memory Bank. If not set, TTL will not be applied automatically. The
      TTL can be explicitly set by modifying the `expire_time` of each Memory
      resource. */
  ttlConfig?: ManagedSemanticMemoryConfigTtlConfig;
  /** If true, no memory revisions will be created for any requests to
      Memory Bank. */
  disableMemoryRevisions?: boolean;
}

/** Represents a customer-managed encryption key specification that can be applied to a Vertex AI resource. */
export declare interface EncryptionSpec {
  /** Required. Resource name of the Cloud KMS key used to protect the resource. The Cloud KMS key must be in the same region as the resource. It must have the format `projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{crypto_key}`. */
  kmsKeyName?: string;
}

/** A memory bank. */
export declare interface MemoryBank {
  /** Required. Represents the ID of the schema. Must be 1-63 characters, start with a lowercase letter, and consist of lowercase letters, numbers, and hyphens. */
  name?: string;
  /** Represents the configuration for managed memories in Memory Bank. If not set, then the default configuration will be used. */
  managedSemanticMemoryConfig?: ManagedSemanticMemoryConfig;
  /** Represents the display name of the Memory Bank. */
  displayName?: string;
  /** Represents the description of the Memory Bank. */
  description?: string;
  /** Timestamp when this Memory Bank was created. */
  createTime?: string;
  /** Timestamp when this Memory Bank was most recently updated. */
  updateTime?: string;
  /** Customer-managed encryption key spec for a Memory Bank. If set, this Memory Bank and all sub-resources of this Memory Bank will be secured by this key. */
  encryptionSpec?: EncryptionSpec;
}

/** Operation that has an memory bank as a response. */
export declare interface MemoryBankOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
  /** The created Memory Bank. */
  response?: MemoryBank;
}

/** Config for delete memory bank. */
export declare interface DeleteMemoryBankConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for deleting a memory bank. */
export declare interface DeleteMemoryBankRequestParameters {
  /** Name of the memory bank. */
  name: string;
  /** If set to true, any child resources will also be deleted. */
  force?: boolean;
  config?: DeleteMemoryBankConfig;
}

/** Operation for deleting a memory bank. */
export declare interface DeleteMemoryBankOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

/** Config for getting a Memory Bank. */
export declare interface GetMemoryBankConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for getting a Memory Bank. */
export declare interface GetMemoryBankRequestParameters {
  /** Name of the Memory Bank. */
  name: string;
  config?: GetMemoryBankConfig;
}

/** The direct contents source event for ingesting events. */
export declare interface IngestionDirectContentsSourceEvent {
  /** Required. The content of the event. */
  content?: genaiTypes.Content;
  /** Optional. A unique identifier for the event. If an event with the same event_id is ingested multiple times, it will be de-duplicated. */
  eventId?: string;
  /** Optional. The time at which the event occurred. If provided, this timestamp will be used for ordering events within a stream. If not provided, the server-side ingestion time will be used. */
  eventTime?: string;
}

/** The direct contents source for ingesting events. */
export declare interface IngestionDirectContentsSource {
  /** Required. The events to ingest. */
  events?: IngestionDirectContentsSourceEvent[];
}

/** The metadata values for memories. */
export declare interface MemoryMetadataValue {
  /** Represents a boolean value. */
  boolValue?: boolean;
  /** Represents a double value. */
  doubleValue?: number;
  /** Represents a string value. */
  stringValue?: string;
  /** Represents a timestamp value. When filtering on timestamp values, only the seconds field will be compared. */
  timestampValue?: string;
}

/** Config for ingesting events. */
export declare interface IngestEventsConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Waits for the underlying memory generation operation to complete
      before returning. Defaults to false. */
  waitForCompletion?: boolean;
  /** Optional. Forces a flush of all pending events in the stream and triggers memory generation immediately bypassing any conditions configured in the `generation_trigger_config`. */
  forceFlush?: boolean;
  /** Labels to apply to the memory revision. For example, you can use this to label a revision with its data source. */
  revisionLabels?: Record<string, string>;
  /** Optional. Input only. Timestamp of when the revision is considered expired. If not set, the memory revision will be kept until manually deleted. */
  revisionExpireTime?: string;
  /** Optional. Input only. The TTL for the revision. The expiration time is computed: now + TTL. */
  revisionTtl?: string;
  /** Optional. Input only. If true, no revisions will be created for this request. */
  disableMemoryRevisions?: boolean;
  /** Optional. User-provided metadata for the generated memories. This is not generated by Memory Bank. */
  metadata?: Record<string, MemoryMetadataValue>;
  /** Optional. The strategy to use when applying metadata to existing memories. */
  metadataMergeStrategy?: MemoryMetadataMergeStrategy;
}

/** Parameters for ingesting events to Memory Bank. */
export declare interface IngestEventsRequestParameters {
  /** Name of the Memory Bank to ingest events into. */
  name: string;
  /** The ID of the stream to ingest events into. */
  streamId?: string;
  /** The direct memories source of the events that should be ingested. */
  directContentsSource?: IngestionDirectContentsSource;
  /** The scope of the memories that should be generated from the stream.

      Memories will be consolidated across memories with the same scope. Scope
      values cannot contain the wildcard character '*'. */
  scope?: Record<string, string>;
  /** The configuration for the memory generation trigger. */
  generationTriggerConfig?: MemoryGenerationTriggerConfig;
  config?: IngestEventsConfig;
}

/** Operation that ingests events into a memory bank. */
export declare interface MemoryBankIngestEventsOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

/** Config for listing Memory Banks. */
export declare interface ListMemoryBanksConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  pageSize?: number;
  pageToken?: string;
}

/** Parameters for listing Memory Banks. */
export declare interface ListMemoryBanksRequestParameters {
  config?: ListMemoryBanksConfig;
}

export declare interface GetMemoryBankOperationConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for getting an operation with a memory bank as a response. */
export declare interface GetMemoryBankOperationParameters {
  /** The server-assigned name for the operation. */
  operationName: string;
  /** Used to override the default configuration. */
  config?: GetMemoryBankOperationConfig;
}

/** Config for creating a Memory. */
export declare interface MemoryConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The display name of the memory. */
  displayName?: string;
  /** The description of the memory. */
  description?: string;
  /** Waits for the operation to complete before returning. */
  waitForCompletion?: boolean;
  /** Optional. Input only. The TTL for this resource.

      The expiration time is computed: now + TTL. */
  ttl?: string;
  /** Optional. Timestamp of when this resource is considered expired. This is *always* provided on output, regardless of what `expiration` was sent on input. */
  expireTime?: string;
  /** Optional. Input only. Timestamp of when the revision is considered expired. If not set, the memory revision will be kept until manually deleted. */
  revisionExpireTime?: string;
  /** Optional. Input only. The TTL for the revision. The expiration time is computed: now + TTL. */
  revisionTtl?: string;
  /** Optional. Input only. If true, no revision will be created for this request. */
  disableMemoryRevisions?: boolean;
  /** Optional. The topics of the memory. */
  topics?: MemoryTopicId[];
  /** Optional. User-provided metadata for the Memory. This information was provided when creating, updating, or generating the Memory. It was not generated by Memory Bank. */
  metadata?: Record<string, MemoryMetadataValue>;
  /** Optional. The user defined ID to use for memory, which will become the final component of the memory resource name. If not provided, Vertex AI will generate a value for this ID. This value may be up to 63 characters, and valid characters are `[a-z0-9-]`. The first character must be a letter, and the last character must be a letter or number. */
  memoryId?: string;
}

/** Parameters for creating Memories. */
export declare interface CreateMemoryRequestParameters {
  /** Name of the memory bank to create the memory under. */
  name: string;
  /** The fact of the memory.

      This is the semantic knowledge extracted from the source content). */
  fact: string;
  /** The scope of the memory.

      Memories are isolated within their scope. The scope is defined when
      creating or generating memories. Up to 5 key-value pairs are accepted,
      and scope values cannot contain the wildcard character '*'. */
  scope: Record<string, string>;
  config?: MemoryConfig;
}

/** Represents the structured value of the memory. */
export declare interface MemoryStructuredContent {
  /** Required. Represents the structured value of the memory. */
  data?: Record<string, unknown>;
  /** Required. Represents the schema ID for which this structured memory belongs to. */
  schemaId?: string;
}

/** A memory. */
export declare interface Memory {
  /** Output only. Represents the timestamp when this Memory was created. */
  createTime?: string;
  /** Optional. Represents the description of the Memory. */
  description?: string;
  /** Optional. Input only. Indicates whether no revision will be created for this request. */
  disableMemoryRevisions?: boolean;
  /** Optional. Represents the display name of the Memory. */
  displayName?: string;
  /** Optional. Represents the timestamp of when this resource is considered expired. This is *always* provided on output when `expiration` is set on input, regardless of whether `expire_time` or `ttl` was provided. */
  expireTime?: string;
  /** Optional. Represents semantic knowledge extracted from the source content. */
  fact?: string;
  /** Optional. Represents user-provided metadata for the Memory. This information was provided when creating, updating, or generating the Memory. It was not generated by Memory Bank. */
  metadata?: Record<string, MemoryMetadataValue>;
  /** Identifier. Represents the resource name of the Memory. Format: `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/memories/{memory}` */
  name?: string;
  /** Optional. Input only. Represents the timestamp of when the revision is considered expired. If not set, the memory revision will be kept until manually deleted. */
  revisionExpireTime?: string;
  /** Optional. Input only. Represents the labels to apply to the Memory Revision created as a result of this request. */
  revisionLabels?: Record<string, string>;
  /** Optional. Input only. Represents the TTL for the revision. The expiration time is computed: now + TTL. */
  revisionTtl?: string;
  /** Required. Immutable. Represents the scope of the Memory. Memories are isolated within their scope. The scope is defined when creating or generating memories. Scope values cannot contain the wildcard character '*'. */
  scope?: Record<string, string>;
  /** Optional. Represents the Topics of the Memory. */
  topics?: MemoryTopicId[];
  /** Optional. Input only. Represents the TTL for this resource. The expiration time is computed: now + TTL. */
  ttl?: string;
  /** Output only. Represents the timestamp when this Memory was most recently updated. */
  updateTime?: string;
  /** Optional. Represents the type of the memory. If not set, the `NATURAL_LANGUAGE_COLLECTION` type is used. If `STRUCTURED_COLLECTION` or `STRUCTURED_PROFILE` is used, then `structured_data` must be provided. */
  memoryType?: MemoryType;
  /** Optional. Represents the structured content of the memory. */
  structuredContent?: MemoryStructuredContent;
}

/** Operation that has a memory as a response. */
export declare interface MemoryOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
  /** The Memory. */
  response?: Memory;
}

/** Config for deleting a Memory. */
export declare interface DeleteMemoryConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for deleting memories. */
export declare interface DeleteMemoryRequestParameters {
  /** Name of the memory to delete. */
  name: string;
  config?: DeleteMemoryConfig;
}

/** Operation for deleting memories. */
export declare interface DeleteMemoryOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

/** The vertex session source for generating memories. */
export declare interface GenerateMemoriesRequestVertexSessionSource {
  /** Optional. End time (exclusive) of the time range. If not set, the end time is unbounded. */
  endTime?: string;
  /** Required. The resource name of the Session to generate memories for. Format: `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/sessions/{session}` */
  session?: string;
  /** Optional. Time range to define which session events should be used to generate memories. Start time (inclusive) of the time range. If not set, the start time is unbounded. */
  startTime?: string;
}

export declare interface GenerateMemoriesRequestDirectContentsSourceEvent {
  /** Required. A single piece of content from which to generate memories. */
  content?: genaiTypes.Content;
}

/** The direct contents source for generating memories. */
export declare interface GenerateMemoriesRequestDirectContentsSource {
  /** Required. The source content (i.e. chat history) to generate memories from. */
  events?: GenerateMemoriesRequestDirectContentsSourceEvent[];
}

/** A direct memory to upload to Memory Bank. */
export declare interface GenerateMemoriesRequestDirectMemoriesSourceDirectMemory {
  /** Required. The fact to consolidate with existing memories. */
  fact?: string;
  /** Optional. The topics that the consolidated memories should be associated with. */
  topics?: MemoryTopicId[];
}

/** The direct memories source for generating memories. */
export declare interface GenerateMemoriesRequestDirectMemoriesSource {
  /** Required. The direct memories to upload to Memory Bank. At most 5 direct memories are allowed per request. */
  directMemories?: GenerateMemoriesRequestDirectMemoriesSourceDirectMemory[];
}

/** Config for generating memories. */
export declare interface GenerateMemoriesConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Whether to disable consolidation of memories.

      If true, generated memories will not be consolidated with existing
      memories; all generated memories will be added as new memories regardless
      of whether they are duplicates of or contradictory to existing memories.
      By default, memory consolidation is enabled. */
  disableConsolidation?: boolean;
  /** Waits for the operation to complete before returning. */
  waitForCompletion?: boolean;
  /** Labels to apply to the memory revision. For example, you can use this to label a revision with its data source. */
  revisionLabels?: Record<string, string>;
  /** Optional. Input only. Timestamp of when the revision is considered expired. If not set, the memory revision will be kept until manually deleted. */
  revisionExpireTime?: string;
  /** Optional. Input only. The TTL for the revision. The expiration time is computed: now + TTL. */
  revisionTtl?: string;
  /** Optional. Input only. If true, no revisions will be created for this request. */
  disableMemoryRevisions?: boolean;
  /** Optional. User-provided metadata for the generated memories. This is not generated by Memory Bank. */
  metadata?: Record<string, MemoryMetadataValue>;
  /** Optional. The strategy to use when applying metadata to existing memories. */
  metadataMergeStrategy?: MemoryMetadataMergeStrategy;
  /** Optional. Restricts memory generation to a subset of memory topics. */
  allowedTopics?: MemoryTopicId[];
}

/** Parameters for generating memories. */
export declare interface GenerateMemoriesRequestParameters {
  /** Name of the Memory Bank to generate memories with. */
  name: string;
  /** The vertex session source of the memories that should be generated. */
  vertexSessionSource?: GenerateMemoriesRequestVertexSessionSource;
  /** The direct contents source of the memories that should be generated. */
  directContentsSource?: GenerateMemoriesRequestDirectContentsSource;
  /** The direct memories source of the memories that should be generated. */
  directMemoriesSource?: GenerateMemoriesRequestDirectMemoriesSource;
  /** The scope of the memories that should be generated.

      Memories will be consolidated across memories with the same scope. Must be
      provided unless the scope is defined in the source content. If `scope` is
      provided, it will override the scope defined in the source content. Scope
      values cannot contain the wildcard character '*'. */
  scope?: Record<string, string>;
  config?: GenerateMemoriesConfig;
}

/** A memory that was generated. */
export class GenerateMemoriesResponseGeneratedMemory {
  /** The generated memory. */
  memory?: Memory;
  /** The action to take. */
  action?: GenerateMemoriesResponseGeneratedMemoryAction;
  /** The previous revision of the Memory before the action was performed. This
      field is only set if the action is `UPDATED` or `DELETED`. You can use
      this to rollback the Memory to the previous revision, undoing the action.
      Format:
      `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/memories/{memory}/revisions/{revision}` */
  previousRevision?: string;
}

/** The response for generating memories. */
export class GenerateMemoriesResponse {
  /** The generated memories. */
  generatedMemories?: GenerateMemoriesResponseGeneratedMemory[];
}

/** Operation that generates memories with a Memory Bank. */
export declare interface GenerateMemoriesOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
  /** The response for generating memories. */
  response?: GenerateMemoriesResponse;
}

/** Config for getting a Memory. */
export declare interface GetMemoryConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for getting a Memory. */
export declare interface GetMemoryRequestParameters {
  /** Name of the memory. */
  name: string;
  config?: GetMemoryConfig;
}

/** Config for listing memories. */
export declare interface ListMemoriesConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  pageSize?: number;
  pageToken?: string;
  /** An expression for filtering the results of the request.
      For field names both snake_case and camelCase are supported. */
  filter?: string;
  /** The standard list order by string. If not specified, the default
      order is `create_time desc`. If specified, the default sorting order of
      provided fields is ascending. More detail in
      [AIP-132](https://google.aip.dev/132).

      Supported fields:
      * `create_time`
      * `update_time` */
  orderBy?: string;
}

/** Parameters for listing memories. */
export declare interface ListMemoriesRequestParameters {
  /** Name of the Memory Bank. */
  name: string;
  config?: ListMemoriesConfig;
}

/** Response for listing memories. */
export class ListMemoriesResponse {
  /** Used to retain the full HTTP response. */
  sdkHttpResponse?: genaiTypes.HttpResponse;
  nextPageToken?: string;
  /** List of memories. */
  memories?: Memory[];
}

/** Parameters for getting an operation with a memory as a response. */
export declare interface GetMemoryOperationParameters {
  /** The server-assigned name for the operation. */
  operationName: string;
  /** Used to override the default configuration. */
  config?: GetMemoryBankOperationConfig;
}

/** Parameters for getting an operation with generated memories as a response. */
export declare interface GetGenerateMemoriesOperationParameters {
  /** The server-assigned name for the operation. */
  operationName: string;
  /** Used to override the default configuration. */
  config?: GetMemoryBankOperationConfig;
}

/** The parameters for semantic similarity search based retrieval. */
export declare interface RetrieveMemoriesRequestSimilaritySearchParams {
  /** Required. Query to use for similarity search retrieval. If provided, then the parent ReasoningEngine must have ReasoningEngineContextSpec.MemoryBankConfig.SimilaritySearchConfig set. */
  searchQuery?: string;
  /** Optional. The maximum number of memories to return. The service may return fewer than this value. If unspecified, at most 3 memories will be returned. The maximum value is 100; values above 100 will be coerced to 100. */
  topK?: number;
}

/** The parameters for simple (non-similarity search) retrieval. */
export declare interface RetrieveMemoriesRequestSimpleRetrievalParams {
  /** Optional. The maximum number of memories to return. The service may return fewer than this value. If unspecified, at most 3 memories will be returned. The maximum value is 100; values above 100 will be coerced to 100. */
  pageSize?: number;
  /** Optional. A page token, received from a previous `RetrieveMemories` call. Provide this to retrieve the subsequent page. */
  pageToken?: string;
}

/** Filter to apply when retrieving memories. */
export declare interface MemoryFilter {
  /** Represents the key of the filter. For example, "author" would apply to `metadata` entries with the key "author". */
  key?: string;
  /** Indicates whether the filter will be negated. */
  negate?: boolean;
  /** Represents the operator to apply to the filter. If not set, then EQUAL will be used. */
  op?: Operator;
  /** Represents the value to compare to. */
  value?: MemoryMetadataValue;
}

/** The conjunction filter for memories. */
export declare interface MemoryConjunctionFilter {
  /** Represents filters that will be combined using AND logic. */
  filters?: MemoryFilter[];
}

/** Config for retrieving memories. */
export declare interface RetrieveMemoriesConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The standard list filter that will be applied to the retrieved
      memories. More detail in [AIP-160](https://google.aip.dev/160).

      Supported fields:
       * `fact`
       * `create_time`
       * `update_time`
       */
  filter?: string;
  /** Metadata filters that will be applied to the retrieved memories'
      `metadata` using OR logic. Filters are defined using disjunctive normal
      form (OR of ANDs).

      For example:
      `filter_groups: [{filters: [{key: "author", value: {string_value: "agent
      `123"}, op: EQUAL}]}, {filters: [{key: "label", value: {string_value:
      "travel"}, op: EQUAL}, {key: "author", value: {string_value: "agent 321"},
      op: EQUAL}]}]`

      would be equivalent to the logical expression:
      `(metadata.author = "agent 123" OR (metadata.label = "travel" AND
      metadata.author = "agent 321"))`.
       */
  filterGroups?: MemoryConjunctionFilter[];
  /** Specifies the types of memories to retrieve. If this field is empty
      or not provided, the request will default to retrieving only memories of
      type `NATURAL_LANGUAGE_COLLECTION`. If populated, the request will
      retrieve memories matching any of the specified `MemoryType` values. */
  memoryTypes?: MemoryType[];
}

/** Parameters for retrieving memories. */
export declare interface RetrieveMemoriesRequestParameters {
  /** Name of the Memory Bank to retrieve memories from. */
  name: string;
  /** The scope of the memories to retrieve.

      A memory must have exactly the same scope as the scope provided here to be
      retrieved (i.e. same keys and values). Order does not matter, but it is
      case-sensitive. */
  scope: Record<string, string>;
  /** Parameters for semantic similarity search based retrieval. */
  similaritySearchParams?: RetrieveMemoriesRequestSimilaritySearchParams;
  /** Parameters for simple (non-similarity search) retrieval. */
  simpleRetrievalParams?: RetrieveMemoriesRequestSimpleRetrievalParams;
  config?: RetrieveMemoriesConfig;
}

/** A retrieved memory. */
export class RetrieveMemoriesResponseRetrievedMemory {
  /** The distance between the query and the retrieved Memory. Smaller values indicate more similar memories. This is only set if similarity search was used for retrieval. */
  distance?: number;
  /** The retrieved Memory. */
  memory?: Memory;
}

/** The response for retrieving memories. */
export class RetrieveMemoriesResponse {
  /** A token that can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages. This token is not set if similarity search was used for retrieval. */
  nextPageToken?: string;
  /** The retrieved memories. */
  retrievedMemories?: RetrieveMemoriesResponseRetrievedMemory[];
}

/** Config for retrieving memory profiles. */
export declare interface RetrieveMemoryProfilesConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for retrieving memory profiles. */
export declare interface RetrieveMemoryProfilesRequestParameters {
  /** Name of the Memory Bank to retrieve memory profiles from. */
  name: string;
  /** The scope of the memories to retrieve.

      A memory must have exactly the same scope as the scope provided here to be
      retrieved (i.e. same keys and values). Order does not matter, but it is
      case-sensitive. */
  scope: Record<string, string>;
  config?: RetrieveMemoryProfilesConfig;
}

/** A memory profile. */
export declare interface MemoryProfile {
  /** Represents the ID of the schema. This ID corresponds to the `schema_id` defined inside the SchemaConfig, under StructuredMemoryCustomizationConfig. */
  schemaId?: string;
  /** Represents the profile data. */
  profile?: Record<string, unknown>;
}

/** The response for retrieving memory profiles. */
export class RetrieveProfilesResponse {
  /** The retrieved structured profiles, which match the schemas under the
      requested scope. The key is the ID of the schema that the profile is
      linked with, which corresponds to the `schema_id` defined inside the
      `SchemaConfig`, under `StructuredMemoryCustomizationConfig`. */
  profiles?: Record<string, MemoryProfile>;
}

/** Config for rolling back a memory. */
export declare interface RollbackMemoryConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Waits for the operation to complete before returning. */
  waitForCompletion?: boolean;
}

/** Parameters for generating memories. */
export declare interface RollbackMemoryRequestParameters {
  /** Name of the memory to rollback. */
  name: string;
  /** The ID of the revision to rollback to. */
  targetRevisionId: string;
  config?: RollbackMemoryConfig;
}

/** Operation that rolls back a memory. */
export declare interface RollbackMemoryOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

/** Config for updating a memory. */
export declare interface UpdateMemoryConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The display name of the memory. */
  displayName?: string;
  /** The description of the memory. */
  description?: string;
  /** Waits for the operation to complete before returning. */
  waitForCompletion?: boolean;
  /** Optional. Input only. The TTL for this resource.

      The expiration time is computed: now + TTL. */
  ttl?: string;
  /** Optional. Timestamp of when this resource is considered expired. This is *always* provided on output, regardless of what `expiration` was sent on input. */
  expireTime?: string;
  /** Optional. Input only. Timestamp of when the revision is considered expired. If not set, the memory revision will be kept until manually deleted. */
  revisionExpireTime?: string;
  /** Optional. Input only. The TTL for the revision. The expiration time is computed: now + TTL. */
  revisionTtl?: string;
  /** Optional. Input only. If true, no revision will be created for this request. */
  disableMemoryRevisions?: boolean;
  /** Optional. The topics of the memory. */
  topics?: MemoryTopicId[];
  /** Optional. User-provided metadata for the Memory. This information was provided when creating, updating, or generating the Memory. It was not generated by Memory Bank. */
  metadata?: Record<string, MemoryMetadataValue>;
  /** Optional. The user defined ID to use for memory, which will become the final component of the memory resource name. If not provided, Vertex AI will generate a value for this ID. This value may be up to 63 characters, and valid characters are `[a-z0-9-]`. The first character must be a letter, and the last character must be a letter or number. */
  memoryId?: string;
  /** The update mask to apply. For the `FieldMask` definition, see
      https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask. */
  updateMask?: string;
}

/** Parameters for updating memories. */
export declare interface UpdateMemoryRequestParameters {
  /** Name of the memory to update. */
  name: string;
  /** The updated fact of the memory.

      This is the semantic knowledge extracted from the source content. */
  fact?: string;
  /** The updated scope of the memory.

      Memories are isolated within their scope. The scope is defined when
      creating or generating memories. Up to 5 key-value pairs are accepted,
      and scope values cannot contain the wildcard character '*'. */
  scope?: Record<string, string>;
  config?: UpdateMemoryConfig;
}

/** Config for purging memories. */
export declare interface PurgeMemoriesConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Waits for the operation to complete before returning. */
  waitForCompletion?: boolean;
}

/** Parameters for purging memories. */
export declare interface PurgeMemoriesRequestParameters {
  /** Name of the Memory Bank to purge memories from. */
  name: string;
  /** The standard list filter to determine which memories to purge.
      More detail in [AIP-160](https://google.aip.dev/160). */
  filter?: string;
  /** Metadata filters that will be applied to the memories'
      `metadata` using OR logic. Filters are defined using disjunctive normal
      form (OR of ANDs).

      For example:
      `filter_groups: [{filters: [{key: "author", value: {string_value: "agent
      `123"}, op: EQUAL}]}, {filters: [{key: "label", value: {string_value:
      "travel"}, op: EQUAL}, {key: "author", value: {string_value: "agent 321"},
      op: EQUAL}]}]`

      would be equivalent to the logical expression:
      `(metadata.author = "agent 123" OR (metadata.label = "travel" AND
      metadata.author = "agent 321"))`.
       */
  filterGroups?: MemoryConjunctionFilter[];
  /** If true, the memories will actually be purged. If false, the purge request will be validated but not executed. */
  force?: boolean;
  config?: PurgeMemoriesConfig;
}

/** The response for purging memories. */
export class PurgeMemoriesResponse {
  /** The number of memories that were purged. */
  purgeCount?: number;
}

/** Operation that purges memories from a Memory Bank. */
export declare interface PurgeMemoriesOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
  /** The response for purging memories. */
  response?: PurgeMemoriesResponse;
}

/** Config for getting a Memory Revision. */
export declare interface GetMemoryRevisionConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for getting a memory revision. */
export declare interface GetMemoryRevisionRequestParameters {
  /** Name of the Memory Revision. */
  name: string;
  config?: GetMemoryRevisionConfig;
}

/** An extracted memory that is the intermediate result before consolidation. */
export declare interface IntermediateExtractedMemory {
  /** Output only. Represents the fact of the extracted memory. */
  fact?: string;
  /** Output only. Represents the explanation of why the information was extracted from the source content. */
  context?: string;
  /** Output only. Represents the structured value of the extracted memory. */
  structuredData?: Record<string, unknown>;
}

/** A memory revision. */
export declare interface MemoryRevision {
  /** Output only. Represents the timestamp when this Memory Revision was created. */
  createTime?: string;
  /** Output only. Represents the timestamp of when this resource is considered expired. */
  expireTime?: string;
  /** Output only. Represents the extracted memories from the source content before consolidation when the memory was updated via GenerateMemories. This information was used to modify an existing Memory via Consolidation. */
  extractedMemories?: IntermediateExtractedMemory[];
  /** Output only. Represents the fact of the Memory Revision. This corresponds to the `fact` field of the parent Memory at the time of revision creation. */
  fact?: string;
  /** Output only. Represents the labels of the Memory Revision. These labels are applied to the MemoryRevision when it is created based on `GenerateMemoriesRequest.revision_labels`. */
  labels?: Record<string, string>;
  /** Identifier. Represents the resource name of the Memory Revision. Format: `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/memories/{memory}/revisions/{memory_revision}` */
  name?: string;
  /** Output only. Represents the structured value of the memory at the time of revision creation. */
  structuredData?: Record<string, unknown>;
}

/** Config for listing memory revisions. */
export declare interface ListMemoryRevisionsConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  pageSize?: number;
  pageToken?: string;
  /** An expression for filtering the results of the request.
      For field names both snake_case and camelCase are supported. */
  filter?: string;
}

/** Parameters for listing memory revisions. */
export declare interface ListMemoryRevisionsRequestParameters {
  /** Name of the memory */
  name: string;
  config?: ListMemoryRevisionsConfig;
}

/** Response for listing memory revisions. */
export class ListMemoryRevisionsResponse {
  /** Used to retain the full HTTP response. */
  sdkHttpResponse?: genaiTypes.HttpResponse;
  nextPageToken?: string;
  /** List of memory revisions. */
  memoryRevisions?: MemoryRevision[];
}

/** The code execution environment with customized settings. */
export declare interface SandboxEnvironmentSpecCodeExecutionEnvironment {
  /** The coding language supported in this environment. */
  codeLanguage?: Language;
  /** The machine config of the code execution environment. */
  machineConfig?: MachineConfig;
}

/** The computer use environment with customized settings. */
export declare interface SandboxEnvironmentSpecComputerUseEnvironment {}

/** The shell environment with customized settings. */
export declare interface SandboxEnvironmentSpecShellEnvironment {}

/** The specification of a sandbox environment. */
export declare interface SandboxEnvironmentSpec {
  /** Optional. The code execution environment. */
  codeExecutionEnvironment?: SandboxEnvironmentSpecCodeExecutionEnvironment;
  /** Optional. The computer use environment. */
  computerUseEnvironment?: SandboxEnvironmentSpecComputerUseEnvironment;
  /** Optional. The shell environment. */
  shellEnvironment?: SandboxEnvironmentSpecShellEnvironment;
}

/** Config for creating a Sandbox. */
export declare interface CreateAgentEngineSandboxConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The display name of the sandbox. */
  displayName?: string;
  /** The description of the sandbox. */
  description?: string;
  /** Waits for the operation to complete before returning. */
  waitForCompletion?: boolean;
  /** The TTL for this resource. The expiration time is computed: now + TTL. */
  ttl?: string;
  /** The name of the sandbox environment template to create the sandbox from. The sandbox environment template should be in the format:
      projects/{project}/locations/{location}/agentEngines/{agent_engine}/sandboxEnvironmentTemplates/{sandbox_environment_template} */
  sandboxEnvironmentTemplate?: string;
  /** The name of the sandbox environment snapshot to restore the sandbox from. The sandbox environment snapshot should be in the format:
      projects/{project}/locations/{location}/agentEngines/{agent_engine}/sandboxEnvironmentSnapshots/{sandbox_environment_snapshot} */
  sandboxEnvironmentSnapshot?: string;
  /** Owner information for this sandbox environment. A sandbox can only be restored from a snapshot belonging to the same owner. */
  owner?: string;
}

/** Parameters for creating Agent Engine Sandboxes. */
export declare interface CreateAgentEngineSandboxRequestParameters {
  /** Name of the agent engine to create the sandbox under. */
  name: string;
  /** The specification of the sandbox. */
  spec?: SandboxEnvironmentSpec;
  config?: CreateAgentEngineSandboxConfig;
}

/** The connection information of the SandboxEnvironment. */
export declare interface SandboxEnvironmentConnectionInfo {
  /** Output only. The hostname of the load balancer. */
  loadBalancerHostname?: string;
  /** Output only. The IP address of the load balancer. */
  loadBalancerIp?: string;
  /** Output only. The internal IP address of the SandboxEnvironment. */
  sandboxInternalIp?: string;
  /** Output only. The routing token for the SandboxEnvironment. */
  routingToken?: string;
  /** Output only. The name of the PSC-E service attachment created for private ingress to this SandboxEnvironment. Only populated when the template enables private ingress (see SandboxEnvironmentTemplate.ingress_control_config). VPC-SC customers use this to create a PSC endpoint in their VPC. */
  serviceAttachment?: string;
}

/** A sandbox environment. */
export declare interface SandboxEnvironment {
  /** Expiration time of the sandbox environment.
   */
  expireTime?: string;
  /** Output only. The connection information of the SandboxEnvironment. */
  connectionInfo?: SandboxEnvironmentConnectionInfo;
  /** Output only. The timestamp when this SandboxEnvironment was created. */
  createTime?: string;
  /** Required. The display name of the SandboxEnvironment. */
  displayName?: string;
  /** Identifier. The name of the SandboxEnvironment. */
  name?: string;
  /** Optional. The configuration of the SandboxEnvironment. */
  spec?: SandboxEnvironmentSpec;
  /** Output only. The runtime state of the SandboxEnvironment. */
  state?: SandboxState;
  /** Optional. Input only. The TTL for the sandbox environment. The expiration time is computed: now + TTL. */
  ttl?: string;
  /** Output only. The timestamp when this SandboxEnvironment was most recently updated. */
  updateTime?: string;
  /** Output only. The resource name of the latest snapshot taken for this SandboxEnvironment. */
  latestSandboxEnvironmentSnapshot?: string;
  /** Optional. Owner information for this sandbox environment. A Sandbox can only be restored from a snapshot that belongs to the same owner. If not set, sandbox will be created as the default owner. */
  owner?: string;
  /** Optional. The resource name of the SandboxEnvironmentSnapshot to use for creating this SandboxEnvironment. Format: `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/sandboxEnvironmentSnapshots/{sandbox_environment_snapshot}` */
  sandboxEnvironmentSnapshot?: string;
  /** Optional. The name of the SandboxEnvironmentTemplate specified in the parent Agent Engine resource that this SandboxEnvironment is created from. */
  sandboxEnvironmentTemplate?: string;
}

/** Operation that has an agent engine sandbox as a response. */
export declare interface AgentEngineSandboxOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
  /** The Agent Engine Sandbox. */
  response?: SandboxEnvironment;
}

/** Config for deleting an Agent Engine Sandbox. */
export declare interface DeleteAgentEngineSandboxConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for deleting agent engines. */
export declare interface DeleteAgentEngineSandboxRequestParameters {
  /** Name of the agent engine sandbox to delete. */
  name: string;
  config?: DeleteAgentEngineSandboxConfig;
}

/** Operation for deleting agent engines. */
export declare interface DeleteAgentEngineSandboxOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

/** Metadata for a chunk. */
export declare interface Metadata {
  /** Optional. Attributes attached to the data. The keys have semantic conventions and the consumers of the attributes should know how to deserialize the value bytes based on the keys. */
  attributes?: Record<string, string>;
}

/** A chunk of data. */
export declare interface Chunk {
  /** Required. The data in the chunk.
   * @remarks Encoded as base64 string. */
  data?: string;
  /** Optional. Metadata that is associated with the data in the payload. */
  metadata?: Metadata;
  /** Required. Mime type of the chunk data. See https://www.iana.org/assignments/media-types/media-types.xhtml for the full list. */
  mimeType?: string;
}

/** Config for executing code in an Agent Engine sandbox. */
export declare interface ExecuteCodeAgentEngineSandboxConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for executing code in an agent engine sandbox. */
export declare interface ExecuteCodeAgentEngineSandboxRequestParameters {
  /** Name of the agent engine sandbox to execute code in. */
  name: string;
  /** Inputs to the code execution. */
  inputs?: Chunk[];
  config?: ExecuteCodeAgentEngineSandboxConfig;
}

/** The response for executing a sandbox environment. */
export class ExecuteSandboxEnvironmentResponse {
  /** The outputs from the sandbox environment. */
  outputs?: Chunk[];
}

/** Config for getting an Agent Engine Memory. */
export declare interface GetAgentEngineSandboxConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for getting an agent engine sandbox. */
export declare interface GetAgentEngineSandboxRequestParameters {
  /** Name of the agent engine sandbox. */
  name: string;
  config?: GetAgentEngineSandboxConfig;
}

/** Config for listing agent engine sandboxes. */
export declare interface ListAgentEngineSandboxesConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  pageSize?: number;
  pageToken?: string;
  /** An expression for filtering the results of the request.
      For field names both snake_case and camelCase are supported. */
  filter?: string;
}

/** Parameters for listing agent engine sandboxes. */
export declare interface ListAgentEngineSandboxesRequestParameters {
  /** Name of the agent engine. */
  name: string;
  config?: ListAgentEngineSandboxesConfig;
}

/** Response for listing agent engine sandboxes. */
export class ListAgentEngineSandboxesResponse {
  /** Used to retain the full HTTP response. */
  sdkHttpResponse?: genaiTypes.HttpResponse;
  nextPageToken?: string;
  /** List of agent engine sandboxes. */
  sandboxEnvironments?: SandboxEnvironment[];
}

/** Parameters for getting an operation with a sandbox as a response. */
export declare interface GetAgentEngineSandboxOperationParameters {
  /** The server-assigned name for the operation. */
  operationName: string;
  /** Used to override the default configuration. */
  config?: GetAgentEngineOperationConfig;
}

/** Specification for deploying from a custom container image. */
export declare interface SandboxEnvironmentTemplateCustomContainerSpec {
  /** Required. The Artifact Registry Docker image URI (e.g., us-central1-docker.pkg.dev/my-project/my-repo/my-image:tag) of the container image that is to be run on each worker replica. */
  imageUri?: string;
}

/** Represents a network port in a container. */
export declare interface SandboxEnvironmentTemplateNetworkPort {
  /** Optional. Port number to expose. This must be a valid port number, between 1 and 65535. */
  port?: number;
  /** Optional. Protocol for port. Defaults to TCP if not specified. */
  protocol?: Protocol;
}

/** Message to define resource requests and limits (mirroring Kubernetes) for each sandbox instance created from this template. */
export declare interface SandboxEnvironmentTemplateResourceRequirements {
  /** Optional. The maximum amounts of compute resources allowed. Keys are resource names (e.g., "cpu", "memory"). Values are quantities (e.g., "500m", "1Gi"). */
  limits?: Record<string, string>;
  /** Optional. The requested amounts of compute resources. Keys are resource names (e.g., "cpu", "memory"). Values are quantities (e.g., "250m", "512Mi"). */
  requests?: Record<string, string>;
}

/** The customized sandbox runtime environment for BYOC. */
export declare interface SandboxEnvironmentTemplateCustomContainerEnvironment {
  /** The specification of the custom container environment. */
  customContainerSpec?: SandboxEnvironmentTemplateCustomContainerSpec;
  /** Ports to expose from the container. */
  ports?: SandboxEnvironmentTemplateNetworkPort[];
  /** Resource requests and limits for the container. */
  resources?: SandboxEnvironmentTemplateResourceRequirements;
}

/** The default sandbox runtime environment for default container workloads. */
export declare interface SandboxEnvironmentTemplateDefaultContainerEnvironment {
  /** Required. The category of the default container image. */
  defaultContainerCategory?: DefaultContainerCategory;
  /** Optional. Resource requests and limits for the default container. */
  resources?: SandboxEnvironmentTemplateResourceRequirements;
}

/** Configuration for peering a customer's private DNS zone so that sandbox egress can resolve customer-internal domains via the customer VPC. */
export declare interface SandboxEnvironmentTemplateEgressControlConfigDnsPeeringConfig {
  /** Required. The DNS name suffix of the zone being peered to, e.g., "my-internal-domain.corp.". Must end with a dot. */
  domain?: string;
  /** Required. The VPC network name in the target_project where the DNS zone specified by 'domain' is visible. */
  targetNetwork?: string;
  /** Required. The project ID hosting the Cloud DNS managed zone that contains the 'domain'. The Vertex AI Service Agent requires the dns.peer role on this project. */
  targetProject?: string;
}

/** Configuration for egress control of sandbox instances. */
export declare interface SandboxEnvironmentTemplateEgressControlConfig {
  /** Optional. Whether to allow internet access. */
  internetAccess?: boolean;
  /** Optional. The customer VPC network that sandbox egress is routed into. */
  customerVpcNetwork?: string;
  /** Optional. DNS peering configurations that allow sandbox egress to resolve customer-internal domains via the customer VPC. */
  dnsPeeringConfigs?: SandboxEnvironmentTemplateEgressControlConfigDnsPeeringConfig[];
  /** Optional. The name of the customer VPC NetworkAttachment used to draw a PSC interface IP into the customer VPC for sandbox egress. */
  networkAttachment?: string;
}

/** Config for creating a Sandbox Template. */
export declare interface CreateSandboxEnvironmentTemplateConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The custom container environment for the sandbox template. */
  customContainerEnvironment?: SandboxEnvironmentTemplateCustomContainerEnvironment;
  /** The default container environment for the sandbox template. */
  defaultContainerEnvironment?: SandboxEnvironmentTemplateDefaultContainerEnvironment;
  /** The egress control config for the sandbox template. */
  egressControlConfig?: SandboxEnvironmentTemplateEgressControlConfig;
  /** Waits for the operation to complete before returning. */
  waitForCompletion?: boolean;
}

/** Parameters for creating Sandbox Environment Templates. */
export declare interface CreateSandboxEnvironmentTemplateRequestParameters {
  /** Name of the agent engine to create the template under. */
  name: string;
  /** The display name of the sandbox template. */
  displayName: string;
  config?: CreateSandboxEnvironmentTemplateConfig;
}

/** PSC config that is used to automatically create PSC endpoints in the user projects. */
export declare interface PSCAutomationConfig {
  /** Output only. Error message if the PSC service automation failed. */
  errorMessage?: string;
  /** Output only. Forwarding rule created by the PSC service automation. */
  forwardingRule?: string;
  /** Output only. IP address rule created by the PSC service automation. */
  ipAddress?: string;
  /** Required. The full name of the Google Compute Engine [network](https://cloud.google.com/compute/docs/networks-and-firewalls#networks). [Format](https://cloud.google.com/compute/docs/reference/rest/v1/networks/get): `projects/{project}/global/networks/{network}`. */
  network?: string;
  /** Required. Project id used to create forwarding rule. */
  projectId?: string;
  /** Output only. The state of the PSC service automation. */
  state?: PscAutomationState;
}

/** Represents configuration for private service connect. */
export declare interface PrivateServiceConnectConfig {
  /** Required. If true, expose the IndexEndpoint via private service connect. */
  enablePrivateServiceConnect?: boolean;
  /** Optional. If set to true, enable secure private service connect with IAM authorization. Otherwise, private service connect will be done without authorization. Note latency will be slightly increased if authorization is enabled. */
  enableSecurePrivateServiceConnect?: boolean;
  /** A list of Projects from which the forwarding rule will target the service attachment. */
  projectAllowlist?: string[];
  /** Optional. List of projects and networks where the PSC endpoints will be created. This field is used by Online Inference(Prediction) only. */
  pscAutomationConfigs?: PSCAutomationConfig[];
  /** Output only. The name of the generated service attachment resource. This is only populated if the endpoint is deployed with PrivateServiceConnect. */
  serviceAttachment?: string;
}

/** A sandbox environment template. */
export declare interface SandboxEnvironmentTemplate {
  /** Output only. The timestamp when this SandboxEnvironmentTemplate was created. */
  createTime?: string;
  /** The sandbox environment for custom container workloads. */
  customContainerEnvironment?: SandboxEnvironmentTemplateCustomContainerEnvironment;
  /** The sandbox environment for default container workloads. */
  defaultContainerEnvironment?: SandboxEnvironmentTemplateDefaultContainerEnvironment;
  /** Required. The display name of the SandboxEnvironmentTemplate. */
  displayName?: string;
  /** Optional. The configuration for egress control of this template. */
  egressControlConfig?: SandboxEnvironmentTemplateEgressControlConfig;
  /** Identifier. The resource name of the SandboxEnvironmentTemplate. Format: `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/sandboxEnvironmentTemplates/{sandbox_environment_template}` */
  name?: string;
  /** Output only. The state of the sandbox environment template. */
  state?:
    | 'UNSPECIFIED'
    | 'PROVISIONING'
    | 'ACTIVE'
    | 'DEPROVISIONING'
    | 'DELETED'
    | 'FAILED';
  /** Output only. The timestamp when this SandboxEnvironmentTemplate was most recently updated. */
  updateTime?: string;
  /** Optional. The configuration for private ingress (PSC-E) of this template. When set, the sandbox router is exposed privately via a PSC service attachment so VPC-SC customers can connect from their VPC over a private endpoint instead of the public internet. The resulting service attachment is surfaced on `SandboxEnvironment.connection_info.service_attachment`. Only the PSC-E (service-attachment/ingress) portion of `PrivateServiceConnectConfig` applies here: `enable_private_service_connect` and `project_allowlist` (the consumer projects allowed to connect). The nested `psc_interface_config` (PSC-I / egress) is not used for sandbox ingress; sandbox egress is configured via `egress_control_config` instead. */
  ingressControlConfig?: PrivateServiceConnectConfig;
}

/** Operation that has an agent engine sandbox as a response. */
export declare interface SandboxEnvironmentTemplateOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
  /** The Agent Engine Sandbox Template. */
  response?: SandboxEnvironmentTemplate;
}

/** Config for deleting a Sandbox Template. */
export declare interface DeleteSandboxEnvironmentTemplateConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for deleting sandbox templates. */
export declare interface DeleteSandboxEnvironmentTemplateRequestParameters {
  /** Name of the sandbox template to delete. */
  name: string;
  config?: DeleteSandboxEnvironmentTemplateConfig;
}

/** Operation for deleting sandbox templates. */
export declare interface DeleteSandboxEnvironmentTemplateOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

/** Config for getting a Sandbox Template. */
export declare interface GetSandboxEnvironmentTemplateConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for getting a sandbox template. */
export declare interface GetSandboxEnvironmentTemplateRequestParameters {
  /** Name of the sandbox template. */
  name: string;
  config?: GetSandboxEnvironmentTemplateConfig;
}

/** Config for listing sandbox templates. */
export declare interface ListSandboxEnvironmentTemplatesConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  pageSize?: number;
  pageToken?: string;
  /** An expression for filtering the results of the request. */
  filter?: string;
}

/** Parameters for listing sandbox templates. */
export declare interface ListSandboxEnvironmentTemplatesRequestParameters {
  /** Name of the agent engine. */
  name: string;
  config?: ListSandboxEnvironmentTemplatesConfig;
}

/** Response for listing sandbox templates. */
export class ListSandboxEnvironmentTemplatesResponse {
  /** Used to retain the full HTTP response. */
  sdkHttpResponse?: genaiTypes.HttpResponse;
  nextPageToken?: string;
  /** List of sandbox templates. */
  sandboxEnvironmentTemplates?: SandboxEnvironmentTemplate[];
}

/** Parameters for getting an operation with a sandbox template as a response. */
export declare interface GetSandboxEnvironmentTemplateOperationParameters {
  /** The server-assigned name for the operation. */
  operationName: string;
  /** Used to override the default configuration. */
  config?: GetAgentEngineOperationConfig;
}

/** Config for creating a Sandbox Environment Snapshot. */
export declare interface CreateAgentEngineSandboxSnapshotConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The display name of the sandbox snapshot. */
  displayName?: string;
  /** The owner of the sandbox snapshot. */
  owner?: string;
  /** The TTL for this resource. The expiration time is computed: now + TTL. */
  ttl?: string;
  /** Waits for the operation to complete before returning. */
  waitForCompletion?: boolean;
}

/** Parameters for creating a sandbox environment snapshot. */
export declare interface CreateSandboxEnvironmentSnapshotRequestParameters {
  /** Name of the sandbox environment to snapshot. */
  sourceSandboxEnvironmentName: string;
  config?: CreateAgentEngineSandboxSnapshotConfig;
}

/** A sandbox environment snapshot. */
export declare interface SandboxEnvironmentSnapshot {
  /** The display name of the sandbox environment snapshot. */
  displayName?: string;
  /** Expiration time of the sandbox environment snapshot.
   */
  expireTime?: string;
  /** Output only. The timestamp when this SandboxEnvironmentSnapshot was created. */
  createTime?: string;
  /** Identifier. The resource name of the SandboxEnvironmentSnapshot. Format: `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/sandboxEnvironmentSnapshots/{sandbox_environment_snapshot}` */
  name?: string;
  /** Optional. Owner information for this sandbox snapshot. Different owners will have isolations on snapshot storage and identity. If not set, snapshot will be created as the default owner. */
  owner?: string;
  /** Output only. The resource name of the parent SandboxEnvironmentSnapshot. Empty if this is a root Snapshot (the first snapshot from a newly created sandbox). Can be used to reconstruct the whole ancestry tree of snapshots. */
  parentSnapshot?: string;
  /** Optional. Input only. Action to take on the source SandboxEnvironment after the snapshot is taken. This field is only used in CreateSandboxEnvironmentSnapshotRequest and it is not stored in the resource. */
  postSnapshotAction?: PostSnapshotAction;
  /** Optional. Output only. Size of the snapshot data in bytes. */
  sizeBytes?: string;
  /** Required. The resource name of the source SandboxEnvironment this snapshot was taken from. */
  sourceSandboxEnvironment?: string;
  /** Optional. Input only. The TTL for the sandbox environment snapshot. The expiration time is computed: now + TTL. */
  ttl?: string;
  /** Output only. The timestamp when this SandboxEnvironment was most recently updated. */
  updateTime?: string;
}

/** Operation that has an agent engine sandbox snapshot as a response. */
export declare interface AgentEngineSandboxSnapshotOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
  /** The Agent Engine Sandbox Snapshot. */
  response?: SandboxEnvironmentSnapshot;
}

/** Config for deleting a Sandbox Environment Snapshot. */
export declare interface DeleteSandboxEnvironmentSnapshotConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for deleting sandbox environment snapshots. */
export declare interface DeleteSandboxEnvironmentSnapshotRequestParameters {
  /** Name of the sandbox environment snapshot to delete. */
  name: string;
  config?: DeleteSandboxEnvironmentSnapshotConfig;
}

/** Operation for deleting sandbox environment snapshots. */
export declare interface DeleteSandboxEnvironmentSnapshotOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

/** Config for getting a Sandbox Environment Snapshot. */
export declare interface GetSandboxEnvironmentSnapshotConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for getting a sandbox environment snapshot. */
export declare interface GetSandboxEnvironmentSnapshotRequestParameters {
  /** Name of the sandbox environment snapshot. */
  name: string;
  config?: GetSandboxEnvironmentSnapshotConfig;
}

/** Config for listing sandbox environment snapshots. */
export declare interface ListSandboxEnvironmentSnapshotsConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  pageSize?: number;
  pageToken?: string;
  /** An expression for filtering the results of the request. */
  filter?: string;
}

/** Parameters for listing sandbox environment snapshots. */
export declare interface ListSandboxEnvironmentSnapshotsRequestParameters {
  /** Name of the reasoning engine to list snapshots from. */
  name: string;
  config?: ListSandboxEnvironmentSnapshotsConfig;
}

/** Response for listing sandbox environment snapshots. */
export class ListSandboxEnvironmentSnapshotsResponse {
  /** Used to retain the full HTTP response. */
  sdkHttpResponse?: genaiTypes.HttpResponse;
  nextPageToken?: string;
  /** List of sandbox environment snapshots. */
  sandboxEnvironmentSnapshots?: SandboxEnvironmentSnapshot[];
}

/** Parameters for getting an operation with a sandbox snapshot as a response. */
export declare interface GetAgentEngineSandboxSnapshotOperationParameters {
  /** The server-assigned name for the operation. */
  operationName: string;
  /** Used to override the default configuration. */
  config?: GetAgentEngineOperationConfig;
}

/** Config for creating a Session. */
export declare interface CreateAgentEngineSessionConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The display name of the session. */
  displayName?: string;
  /** Session state which stores key conversation points. */
  sessionState?: Record<string, unknown>;
  /** Waits for the operation to complete before returning. */
  waitForCompletion?: boolean;
  /** Optional. Input only. The TTL for this resource.

      The expiration time is computed: now + TTL. */
  ttl?: string;
  /** Optional. Timestamp of when this resource is considered expired. This is *always* provided on output, regardless of what `expiration` was sent on input. */
  expireTime?: string;
  /** Optional. The labels with user-defined metadata to organize your Sessions. Label keys and values can be no longer than 64 characters (Unicode codepoints), can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. See https://goo.gl/xmQnxf for more information and examples of labels. */
  labels?: Record<string, string>;
  /** Optional. The user defined ID to use for session, which will become the final component of the session resource name. If not provided, Vertex AI will generate a value for this ID. This value may be up to 63 characters, and valid characters are `[a-z0-9-]`. The first character must be a letter, and the last character must be a letter or number. */
  sessionId?: string;
}

/** Parameters for creating Agent Engine Sessions. */
export declare interface CreateAgentEngineSessionRequestParameters {
  /** Name of the agent engine to create the session under. */
  name: string;
  /** The user ID of the session. */
  userId: string;
  config?: CreateAgentEngineSessionConfig;
}

/** A session. */
export declare interface Session {
  /** Output only. Timestamp when the session was created. */
  createTime?: string;
  /** Optional. The display name of the session. */
  displayName?: string;
  /** Optional. Timestamp of when this session is considered expired. This is *always* provided on output, regardless of what was sent on input. The minimum value is 24 hours from the time of creation. */
  expireTime?: string;
  /** The labels with user-defined metadata to organize your Sessions. Label keys and values can be no longer than 64 characters (Unicode codepoints), can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. See https://goo.gl/xmQnxf for more information and examples of labels. */
  labels?: Record<string, string>;
  /** Identifier. The resource name of the session. Format: 'projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/sessions/{session}'. */
  name?: string;
  /** Optional. Session specific memory which stores key conversation points. */
  sessionState?: Record<string, unknown>;
  /** Optional. Input only. The TTL for this session. The minimum value is 24 hours. */
  ttl?: string;
  /** Output only. Timestamp when the session was updated. */
  updateTime?: string;
  /** Required. Immutable. String id provided by the user */
  userId?: string;
}

/** Operation that has an agent engine session as a response. */
export declare interface AgentEngineSessionOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
  /** The Agent Engine Session. */
  response?: Session;
}

/** Config for deleting an Agent Engine Session. */
export declare interface DeleteAgentEngineSessionConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for deleting agent engine sessions. */
export declare interface DeleteAgentEngineSessionRequestParameters {
  /** Name of the agent engine session to delete. */
  name: string;
  config?: DeleteAgentEngineSessionConfig;
}

/** Operation for deleting agent engine sessions. */
export declare interface DeleteAgentEngineSessionOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

/** Config for getting an Agent Engine Session. */
export declare interface GetAgentEngineSessionConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for getting an agent engine session. */
export declare interface GetAgentEngineSessionRequestParameters {
  /** Name of the agent engine session. */
  name: string;
  config?: GetAgentEngineSessionConfig;
}

/** Config for listing agent engine sessions. */
export declare interface ListAgentEngineSessionsConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  pageSize?: number;
  pageToken?: string;
  /** An expression for filtering the results of the request.
      For field names both snake_case and camelCase are supported. */
  filter?: string;
}

/** Parameters for listing agent engines. */
export declare interface ListAgentEngineSessionsRequestParameters {
  /** Name of the agent engine. */
  name: string;
  config?: ListAgentEngineSessionsConfig;
}

/** Response for listing agent engine sessions. */
export class ListReasoningEnginesSessionsResponse {
  /** Used to retain the full HTTP response. */
  sdkHttpResponse?: genaiTypes.HttpResponse;
  nextPageToken?: string;
  /** List of agent engine sessions. */
  sessions?: Session[];
}

/** Parameters for getting an operation with a session as a response. */
export declare interface GetAgentEngineSessionOperationParameters {
  /** The server-assigned name for the operation. */
  operationName: string;
  /** Used to override the default configuration. */
  config?: GetAgentEngineOperationConfig;
}

/** Config for updating agent engine session. */
export declare interface UpdateAgentEngineSessionConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The display name of the session. */
  displayName?: string;
  /** Session state which stores key conversation points. */
  sessionState?: Record<string, unknown>;
  /** Waits for the operation to complete before returning. */
  waitForCompletion?: boolean;
  /** Optional. Input only. The TTL for this resource.

      The expiration time is computed: now + TTL. */
  ttl?: string;
  /** Optional. Timestamp of when this resource is considered expired. This is *always* provided on output, regardless of what `expiration` was sent on input. */
  expireTime?: string;
  /** Optional. The labels with user-defined metadata to organize your Sessions. Label keys and values can be no longer than 64 characters (Unicode codepoints), can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. See https://goo.gl/xmQnxf for more information and examples of labels. */
  labels?: Record<string, string>;
  /** Optional. The user defined ID to use for session, which will become the final component of the session resource name. If not provided, Vertex AI will generate a value for this ID. This value may be up to 63 characters, and valid characters are `[a-z0-9-]`. The first character must be a letter, and the last character must be a letter or number. */
  sessionId?: string;
  /** The update mask to apply. For the `FieldMask` definition, see
      https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask. */
  updateMask?: string;
  /** User ID of the agent engine session to update. */
  userId?: string;
}

/** Parameters for updating agent engine sessions. */
export declare interface UpdateAgentEngineSessionRequestParameters {
  /** Name of the agent engine session to update. */
  name: string;
  config?: UpdateAgentEngineSessionConfig;
}

/** Actions are parts of events that are executed by the agent. */
export declare interface EventActions {
  /** Optional. Indicates that the event is updating an artifact. key is the filename, value is the version. */
  artifactDelta?: Record<string, number>;
  /** Optional. The agent is escalating to a higher level agent. */
  escalate?: boolean;
  /** Optional. Will only be set by a tool response indicating tool request euc. Struct key is the function call id since one function call response (from model) could correspond to multiple function calls. Struct value is the required auth config, which can be another struct. */
  requestedAuthConfigs?: Record<string, unknown>;
  /** Optional. If true, it won't call model to summarize function response. Only used for function_response event. */
  skipSummarization?: boolean;
  /** Optional. Indicates that the event is updating the state with the given delta. */
  stateDelta?: Record<string, unknown>;
  /** Optional. If set, the event transfers to the specified agent. */
  transferAgent?: string;
}

/** Metadata relating to a LLM response event. */
export declare interface EventMetadata {
  /** Optional. Metadata returned to client when grounding is enabled. */
  groundingMetadata?: genaiTypes.GroundingMetadata;
  /** Optional. The branch of the event. The format is like agent_1.agent_2.agent_3, where agent_1 is the parent of agent_2, and agent_2 is the parent of agent_3. Branch is used when multiple child agents shouldn't see their siblings' conversation history. */
  branch?: string;
  /** The custom metadata of the LlmResponse. */
  customMetadata?: Record<string, unknown>;
  /** Optional. Flag indicating that LLM was interrupted when generating the content. Usually it's due to user interruption during a bidi streaming. */
  interrupted?: boolean;
  /** Optional. Set of ids of the long running function calls. Agent client will know from this field about which function call is long running. Only valid for function call event. */
  longRunningToolIds?: string[];
  /** Optional. Indicates whether the text content is part of a unfinished text stream. Only used for streaming mode and when the content is plain text. */
  partial?: boolean;
  /** Optional. Indicates whether the response from the model is complete. Only used for streaming mode. */
  turnComplete?: boolean;
  /** Optional. Audio transcription of user input. */
  inputTranscription?: genaiTypes.Transcription;
  /** Optional. Audio transcription of model output. */
  outputTranscription?: genaiTypes.Transcription;
}

/** Config for appending agent engine session event. */
export declare interface AppendAgentEngineSessionEventConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The content of the session event. */
  content?: genaiTypes.Content;
  /** Actions are parts of events that are related to the session event. */
  actions?: EventActions;
  /** The error code of the session event. */
  errorCode?: string;
  /** The error message of the session event. */
  errorMessage?: string;
  /** Metadata relating to the session event. */
  eventMetadata?: EventMetadata;
  /** Weakly typed raw event data in proto struct format. */
  rawEvent?: Record<string, unknown>;
}

/** Parameters for appending agent engines. */
export declare interface AppendAgentEngineSessionEventRequestParameters {
  /** Name of the agent engine session. */
  name: string;
  /** Author of the agent engine session event. */
  author: string;
  /** Invocation ID of the agent engine. */
  invocationId: string;
  /** Timestamp indicating when the event was created. */
  timestamp: string;
  config?: AppendAgentEngineSessionEventConfig;
}

/** Response for appending agent engine session event. */
export class AppendAgentEngineSessionEventResponse {}

/** Config for listing agent engine session events. */
export declare interface ListAgentEngineSessionEventsConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  pageSize?: number;
  pageToken?: string;
  /** An expression for filtering the results of the request.
      For field names both snake_case and camelCase are supported. */
  filter?: string;
}

/** Parameters for listing agent engine session events. */
export declare interface ListAgentEngineSessionEventsRequestParameters {
  /** Name of the agent engine session. */
  name: string;
  config?: ListAgentEngineSessionEventsConfig;
}

/** A session event. */
export declare interface SessionEvent {
  /** Optional. Content of the event provided by the author. */
  content?: genaiTypes.Content;
  /** Optional. Actions executed by the agent. */
  actions?: EventActions;
  /** Required. The name of the agent that sent the event, or user. */
  author?: string;
  /** Optional. Error code if the response is an error. Code varies by model. */
  errorCode?: string;
  /** Optional. Error message if the response is an error. */
  errorMessage?: string;
  /** Optional. Metadata relating to this event. */
  eventMetadata?: EventMetadata;
  /** Required. The invocation id of the event, multiple events can have the same invocation id. */
  invocationId?: string;
  /** Identifier. The resource name of the event. Format:`projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}/sessions/{session}/events/{event}`. */
  name?: string;
  /** Required. Timestamp when the event was created on client side. */
  timestamp?: string;
  /** Optional. Weakly typed raw event data in proto struct format. */
  rawEvent?: Record<string, unknown>;
}

/** Response for listing agent engine session events. */
export class ListAgentEngineSessionEventsResponse {
  /** Used to retain the full HTTP response. */
  sdkHttpResponse?: genaiTypes.HttpResponse;
  nextPageToken?: string;
  /** List of session events. */
  sessionEvents?: SessionEvent[];
}

/** Config for getting a skill. */
export declare interface GetSkillConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for GetSkillRequest. */
export declare interface GetSkillRequestParameters {
  /** The resource name of the Skill to retrieve. Format: projects/{project}/locations/{location}/skills/{skill} */
  name: string;
  config?: GetSkillConfig;
}

/** Represents a Skill resource.

Patches the type from the discovery document. */
export declare interface Skill {
  /** Required. Provides the zipped filesystem of the Skill. This should contain the `SKILL.md` file at the root of the zip and optional directories for scripts, references, and assets. Directory should align with the directory structure specified at https://agentskills.io/specification#directory-structure. */
  zippedFilesystem?: string;
  /** Output only. The state of the Skill. */
  state?: SkillState;
  /** Identifier. The resource name of the Skill. Format: `projects/{project}/locations/{location}/skills/{skill}` */
  name?: string;
  /** Output only. Timestamp when this Skill was created. */
  createTime?: string;
  /** Output only. Timestamp when this Skill was most recently updated. */
  updateTime?: string;
  /** Required. Provides the display name of the Skill. This should align with `name` in the `SKILL.md` file. */
  displayName?: string;
  /** Required. Describes the Skill. Should describe both what the skill does and when to use it. Should include specific keywords that help agents identify relevant tasks. This should align with `description` in the `SKILL.md` file. */
  description?: string;
  /** Optional. Specifies the license of the Skill. This should be an SPDX license identifier (e.g., "MIT", "Apache-2.0"). See https://spdx.org/licenses/. This should align with `license` in the `SKILL.md` file. */
  license?: string;
  /** Optional. Specifies the compatibility of the Skill. Indicates environment requirements (intended product, system packages, network access, etc.). This should align with `compatibility` in the `SKILL.md` file. */
  compatibility?: string;
  /** The labels with user-defined metadata to organize Skills. */
  labels?: Record<string, string>;
  /** Output only. The SHA256 checksum of the zipped filesystem. */
  sha256?: string;
  /** Output only. The source of the Skill. */
  skillSource?: SkillSource;
}

/** Config for retrieving skills. */
export declare interface RetrieveSkillsConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Optional. The maximum number of skills to return. The service may
      return fewer than this value. If unspecified, at most 10 skills will be
      returned. The maximum value is 100.
       */
  topK?: number;
}

/** Parameters for retrieving skills. */
export declare interface RetrieveSkillsRequestParameters {
  /** Required. The query to find matching skills. */
  query: string;
  config?: RetrieveSkillsConfig;
}

/** A retrieved skill from semantic search. */
export declare interface RetrievedSkill {
  /** The resource name of the skill. */
  skillName?: string;
  /** The description of the skill. */
  description?: string;
}

/** Response for retrieving skills. */
export class RetrieveSkillsResponse {
  /** List of retrieved skills ranked by similarity. */
  retrievedSkills?: RetrievedSkill[];
}

/** Config for creating a skill. */
export declare interface CreateSkillConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Whether to wait for the long running operation to complete. */
  waitForCompletion?: boolean;
  /** Optional. The local path to the directory containing the Skill to
      be zipped and uploaded.
       */
  localPath?: string;
  /** Optional. The zipped filesystem of the Skill. */
  zippedFilesystem?: unknown;
}

/** Parameters for creating a skill. */
export declare interface CreateSkillRequestParameters {
  /** Required. The display name of the Skill. */
  displayName: string;
  /** Required. The description of the Skill. */
  description: string;
  /** Required. The ID to use for the Skill, which will become the final
      component of the Skill's resource name.
       */
  skillId: string;
  config?: CreateSkillConfig;
}

/** Operation that has a skill as a response. */
export declare interface SkillOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
  /** The created Skill. */
  response?: Skill;
}

/** Config for updating a skill. */
export declare interface UpdateSkillConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Whether to wait for the long running operation to complete. */
  waitForCompletion?: boolean;
  /** Optional. The local path to the directory containing the Skill to
      be zipped and uploaded.
       */
  localPath?: string;
  /** Optional. The display name of the Skill. */
  displayName?: string;
  /** Optional. The description of the Skill. */
  description?: string;
  /** Optional. The zipped filesystem of the Skill. */
  zippedFilesystem?: unknown;
  /** Optional. The update mask to apply. */
  updateMask?: string;
}

/** Parameters for updating a skill. */
export declare interface UpdateSkillRequestParameters {
  /** Required. The resource name of the Skill to update. */
  name: string;
  config?: UpdateSkillConfig;
}

/** Config for listing skills. */
export declare interface ListSkillsConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal to cancel the request. */
  abortSignal?: AbortSignal;
  pageSize?: number;
  pageToken?: string;
  /** Optional. The standard list filter. */
  filter?: string;
}

/** Parameters for listing skills. */
export declare interface ListSkillsRequestParameters {
  config?: ListSkillsConfig;
}

/** Response for listing skills. */
export class ListSkillsResponse {
  /** Used to retain the full HTTP response. */
  sdkHttpResponse?: genaiTypes.HttpResponse;
  nextPageToken?: string;
  /** List of Skills. */
  skills?: Skill[];
}

/** Config for deleting a skill. */
export declare interface DeleteSkillConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal to cancel the request. */
  abortSignal?: AbortSignal;
  /** Whether to wait for the long running operation to complete. */
  waitForCompletion?: boolean;
}

/** Parameters for deleting a skill. */
export declare interface DeleteSkillRequestParameters {
  /** Required. The resource name of the Skill to delete. */
  name: string;
  config?: DeleteSkillConfig;
}

/** Operation for deleting a skill. */
export declare interface DeleteSkillOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

export declare interface GetSkillOperationConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal to cancel the request. */
  abortSignal?: AbortSignal;
}

/** Parameters for getting an operation. */
export declare interface GetSkillOperationParameters {
  /** The server-assigned name for the operation. */
  operationName: string;
  /** Used to override the default configuration. */
  config?: GetSkillOperationConfig;
}

/** Configuration for getting a Skill Revision. */
export declare interface GetSkillRevisionConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal to cancel the request. */
  abortSignal?: AbortSignal;
}

/** Parameters for getting a Skill Revision. */
export declare interface GetSkillRevisionRequestParameters {
  /** The resource name of the Skill Revision to retrieve. Format: projects/{project}/locations/{location}/skills/{skill}/revisions/{revision} */
  name: string;
  config?: GetSkillRevisionConfig;
}

/** A single revision of a Skill. */
export declare interface SkillRevision {
  /** Output only. The state of the Skill Revision. */
  state?: SkillRevisionState;
  /** Identifier. The resource name of the Skill Revision. Format: `projects/{project}/locations/{location}/skills/{skill}/revisions/{revision}` */
  name?: string;
  /** Output only. Timestamp when this Skill Revision was created. */
  createTime?: string;
  /** Output only. The state of the Skill at this revision. */
  skill?: Skill;
}

/** Configuration for listing Skill Revisions. */
export declare interface ListSkillRevisionsConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal to cancel the request. */
  abortSignal?: AbortSignal;
  pageSize?: number;
  pageToken?: string;
}

/** Parameters for ListSkillRevisionsRequest. */
export declare interface ListSkillRevisionsRequestParameters {
  /** Required. The name of the Skill to list revisions for. */
  name: string;
  config?: ListSkillRevisionsConfig;
}

/** Response for listing Skill Revisions. */
export class ListSkillRevisionsResponse {
  /** Used to retain the full HTTP response. */
  sdkHttpResponse?: genaiTypes.HttpResponse;
  nextPageToken?: string;
  /** List of Skill Revisions. */
  skillRevisions?: SkillRevision[];
}

/** Single source entry for the grounding checking. */
export declare interface SchemaPredictParamsGroundingConfigSourceEntry {
  /** The uri of the Vertex AI Search data source. Deprecated. Use vertex_ai_search_datastore instead. */
  enterpriseDatastore?: string;
  /** The grounding text passed inline with the Predict API. It can support up to 1 million bytes. */
  inlineContext?: string;
  /** The type of the grounding checking source. */
  type?: 'UNSPECIFIED' | 'WEB' | 'ENTERPRISE' | 'VERTEX_AI_SEARCH' | 'INLINE';
  /** The uri of the Vertex AI Search data source. */
  vertexAiSearchDatastore?: string;
}

/** The configuration for grounding checking. */
export declare interface SchemaPredictParamsGroundingConfig {
  /** If set, skip finding claim attributions (i.e not generate grounding citation). */
  disableAttribution?: boolean;
  /** The sources for the grounding checking. */
  sources?: SchemaPredictParamsGroundingConfigSourceEntry[];
}

/** Represents a prompt spec part list. */
export declare interface SchemaPromptSpecPartList {
  /** A list of elements that can be part of a prompt. */
  parts?: genaiTypes.Part[];
}

/** Represents a prompt instance variable. */
export declare interface SchemaPromptInstanceVariableValue {
  /** The parts of the variable value. */
  partList?: SchemaPromptSpecPartList;
}

/** A prompt instance's parameters set that contains a set of variable values. */
export declare interface SchemaPromptInstancePromptExecution {
  /** Maps variable names to their value. */
  arguments?: Record<string, SchemaPromptInstanceVariableValue>;
}

/** Represents a prompt message. */
export declare interface SchemaPromptSpecPromptMessage {
  /** Generation config. */
  generationConfig?: genaiTypes.GenerationConfig;
  /** Tool config. This config is shared for all tools provided in the request. */
  toolConfig?: genaiTypes.FunctionCallingConfig;
  /** A list of `Tools` the model may use to generate the next response. A `Tool` is a piece of code that enables the system to interact with external systems to perform an action, or set of actions, outside of knowledge and scope of the model. */
  tools?: genaiTypes.Tool[];
  /** Per request settings for blocking unsafe content. Enforced on GenerateContentResponse.candidates. */
  safetySettings?: genaiTypes.SafetySetting[];
  /** The content of the current conversation with the model. For single-turn queries, this is a single instance. For multi-turn queries, this is a repeated field that contains conversation history + latest request. */
  contents?: genaiTypes.Content[];
  /** The user provided system instructions for the model. Note: only text should be used in parts and content in each part will be in a separate paragraph. */
  systemInstruction?: genaiTypes.Content;
  variables?: Record<string, genaiTypes.Part>[];
  /** The model name. */
  model?: string;
}

/** Prompt variation that embeds preambles to prompt string. */
export declare interface SchemaPromptSpecMultimodalPrompt {
  /** The prompt message. */
  promptMessage?: SchemaPromptSpecPromptMessage;
}

/** A linked resource attached to the application by the user. */
export declare interface SchemaPromptSpecAppBuilderDataLinkedResource {
  /** A user-friendly name for the data source shown in the UI. */
  displayName?: string;
  /** The unique resource name of the data source. The format is determined by the 'type' field. For type "SAVED_PROMPT": projects/{project}/locations/{location}/datasets/{dataset} For type "AI_AGENT": projects/{project}/locations/{location}/agents/{agent} */
  name?: string;
  /** The type of the linked resource. e.g., "SAVED_PROMPT", "AI_AGENT" This string corresponds to the name of the LinkedResourceType enum member. See: google3/cloud/console/web/ai/platform/llm/prompts/build/services/specs_repository_service/linked_resources/linked_resource.ts */
  type?: string;
}

/** Defines data for an application builder. */
export declare interface SchemaPromptSpecAppBuilderData {
  /** Serialized state of the code repository. This string will typically contain a JSON representation of the UI's CodeRepositoryService state (files, folders, content, and any metadata). The UI is responsible for serialization and deserialization. */
  codeRepositoryState?: string;
  /** Optional. Framework used to build the application. */
  framework?: Framework;
  /** Linked resources attached to the application by the user. */
  linkedResources?: SchemaPromptSpecAppBuilderDataLinkedResource[];
}

/** Defines data for an interaction prompt. */
export declare interface SchemaPromptSpecInteractionData {
  /** Optional. Lists interaction IDs associated with the prompt. This maps 1:1 to PromptMessage.contents. If InteractionData is present, every prompt message has an interaction ID. */
  interactionIds?: string[];
}

/** Represents a structured prompt. */
export declare interface SchemaPromptSpecStructuredPrompt {
  /** Preamble: The context of the prompt. */
  context?: genaiTypes.Content;
  /** Data for app builder use case. */
  appBuilderData?: SchemaPromptSpecAppBuilderData;
  /** Preamble: A set of examples for expected model response. */
  examples?: SchemaPromptSpecPartList[];
  /** Preamble: For infill prompt, the prefix before expected model response. */
  infillPrefix?: string;
  /** Preamble: For infill prompt, the suffix after expected model response. */
  infillSuffix?: string;
  /** Preamble: The input prefixes before each example input. */
  inputPrefixes?: string[];
  /** Preamble: The output prefixes before each example output. */
  outputPrefixes?: string[];
  /** Preamble: The input test data for prediction. Each PartList in this field represents one text-only input set for a single model request. */
  predictionInputs?: SchemaPromptSpecPartList[];
  /** The prompt message. */
  promptMessage?: SchemaPromptSpecPromptMessage;
  /** Data for interaction use case. */
  interactionData?: SchemaPromptSpecInteractionData;
}

/** A pair of sentences used as reference in source and target languages. */
export declare interface SchemaPromptSpecReferenceSentencePair {
  /** Source sentence in the sentence pair. */
  sourceSentence?: string;
  /** Target sentence in the sentence pair. */
  targetSentence?: string;
}

/** A list of reference sentence pairs. */
export declare interface SchemaPromptSpecReferenceSentencePairList {
  /** Reference sentence pairs. */
  referenceSentencePairs?: SchemaPromptSpecReferenceSentencePair[];
}

export declare interface SchemaPromptSpecTranslationFileInputSource {
  /** The file's contents. */
  content?: string;
  /** The file's display name. */
  displayName?: string;
  /** The file's mime type. */
  mimeType?: string;
}

export declare interface SchemaPromptSpecTranslationGcsInputSource {
  /** Source data URI. For example, `gs://my_bucket/my_object`. */
  inputUri?: string;
}

export declare interface SchemaPromptSpecTranslationSentenceFileInput {
  /** Inlined file source. */
  fileInputSource?: SchemaPromptSpecTranslationFileInputSource;
  /** Cloud Storage file source. */
  gcsInputSource?: SchemaPromptSpecTranslationGcsInputSource;
}

/** The translation example that contains reference sentences from various sources. */
export declare interface SchemaPromptSpecTranslationExample {
  /** The reference sentences from inline text. */
  referenceSentencePairLists?: SchemaPromptSpecReferenceSentencePairList[];
  /** The reference sentences from file. */
  referenceSentencesFileInputs?: SchemaPromptSpecTranslationSentenceFileInput[];
}

/** Optional settings for translation prompt. */
export declare interface SchemaPromptSpecTranslationOption {
  /** How many shots to use. */
  numberOfShots?: number;
}

/** Prompt variation for Translation use case. */
export declare interface SchemaPromptSpecTranslationPrompt {
  /** The translation example. */
  example?: SchemaPromptSpecTranslationExample;
  /** The translation option. */
  option?: SchemaPromptSpecTranslationOption;
  /** The prompt message. */
  promptMessage?: SchemaPromptSpecPromptMessage;
  /** The source language code. */
  sourceLanguageCode?: string;
  /** The target language code. */
  targetLanguageCode?: string;
}

/** The A2 schema of a prompt. */
export declare interface SchemaPromptApiSchema {
  /** The Schema version that represents changes to the API behavior. */
  apiSchemaVersion?: string;
  /** A list of execution instances for constructing a ready-to-use prompt. */
  executions?: SchemaPromptInstancePromptExecution[];
  /** Multimodal prompt which embeds preambles to prompt string. */
  multimodalPrompt?: SchemaPromptSpecMultimodalPrompt;
  /** The prompt variation that stores preambles in separate fields. */
  structuredPrompt?: SchemaPromptSpecStructuredPrompt;
  /** The prompt variation for Translation use case. */
  translationPrompt?: SchemaPromptSpecTranslationPrompt;
}

/** Represents the text prompt dataset metadata. */
export declare interface SchemaTextPromptDatasetMetadata {
  /** Number of candidates. */
  candidateCount?: string;
  /** The Google Cloud Storage URI that stores the prompt data. */
  gcsUri?: string;
  /** Grounding checking configuration. */
  groundingConfig?: SchemaPredictParamsGroundingConfig;
  /** Whether the prompt dataset has prompt variable. */
  hasPromptVariable?: boolean;
  /** Whether or not the user has enabled logit probabilities in the model parameters. */
  logprobs?: boolean;
  /** Value of the maximum number of tokens generated set when the dataset was saved. */
  maxOutputTokens?: string;
  /** User-created prompt note. Note size limit is 2KB. */
  note?: string;
  /** The API schema of the prompt to support both UI and SDK usages. */
  promptApiSchema?: SchemaPromptApiSchema;
  /** Type of the prompt dataset. */
  promptType?: string;
  /** Seeding enables model to return a deterministic response on a best effort basis. Determinism isn't guaranteed. This field determines whether or not seeding is enabled. */
  seedEnabled?: boolean;
  /** The actual value of the seed. */
  seedValue?: string;
  /** Customized stop sequences. */
  stopSequences?: string[];
  /** The content of the prompt dataset system instruction. */
  systemInstruction?: string;
  /** The Google Cloud Storage URI that stores the system instruction, starting with gs://. */
  systemInstructionGcsUri?: string;
  /** Temperature value used for sampling set when the dataset was saved. This value is used to tune the degree of randomness. */
  temperature?: number;
  /** The content of the prompt dataset. */
  text?: string;
  /** Top K value set when the dataset was saved. This value determines how many candidates with highest probability from the vocab would be selected for each decoding step. */
  topK?: string;
  /** Top P value set when the dataset was saved. Given topK tokens for decoding, top candidates will be selected until the sum of their probabilities is topP. */
  topP?: number;
}

/** Config for creating a dataset resource to store prompts. */
export declare interface CreateDatasetConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for creating a dataset resource to store prompts. */
export declare interface CreateDatasetParameters {
  name?: string;
  displayName?: string;
  metadataSchemaUri?: string;
  metadata?: SchemaTextPromptDatasetMetadata;
  description?: string;
  encryptionSpec?: genaiTypes.EncryptionSpec;
  modelReference?: string;
  config?: CreateDatasetConfig;
}

/** Represents the create dataset operation. */
export declare interface DatasetOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
  /** The result of the dataset operation. */
  response?: Record<string, unknown>;
}

/** Config for creating a dataset version resource to store prompts. */
export declare interface CreateDatasetVersionConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Represents the create dataset version parameters. */
export declare interface CreateDatasetVersionParameters {
  datasetName?: string;
  metadata?: SchemaTextPromptDatasetMetadata;
  modelReference?: string;
  parent?: string;
  displayName?: string;
  config?: CreateDatasetVersionConfig;
}

/** Parameters for getting a dataset resource to store prompts. */
export declare interface GetDatasetParameters {
  name?: string;
  config?: VertexBaseConfig;
}

/** A SavedQuery is a view of the dataset. It references a subset of annotations by problem type and filters. */
export declare interface SavedQuery {
  /** Output only. Filters on the Annotations in the dataset. */
  annotationFilter?: string;
  /** Output only. Number of AnnotationSpecs in the context of the SavedQuery. */
  annotationSpecCount?: number;
  /** Output only. Timestamp when this SavedQuery was created. */
  createTime?: string;
  /** Required. The user-defined name of the SavedQuery. The name can be up to 128 characters long and can consist of any UTF-8 characters. */
  displayName?: string;
  /** Used to perform a consistent read-modify-write update. If not set, a blind "overwrite" update happens. */
  etag?: string;
  /** Some additional information about the SavedQuery. */
  metadata?: unknown;
  /** Output only. Resource name of the SavedQuery. */
  name?: string;
  /** Required. Problem type of the SavedQuery. Allowed values: * IMAGE_CLASSIFICATION_SINGLE_LABEL * IMAGE_CLASSIFICATION_MULTI_LABEL * IMAGE_BOUNDING_POLY * IMAGE_BOUNDING_BOX * TEXT_CLASSIFICATION_SINGLE_LABEL * TEXT_CLASSIFICATION_MULTI_LABEL * TEXT_EXTRACTION * TEXT_SENTIMENT * VIDEO_CLASSIFICATION * VIDEO_OBJECT_TRACKING */
  problemType?: string;
  /** Output only. If the Annotations belonging to the SavedQuery can be used for AutoML training. */
  supportAutomlTraining?: boolean;
  /** Output only. Timestamp when SavedQuery was last updated. */
  updateTime?: string;
}

/** Represents a dataset resource to store prompts. */
export declare interface Dataset {
  /** Required. Additional information about the Dataset. */
  metadata?: SchemaTextPromptDatasetMetadata;
  /** Customer-managed encryption key spec for a Dataset. If set, this Dataset and all sub-resources of this Dataset will be secured by this key. */
  encryptionSpec?: genaiTypes.EncryptionSpec;
  /** Output only. Timestamp when this Dataset was created. */
  createTime?: string;
  /** Output only. The number of DataItems in this Dataset. Only apply for non-structured Dataset. */
  dataItemCount?: string;
  /** The description of the Dataset. */
  description?: string;
  /** Required. The user-defined name of the Dataset. The name can be up to 128 characters long and can consist of any UTF-8 characters. */
  displayName?: string;
  /** Used to perform consistent read-modify-write updates. If not set, a blind "overwrite" update happens. */
  etag?: string;
  /** The labels with user-defined metadata to organize your Datasets. Label keys and values can be no longer than 64 characters (Unicode codepoints), can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. No more than 64 user labels can be associated with one Dataset (System labels are excluded). See https://goo.gl/xmQnxf for more information and examples of labels. System reserved label keys are prefixed with "aiplatform.googleapis.com/" and are immutable. Following system labels exist for each Dataset: * "aiplatform.googleapis.com/dataset_metadata_schema": output only, its value is the metadata_schema's title. */
  labels?: Record<string, string>;
  /** Output only. The resource name of the Artifact that was created in MetadataStore when creating the Dataset. The Artifact resource name pattern is `projects/{project}/locations/{location}/metadataStores/{metadata_store}/artifacts/{artifact}`. */
  metadataArtifact?: string;
  /** Required. Points to a YAML file stored on Google Cloud Storage describing additional information about the Dataset. The schema is defined as an OpenAPI 3.0.2 Schema Object. The schema files that can be used here are found in gs://google-cloud-aiplatform/schema/dataset/metadata/. */
  metadataSchemaUri?: string;
  /** Optional. Reference to the public base model last used by the dataset. Only set for prompt datasets. */
  modelReference?: string;
  /** Output only. Identifier. The resource name of the Dataset. Format: `projects/{project}/locations/{location}/datasets/{dataset}` */
  name?: string;
  /** Output only. Reserved for future use. */
  satisfiesPzi?: boolean;
  /** Output only. Reserved for future use. */
  satisfiesPzs?: boolean;
  /** All SavedQueries belong to the Dataset will be returned in List/Get Dataset response. The annotation_specs field will not be populated except for UI cases which will only use annotation_spec_count. In CreateDataset request, a SavedQuery is created together if this field is set, up to one SavedQuery can be set in CreateDatasetRequest. The SavedQuery should not contain any AnnotationSpec. */
  savedQueries?: SavedQuery[];
  /** Output only. Timestamp when this Dataset was last updated. */
  updateTime?: string;
}

/** Parameters for getting a dataset resource to store prompts. */
export declare interface GetDatasetVersionParameters {
  datasetId?: string;
  datasetVersionId?: string;
  config?: VertexBaseConfig;
}

/** Represents a dataset version resource to store prompts. */
export declare interface DatasetVersion {
  /** Required. Output only. Additional information about the DatasetVersion. */
  metadata?: SchemaTextPromptDatasetMetadata;
  /** Output only. Name of the associated BigQuery dataset. */
  bigQueryDatasetName?: string;
  /** Output only. Timestamp when this DatasetVersion was created. */
  createTime?: string;
  /** The user-defined name of the DatasetVersion. The name can be up to 128 characters long and can consist of any UTF-8 characters. */
  displayName?: string;
  /** Used to perform consistent read-modify-write updates. If not set, a blind "overwrite" update happens. */
  etag?: string;
  /** Output only. Reference to the public base model last used by the dataset version. Only set for prompt dataset versions. */
  modelReference?: string;
  /** Output only. Identifier. The resource name of the DatasetVersion. Format: `projects/{project}/locations/{location}/datasets/{dataset}/datasetVersions/{dataset_version}` */
  name?: string;
  /** Output only. Reserved for future use. */
  satisfiesPzi?: boolean;
  /** Output only. Reserved for future use. */
  satisfiesPzs?: boolean;
  /** Output only. Timestamp when this DatasetVersion was last updated. */
  updateTime?: string;
}

/** Config for getting a dataset version operation. */
export declare interface GetDatasetOperationConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Parameters for getting a dataset operation. */
export declare interface GetDatasetOperationParameters {
  datasetId?: string;
  operationId?: string;
  config?: GetDatasetOperationConfig;
}

/** Config for listing prompt datasets and dataset versions. */
export declare interface ListPromptsConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  pageSize?: number;
  pageToken?: string;
  /** An expression for filtering the results of the request.
      For field names both snake_case and camelCase are supported. */
  filter?: string;
}

/** Parameters for listing prompt datasets. */
export declare interface ListDatasetsRequestParameters {
  config?: ListPromptsConfig;
}

/** Response for listing prompt datasets. */
export class ListDatasetsResponse {
  /** Used to retain the full HTTP response. */
  sdkHttpResponse?: genaiTypes.HttpResponse;
  nextPageToken?: string;
  /** List of datasets for the project.
   */
  datasets?: Dataset[];
}

/** Parameters for listing dataset versions. */
export declare interface ListDatasetVersionsRequestParameters {
  readMask?: string;
  datasetId?: string;
  config?: ListPromptsConfig;
}

/** Response for listing prompt datasets. */
export class ListDatasetVersionsResponse {
  /** Used to retain the full HTTP response. */
  sdkHttpResponse?: genaiTypes.HttpResponse;
  nextPageToken?: string;
  /** List of datasets for the project.
   */
  datasetVersions?: DatasetVersion[];
}

/** Config for deleting a prompt. */
export declare interface DeletePromptConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Timeout for the delete prompt operation in seconds. Defaults to 90. */
  timeout?: number;
  /** Maximum interval between polling requests in seconds. Defaults to 60. */
  maxWaitTime?: number;
}

/** Parameters for deleting a prompt dataset. */
export declare interface DeleteDatasetRequestParameters {
  /** ID of the prompt dataset to be deleted. */
  promptId: string;
  config?: DeletePromptConfig;
}

/** Operation for deleting prompts. */
export declare interface DeletePromptOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

/** Parameters for deleting a prompt version. */
export declare interface DeletePromptVersionRequestParameters {
  /** ID of the prompt to be deleted. */
  promptId: string;
  /** ID of the prompt version to be deleted within the provided prompt_id. */
  versionId: string;
  config?: DeletePromptConfig;
}

/** Operation for deleting prompt versions. */
export declare interface DeletePromptVersionOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

/** Config for restoring a prompt version. */
export declare interface RestoreVersionConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Timeout for the restore prompt version operation in seconds. Defaults to 90. */
  timeout?: number;
  /** Maximum interval between polling requests in seconds. Defaults to 60. */
  maxWaitTime?: number;
}

/** Parameters for restoring a prompt version. */
export declare interface RestoreVersionRequestParameters {
  /** ID of the prompt dataset to be restored. */
  datasetId: string;
  /** ID of the prompt dataset version to be restored. */
  versionId: string;
  config?: RestoreVersionConfig;
}

/** Represents the restore version operation. */
export declare interface RestoreVersionOperation {
  /** The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`. */
  name?: string;
  /** Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any. */
  metadata?: Record<string, unknown>;
  /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
  done?: boolean;
  /** The error result of the operation in case of failure or cancellation. */
  error?: Record<string, unknown>;
}

/** Config for creating a dataset resource to store prompts. */
export declare interface UpdatePromptConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The updated display name for the prompt. */
  promptDisplayName?: string;
  /** The updated display name for the prompt version. If not set, a default name with a timestamp will be used. */
  versionDisplayName?: string;
  /** The timeout for the update_dataset_resource request in seconds. If not set, the default timeout is 90 seconds. */
  timeout?: number;
  /** Customer-managed encryption key spec for a prompt dataset. If set, this prompt dataset and all sub-resources of this prompt dataset will be secured by this key. */
  encryptionSpec?: genaiTypes.EncryptionSpec;
  /** The maximum interval between polling requests in seconds. If not set, the default interval is 60 seconds. */
  maxWaitTime?: number;
}

/** Parameters for creating a dataset resource to store prompts. */
export declare interface UpdateDatasetParameters {
  name?: string;
  datasetId?: string;
  displayName?: string;
  metadata?: SchemaTextPromptDatasetMetadata;
  description?: string;
  encryptionSpec?: genaiTypes.EncryptionSpec;
  modelReference?: string;
  config?: UpdatePromptConfig;
}

/** An agent engine instance. */
export declare interface AgentEngine {
  /** The underlying API client. */
  apiClient?: unknown;
  /** The underlying API client for asynchronous operations. */
  apiAsyncClient?: unknown;
  /** The underlying API resource (i.e. ReasoningEngine). */
  apiResource?: ReasoningEngine;
}

/** Config for agent engine methods. */
export declare interface AgentEngineConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The GCS bucket to use for staging the artifacts needed.

      It must be a valid GCS bucket name, e.g. "gs://bucket-name". It is
      required if `agent_engine` is specified. */
  stagingBucket?: string;
  /** The set of PyPI dependencies needed.

      It can either be the path to a single file (requirements.txt), or an
      ordered list of strings corresponding to each line of the requirements
      file. */
  requirements?: unknown;
  /** The user-defined name of the Agent Engine.

      The name can be up to 128 characters long and can comprise any UTF-8
      character. */
  displayName?: string;
  /** The description of the Agent Engine. */
  description?: string;
  /** The GCS bucket directory under `staging_bucket` to use for staging
      the artifacts needed. */
  gcsDirName?: string;
  /** The set of extra user-provided packages (if any). */
  extraPackages?: string[];
  /** The environment variables to be set when running the Agent Engine.

      If it is a dictionary, the keys are the environment variable names, and
      the values are the corresponding values. */
  envVars?: unknown;
  /** The service account to be used for the Agent Engine.

      If not specified, the default Reasoning Engine P6SA service agent will be used. */
  serviceAccount?: string;
  /** The identity type to use for the Agent Engine. */
  identityType?: IdentityType;
  /** The context spec to be used for the Agent Engine. */
  contextSpec?: ReasoningEngineContextSpec;
  /** The PSC interface config for PSC-I to be used for the Agent Engine. */
  pscInterfaceConfig?: PscInterfaceConfig;
  /** The minimum number of instances to run for the Agent Engine.
      Defaults to 1. Range: [0, 10].
       */
  minInstances?: number;
  /** The maximum number of instances to run for the Agent Engine.
      Defaults to 100. Range: [1, 1000].
      If VPC-SC or PSC-I is enabled, the acceptable range is [1, 100].
       */
  maxInstances?: number;
  /** The resource limits to be applied to the Agent Engine.
      Required keys: 'cpu' and 'memory'.
      Supported values for 'cpu': '1', '2', '4', '6', '8'.
      Supported values for 'memory': '1Gi', '2Gi', ..., '32Gi'.
       */
  resourceLimits?: Record<string, string>;
  /** The container concurrency to be used for the Agent Engine.
      Recommended value: 2 * cpu + 1. Defaults to 9.
       */
  containerConcurrency?: number;
  /** The encryption spec to be used for the Agent Engine. */
  encryptionSpec?: genaiTypes.EncryptionSpec;
  /** The labels to be used for the Agent Engine. */
  labels?: Record<string, string>;
  /** The class methods to be used for the Agent Engine.
      If specified, they'll override the class methods that are autogenerated by
      default. By default, methods are generated by inspecting the agent object
      and generating a corresponding method for each method defined on the
      agent class.
       */
  classMethods?: Record<string, unknown>[];
  /** The user-provided paths to the source packages (if any).
      If specified, the files in the source packages will be packed into a
      a tarball file, uploaded to Agent Engine's API, and deployed to the
      Agent Engine.
      The following fields will be ignored:
        - agent
        - extra_packages
        - staging_bucket
        - requirements
      The following fields will be used to install and use the agent from the
      source packages:
        - entrypoint_module (required)
        - entrypoint_object (required)
        - requirements_file (optional)
        - class_methods     (required)
       */
  sourcePackages?: string[];
  /** Specifies the configuration for fetching source code from a Git repository that is managed by Developer Connect. This includes the repository, revision, and directory to use. */
  developerConnectSource?: ReasoningEngineSpecSourceCodeSpecDeveloperConnectConfig;
  /** The entrypoint module to be used for the Agent Engine
      This field only used when source_packages is specified. */
  entrypointModule?: string;
  /** The entrypoint object to be used for the Agent Engine.
      This field only used when source_packages is specified. */
  entrypointObject?: string;
  /** The user-provided path to the requirements file (if any).
      This field is only used when source_packages is specified.
      If not specified, agent engine will find and use the `requirements.txt` in
      the source package.
       */
  requirementsFile?: string;
  /** The agent framework to be used for the Agent Engine.
      The OSS agent framework used to develop the agent.
      Currently supported values: "google-adk", "langchain", "langgraph",
      "ag2", "llama-index", "custom".
      If not specified:
      - If `agent` is specified, the agent framework will be auto-detected.
      - If `source_packages` is specified, the agent framework will
        default to "custom". */
  agentFramework?:
    | 'google-adk'
    | 'langchain'
    | 'langgraph'
    | 'ag2'
    | 'llama-index'
    | 'custom';
  /** The Python version to be used for the Agent Engine.
      If not specified, it will use the current Python version of the environment.
      Supported versions: "3.10", "3.11", "3.12", "3.13", "3.14".
       */
  pythonVersion?: '3.10' | '3.11' | '3.12' | '3.13' | '3.14';
  /** The build options for the Agent Engine.
      The following keys are supported:
      - installation_scripts:
          Optional. The paths to the installation scripts to be
          executed in the Docker image.
          The scripts must be located in the `installation_scripts`
          subdirectory and the path must be added to `extra_packages`.
       */
  buildOptions?: Record<string, string[]>;
  /** The image spec for the Agent Engine. */
  imageSpec?: ReasoningEngineSpecSourceCodeSpecImageSpec;
  /** The agent config source for the Agent Engine. */
  agentConfigSource?: ReasoningEngineSpecSourceCodeSpecAgentConfigSource;
  /** The container spec for the Agent Engine. */
  containerSpec?: ReasoningEngineSpecContainerSpec;
  /** Agent Gateway configuration for a Reasoning Engine deployment. */
  agentGatewayConfig?: ReasoningEngineSpecDeploymentSpecAgentGatewayConfig;
  /** Optional. Specifies the configuration for keep-alive probe.
      Contains configuration on a specified endpoint that a deployment host
      should use to keep the container alive based on the probe settings. */
  keepAliveProbe?: KeepAliveProbe;
}

/** Config for checking a query job on an agent engine. */
export declare interface RunQueryJobAgentEngineConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The query to send to the agent engine. */
  query?: string;
  /** The GCS URI to use for the output.
      If it is a file, the system use this file to store the response.
      If it represents a directory, the system automatically generate a file
      for the response.
      In both cases, the input query will be stored in the same directory under
      the same file name prefix as the output file. */
  outputGcsUri?: string;
}

/** Result of running a query job. */
export declare interface RunQueryJobResult {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Name of the agent engine operation to later check for status. */
  jobName?: string;
  /** The GCS URI of the input file. */
  inputGcsUri?: string;
  /** The GCS URI of the output file. */
  outputGcsUri?: string;
}

/** Config for canceling async querying agent engines. */
export declare interface CancelQueryJobAgentEngineConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Name of the longrunning operation returned from run_query_job. */
  operationName?: string;
}

/** Result of canceling a query job. */
export declare interface CancelQueryJobResult {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Config for async querying agent engines. */
export declare interface CheckQueryJobAgentEngineConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Whether to retrieve the results of the query job. */
  retrieveResult?: boolean;
}

/** Result of checking a query job. */
export declare interface CheckQueryJobResult {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** Name of the agent engine operation. */
  operationName?: string;
  /** The GCS URI of the output file. */
  outputGcsUri?: string;
  /** Status of the operation. */
  status?: string;
  /** JSON result of the operation. */
  result?: string;
}

/** Response from LRO. */
export class CheckQueryJobResponse {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The GCS URI of the output file. */
  outputGcsUri?: string;
}

/** Represents a prompt. */
export declare interface Prompt {
  promptData?: PromptData;
}

export type PromptData = SchemaPromptSpecPromptMessage;
/* eslint-disable @typescript-eslint/no-explicit-any */
export type VertexBaseConfig = any;
export type ParsedResponseUnion = any;

/** Config for creating a prompt. */
export declare interface CreatePromptConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The display name for the prompt. If not set, a default name with a timestamp will be used. */
  promptDisplayName?: string;
  /** The timeout for the create_version request in seconds. If not set, the default timeout is 90 seconds. */
  timeout?: number;
  /** Customer-managed encryption key spec for a prompt dataset. If set, this prompt dataset and all sub-resources of this prompt dataset will be secured by this key. */
  encryptionSpec?: genaiTypes.EncryptionSpec;
  /** The display name for the prompt version. If not set, a default name with a timestamp will be used. */
  versionDisplayName?: string;
  /** The maximum interval between requests in seconds. If not set, the default interval is 60 seconds. */
  maxWaitTime?: number;
}

/** Config for creating a prompt version. */
export declare interface CreatePromptVersionConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
  /** The display name for the prompt version. If not set, a default name with a timestamp will be used. */
  versionDisplayName?: string;
  /** The timeout for the create_version request in seconds. If not set, the default timeout is 90 seconds. */
  timeout?: number;
  /** The display name for the prompt. If not set, a default name with a timestamp will be used. */
  promptDisplayName?: string;
  /** Customer-managed encryption key spec for a prompt dataset. If set, this prompt dataset and all sub-resources of this prompt dataset will be secured by this key. */
  encryptionSpec?: genaiTypes.EncryptionSpec;
  /** The maximum interval between requests in seconds. If not set, the default interval is 60 seconds. */
  maxWaitTime?: number;
}

/** Config for getting a prompt. */
export declare interface GetPromptConfig {
  /** Used to override HTTP request options. */
  httpOptions?: genaiTypes.HttpOptions;
  /** Abort signal which can be used to cancel the request.

  NOTE: AbortSignal is a client-only operation. Using it to cancel an
  operation will not cancel the request in the service. You will still
  be charged usage for any applicable operations.
       */
  abortSignal?: AbortSignal;
}

/** Reference to a prompt. */
export declare interface PromptRef {
  promptId?: string;
  model?: string;
}

/** Reference to a prompt version. */
export declare interface PromptVersionRef {
  promptId?: string;
  versionId?: string;
  model?: string;
}

/** The response for listing Memory Banks. */
export class ListMemoryBanksResponse {
  /** The list of Memory Banks. */
  memoryBanks?: MemoryBank[];
}