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';

import * as agentEnginesTypes from './agent_engines.js';

/** 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',
}

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

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

/** 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;
}

/** The PSC interface config. */
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;
}

/** 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, 10]. */
  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[];
}

/** 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.9, 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).

It is 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. Support version includes 3.9, 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;
}

/** 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;
}

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

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

/** A memory topic identifier. This will be used to label a Memory and to restrict which topics are eligible for generation or retrieval. */
export declare interface MemoryTopicId {
  /** Optional. The custom memory topic label. */
  customMemoryTopicLabel?: string;
  /** Optional. The managed memory topic. */
  managedMemoryTopic?: ManagedTopicEnum;
}

/** A memory generated by the operation. */
export declare interface MemoryBankCustomizationConfigGenerateMemoriesExampleGeneratedMemory {
  /** Required. The fact to generate a memory from. */
  fact?: string;
  /** Optional. 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. 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. The label of the topic. */
  label?: string;
  /** Required. 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. 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;
}

/** Configuration for organizing memories for a particular scope. */
export declare interface MemoryBankCustomizationConfig {
  /** Optional. If true, then 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. Examples of how to generate memories for a particular scope. */
  generateMemoriesExamples?: MemoryBankCustomizationConfigGenerateMemoriesExample[];
  /** Optional. 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. 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[];
}

/** Configuration for how to generate memories. */
export declare interface ReasoningEngineContextSpecMemoryBankConfigGenerationConfig {
  /** Required. The model used to generate memories. Format: `projects/{project}/locations/{location}/publishers/google/models/{model}`. */
  model?: string;
}

/** 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;
}

/** 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;
}

/** The configuration for agent engine sub-resources to 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.9", "3.10", "3.11", "3.12", "3.13", "3.14".
       */
  pythonVersion?: '3.9' | '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[]>;
}

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

/** 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;
}

/** 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.9", "3.10", "3.11", "3.12", "3.13", "3.14".
       */
  pythonVersion?: '3.9' | '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 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 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>;
}

/** 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>;
  /** 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;
}

/** 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;
}

/** 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;
}

/** 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[];
}

/** 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.9", "3.10", "3.11", "3.12", "3.13", "3.14".
       */
  pythonVersion?: '3.9' | '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;
}

/** Configuration for Model Armor. Model Armor is a Google Cloud service that provides safety and security filtering for prompts and responses. It helps protect your AI applications from risks such as harmful content, sensitive data leakage, and prompt injection attacks. */
export declare interface ModelArmorConfig {
  /** Optional. The resource name of the Model Armor template to use for prompt screening. A Model Armor template is a set of customized filters and thresholds that define how Model Armor screens content. If specified, Model Armor will use this template to check the user's prompt for safety and security risks before it is sent to the model. The name must be in the format `projects/{project}/locations/{location}/templates/{template}`. */
  promptTemplateName?: string;
  /** Optional. The resource name of the Model Armor template to use for response screening. A Model Armor template is a set of customized filters and thresholds that define how Model Armor screens content. If specified, Model Armor will use this template to check the model's response for safety and security risks before it is returned to the user. The name must be in the format `projects/{project}/locations/{location}/templates/{template}`. */
  responseTemplateName?: string;
}

/** 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[];
}