@google/genai 0.7.0 → 0.8.0

package/dist/web/web.d.ts

@@ -1,5 +1,28 @@
 import { GoogleAuthOptions } from 'google-auth-library';
 
+/** Marks the end of user activity.
+
+ This can only be sent if automatic (i.e. server-side) activity detection is
+ disabled.
+ */
+export declare interface ActivityEnd {
+}
+
+/** The different ways of handling user activity. */
+export declare enum ActivityHandling {
+    ACTIVITY_HANDLING_UNSPECIFIED = "ACTIVITY_HANDLING_UNSPECIFIED",
+    START_OF_ACTIVITY_INTERRUPTS = "START_OF_ACTIVITY_INTERRUPTS",
+    NO_INTERRUPTION = "NO_INTERRUPTION"
+}
+
+/** Marks the start of user activity.
+
+ This can only be sent if automatic (i.e. server-side) activity detection is
+ disabled.
+ */
+export declare interface ActivityStart {
+}
+
 /**
  * The ApiClient class is used to send requests to the Gemini API or Vertex AI
  * endpoints.
@@ -20,6 +43,7 @@ declare class ApiClient {
     getWebsocketBaseUrl(): string;
     setBaseUrl(url: string): void;
     private constructUrl;
+    private shouldPrependVertexProjectPath;
     request(request: HttpRequest): Promise<HttpResponse>;
     private patchHttpOptions;
     requestStream(request: HttpRequest): Promise<any>;
@@ -97,6 +121,10 @@ declare interface ApiClientInitOptions {
     userAgentExtra?: string;
 }
 
+/** The audio transcription configuration in Setup. */
+export declare interface AudioTranscriptionConfig {
+}
+
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -114,6 +142,25 @@ declare interface Auth {
     addAuthHeaders(headers: Headers): Promise<void>;
 }
 
+/** Configures automatic detection of activity. */
+export declare interface AutomaticActivityDetection {
+    /** If enabled, detected voice and text input count as activity. If disabled, the client must send activity signals. */
+    disabled?: boolean;
+    /** Determines how likely speech is to be detected. */
+    startOfSpeechSensitivity?: StartSensitivity;
+    /** Determines how likely detected speech is ended. */
+    endOfSpeechSensitivity?: EndSensitivity;
+    /** The required duration of detected speech before start-of-speech is committed. The lower this value the more sensitive the start-of-speech detection is and the shorter speech can be recognized. However, this also increases the probability of false positives. */
+    prefixPaddingMs?: number;
+    /** The required duration of detected non-speech (e.g. silence) before end-of-speech is committed. The larger this value, the longer speech gaps can be without interrupting the user's activity but this will increase the model's latency. */
+    silenceDurationMs?: number;
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
 declare class BaseModule {
 }
 
@@ -126,6 +173,7 @@ declare interface Blob_2 {
 }
 export { Blob_2 as Blob }
 
+/** Output only. Blocked reason. */
 export declare enum BlockedReason {
     BLOCKED_REASON_UNSPECIFIED = "BLOCKED_REASON_UNSPECIFIED",
     SAFETY = "SAFETY",
@@ -435,16 +483,6 @@ export declare interface CodeExecutionResult {
     output?: string;
 }
 
-declare namespace common {
-    export {
-        formatMap,
-        setValueByPath,
-        getValueByPath,
-        BaseModule,
-        UploadFileParameters
-    }
-}
-
 /** Optional parameters for computing tokens. */
 export declare interface ComputeTokensConfig {
     /** Used to override HTTP request options. */
@@ -476,7 +514,7 @@ export declare interface Content {
     parts?: Part[];
     /** Optional. The producer of the content. Must be either 'user' or
      'model'. Useful to set for multi-turn conversations, otherwise can be
-     left blank or unset. If role is not specified, SDK will determine the role. */
+     empty. If role is not specified, SDK will determine the role. */
     role?: string;
 }
 
@@ -506,6 +544,14 @@ export declare type ContentListUnion = ContentUnion[] | ContentUnion;
 
 export declare type ContentUnion = Content | PartUnion[] | PartUnion;
 
+/** Enables context window compression -- mechanism managing model context window so it does not exceed given length. */
+export declare interface ContextWindowCompressionConfig {
+    /** Number of tokens (before running turn) that triggers context window compression mechanism. */
+    triggerTokens?: string;
+    /** Sliding window compression mechanism. */
+    slidingWindow?: SlidingWindow;
+}
+
 /** Configuration for a Control reference image. */
 export declare interface ControlReferenceConfig {
     /** The type of control reference image to use. */
@@ -537,6 +583,7 @@ export declare interface ControlReferenceImage {
     config?: ControlReferenceConfig;
 }
 
+/** Enum representing the control type of a control reference image. */
 export declare enum ControlReferenceType {
     CONTROL_TYPE_DEFAULT = "CONTROL_TYPE_DEFAULT",
     CONTROL_TYPE_CANNY = "CONTROL_TYPE_CANNY",
@@ -672,7 +719,7 @@ export declare class CreateFileResponse {
 export declare function createModelContent(partOrString: PartListUnion | string): Content;
 
 /**
- * Creates a `Part` object from a `base64` `string`.
+ * Creates a `Part` object from a `base64` encoded `string`.
  */
 export declare function createPartFromBase64(data: string, mimeType: string): Part;
 
@@ -763,6 +810,7 @@ export declare interface DynamicRetrievalConfig {
     dynamicThreshold?: number;
 }
 
+/** Config for the dynamic retrieval config mode. */
 export declare enum DynamicRetrievalConfigMode {
     MODE_UNSPECIFIED = "MODE_UNSPECIFIED",
     MODE_DYNAMIC = "MODE_DYNAMIC"
@@ -826,6 +874,21 @@ export declare class EmbedContentResponse {
     metadata?: EmbedContentMetadata;
 }
 
+/** An endpoint where you deploy models. */
+export declare interface Endpoint {
+    /** Resource name of the endpoint. */
+    name?: string;
+    /** ID of the model that's deployed to the endpoint. */
+    deployedModelId?: string;
+}
+
+/** End of speech sensitivity. */
+export declare enum EndSensitivity {
+    END_SENSITIVITY_UNSPECIFIED = "END_SENSITIVITY_UNSPECIFIED",
+    END_SENSITIVITY_HIGH = "END_SENSITIVITY_HIGH",
+    END_SENSITIVITY_LOW = "END_SENSITIVITY_LOW"
+}
+
 /** Code generated by the model that is meant to be executed, and the result returned to the model. Generated when using the [FunctionDeclaration] tool and [FunctionCallingConfig] mode is set to [Mode.CODE]. */
 export declare interface ExecutableCode {
     /** Required. The code to be executed. */
@@ -934,7 +997,9 @@ export declare class Files extends BaseModule {
      * This section can contain multiple paragraphs and code examples.
      *
      * @param params - Optional parameters specified in the
-     *        `common.UploadFileParameters` interface.
+     *        `types.UploadFileParameters` interface.
+     *         @see {@link types.UploadFileParameters#config} for the optional
+     *         config in the parameters.
      * @return A promise that resolves to a `types.File` object.
      * @throws An error if called on a Vertex AI client.
      * @throws An error if the `mimeType` is not provided and can not be inferred,
@@ -951,7 +1016,7 @@ export declare class Files extends BaseModule {
      * console.log(file.name);
      * ```
      */
-    upload(params: common.UploadFileParameters): Promise<types.File>;
+    upload(params: types.UploadFileParameters): Promise<types.File>;
     private listInternal;
     private createInternal;
     /**
@@ -986,6 +1051,7 @@ export declare class Files extends BaseModule {
     delete(params: types.DeleteFileParameters): Promise<types.DeleteFileResponse>;
 }
 
+/** Source of the File. */
 export declare enum FileSource {
     SOURCE_UNSPECIFIED = "SOURCE_UNSPECIFIED",
     UPLOADED = "UPLOADED",
@@ -1009,6 +1075,7 @@ declare interface FileStat {
     type: string | undefined;
 }
 
+/** State for the lifecycle of a File. */
 export declare enum FileState {
     STATE_UNSPECIFIED = "STATE_UNSPECIFIED",
     PROCESSING = "PROCESSING",
@@ -1026,6 +1093,10 @@ export declare interface FileStatus {
     code?: number;
 }
 
+/** Output only. The reason why the model stopped generating tokens.
+
+ If empty, the model has not stopped generating the tokens.
+ */
 export declare enum FinishReason {
     FINISH_REASON_UNSPECIFIED = "FINISH_REASON_UNSPECIFIED",
     STOP = "STOP",
@@ -1040,8 +1111,6 @@ export declare enum FinishReason {
     IMAGE_SAFETY = "IMAGE_SAFETY"
 }
 
-declare function formatMap(templateString: string, valueMap: Record<string, unknown>): string;
-
 /** A function call. */
 export declare interface FunctionCall {
     /** The unique id of the function call. If populated, the client to execute the
@@ -1061,6 +1130,7 @@ export declare interface FunctionCallingConfig {
     allowedFunctionNames?: string[];
 }
 
+/** Config for the function calling config mode. */
 export declare enum FunctionCallingConfigMode {
     MODE_UNSPECIFIED = "MODE_UNSPECIFIED",
     AUTO = "AUTO",
@@ -1385,6 +1455,8 @@ export declare class GenerateContentResponseUsageMetadata {
     toolUsePromptTokensDetails?: ModalityTokenCount[];
     /** Total token count for prompt, response candidates, and tool-use prompts (if present). */
     totalTokenCount?: number;
+    /** Output only. Traffic type. This shows whether a request consumes Pay-As-You-Go or Provisioned Throughput quota. */
+    trafficType?: TrafficType;
 }
 
 /** An output image. */
@@ -1531,10 +1603,8 @@ export declare interface GenerateVideosOperation {
     done?: boolean;
     /** The error result of the operation in case of failure or cancellation. */
     error?: Record<string, unknown>;
-    /** The normal response of the operation in case of success. */
-    response?: Record<string, unknown>;
     /** The generated videos. */
-    result?: GenerateVideosResponse;
+    response?: GenerateVideosResponse;
 }
 
 /** Class that represents the parameters for generating an image. */
@@ -1573,6 +1643,8 @@ export declare interface GenerationConfig {
     logprobs?: number;
     /** Optional. The maximum number of output tokens to generate per message. */
     maxOutputTokens?: number;
+    /** Optional. If specified, the media resolution specified will be used. */
+    mediaResolution?: MediaResolution;
     /** Optional. Positive penalties. */
     presencePenalty?: number;
     /** Optional. If true, export the logprobs results in response. */
@@ -1645,6 +1717,18 @@ export declare interface GetFileParameters {
     config?: GetFileConfig;
 }
 
+/** Optional parameters for models.get method. */
+export declare interface GetModelConfig {
+    /** Used to override HTTP request options. */
+    httpOptions?: HttpOptions;
+}
+
+export declare interface GetModelParameters {
+    model: string;
+    /** Optional parameters for the request. */
+    config?: GetModelConfig;
+}
+
 export declare interface GetOperationConfig {
     /** Used to override HTTP request options. */
     httpOptions?: HttpOptions;
@@ -1658,8 +1742,6 @@ export declare interface GetOperationParameters {
     config?: GetOperationConfig;
 }
 
-declare function getValueByPath(data: unknown, keys: string[]): unknown;
-
 /**
  * The Google GenAI SDK.
  *
@@ -1811,6 +1893,8 @@ export declare interface GroundingChunkRetrievedContext {
 
 /** Chunk from the web. */
 export declare interface GroundingChunkWeb {
+    /** Domain of the (original) URI. */
+    domain?: string;
     /** Title of the chunk. */
     title?: string;
     /** URI reference of the chunk. */
@@ -1843,12 +1927,14 @@ export declare interface GroundingSupport {
     segment?: Segment;
 }
 
+/** Optional. Specify if the threshold is used for probability or severity score. If not specified, the threshold is used for probability score. */
 export declare enum HarmBlockMethod {
     HARM_BLOCK_METHOD_UNSPECIFIED = "HARM_BLOCK_METHOD_UNSPECIFIED",
     SEVERITY = "SEVERITY",
     PROBABILITY = "PROBABILITY"
 }
 
+/** Required. The harm block threshold. */
 export declare enum HarmBlockThreshold {
     HARM_BLOCK_THRESHOLD_UNSPECIFIED = "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
     BLOCK_LOW_AND_ABOVE = "BLOCK_LOW_AND_ABOVE",
@@ -1858,6 +1944,7 @@ export declare enum HarmBlockThreshold {
     OFF = "OFF"
 }
 
+/** Required. Harm category. */
 export declare enum HarmCategory {
     HARM_CATEGORY_UNSPECIFIED = "HARM_CATEGORY_UNSPECIFIED",
     HARM_CATEGORY_HATE_SPEECH = "HARM_CATEGORY_HATE_SPEECH",
@@ -1867,6 +1954,7 @@ export declare enum HarmCategory {
     HARM_CATEGORY_CIVIC_INTEGRITY = "HARM_CATEGORY_CIVIC_INTEGRITY"
 }
 
+/** Output only. Harm probability levels in the content. */
 export declare enum HarmProbability {
     HARM_PROBABILITY_UNSPECIFIED = "HARM_PROBABILITY_UNSPECIFIED",
     NEGLIGIBLE = "NEGLIGIBLE",
@@ -1875,6 +1963,7 @@ export declare enum HarmProbability {
     HIGH = "HIGH"
 }
 
+/** Output only. Harm severity levels in the content. */
 export declare enum HarmSeverity {
     HARM_SEVERITY_UNSPECIFIED = "HARM_SEVERITY_UNSPECIFIED",
     HARM_SEVERITY_NEGLIGIBLE = "HARM_SEVERITY_NEGLIGIBLE",
@@ -1967,6 +2056,7 @@ declare interface Image_2 {
 }
 export { Image_2 as Image }
 
+/** Enum that specifies the language of the text in the prompt. */
 export declare enum ImagePromptLanguage {
     auto = "auto",
     en = "en",
@@ -1975,6 +2065,7 @@ export declare enum ImagePromptLanguage {
     hi = "hi"
 }
 
+/** Required. Programming language of the `code`. */
 export declare enum Language {
     LANGUAGE_UNSPECIFIED = "LANGUAGE_UNSPECIFIED",
     PYTHON = "PYTHON"
@@ -2078,9 +2169,21 @@ export declare class Live {
 
 /** Callbacks for the live API. */
 export declare interface LiveCallbacks {
+    /**
+     * Called when the websocket connection is established.
+     */
     onopen?: (() => void) | null;
+    /**
+     * Called when a message is received from the server.
+     */
     onmessage: (e: LiveServerMessage) => void;
+    /**
+     * Called when an error occurs.
+     */
     onerror?: ((e: ErrorEvent) => void) | null;
+    /**
+     * Called when the websocket connection is closed.
+     */
     onclose?: ((e: CloseEvent) => void) | null;
 }
 
@@ -2119,11 +2222,11 @@ export declare interface LiveClientMessage {
 
 /** User input that is sent in real time.
 
- This is different from `ClientContentUpdate` in a few ways:
+ This is different from `LiveClientContent` in a few ways:
 
  - Can be sent continuously without interruption to model generation.
  - If there is a need to mix data interleaved across the
- `ClientContentUpdate` and the `RealtimeUpdate`, server attempts to
+ `LiveClientContent` and the `LiveClientRealtimeInput`, server attempts to
  optimize for best response, but there are no guarantees.
  - End of turn is not explicitly specified, but is rather derived from user
  activity (for example, end of speech).
@@ -2135,6 +2238,10 @@ export declare interface LiveClientMessage {
 export declare interface LiveClientRealtimeInput {
     /** Inlined bytes data for media input. */
     mediaChunks?: Blob_2[];
+    /** Marks the start of user activity. */
+    activityStart?: ActivityStart;
+    /** Marks the end of user activity. */
+    activityEnd?: ActivityEnd;
 }
 
 /** Message contains configuration that will apply for the duration of the streaming session. */
@@ -2145,15 +2252,7 @@ export declare interface LiveClientSetup {
      */
     model?: string;
     /** The generation configuration for the session.
-
-     The following fields are supported:
-     - `response_logprobs`
-     - `response_mime_type`
-     - `logprobs`
-     - `response_schema`
-     - `stop_sequence`
-     - `routing_config`
-     - `audio_timestamp`
+     Note: only a subset of fields are supported.
      */
     generationConfig?: GenerationConfig;
     /** The user provided system instructions for the model.
@@ -2166,6 +2265,16 @@ export declare interface LiveClientSetup {
      external systems to perform an action, or set of actions, outside of
      knowledge and scope of the model. */
     tools?: ToolListUnion;
+    /** Configures the realtime input behavior in BidiGenerateContent. */
+    realtimeInputConfig?: RealtimeInputConfig;
+    /** Configures session resumption mechanism.
+
+     If included server will send SessionResumptionUpdate messages. */
+    sessionResumption?: SessionResumptionConfig;
+    /** Configures context window compression mechanism.
+
+     If included, server will compress context window to fit into given length. */
+    contextWindowCompression?: ContextWindowCompressionConfig;
 }
 
 /** Client generated response to a `ToolCall` received from the server.
@@ -2204,6 +2313,16 @@ export declare interface LiveConnectConfig {
      external systems to perform an action, or set of actions, outside of
      knowledge and scope of the model. */
     tools?: ToolListUnion;
+    /** Configures session resumption mechanism.
+
+     If included the server will send SessionResumptionUpdate messages. */
+    sessionResumption?: SessionResumptionConfig;
+    /** Configures the realtime input behavior in BidiGenerateContent. */
+    realtimeInputConfig?: RealtimeInputConfig;
+    /** Configures context window compression mechanism.
+
+     If included, server will compress context window to fit into given length. */
+    contextWindowCompression?: ContextWindowCompressionConfig;
 }
 
 /** Parameters for connecting to the live API. */
@@ -2232,6 +2351,10 @@ export declare interface LiveSendClientContentParameters {
 export declare interface LiveSendRealtimeInputParameters {
     /** Realtime input to send to the session. */
     media: Blob_2;
+    /** Marks the start of user activity. */
+    activityStart?: ActivityStart;
+    /** Marks the end of user activity. */
+    activityEnd?: ActivityEnd;
 }
 
 /** Parameters for sending tool responses to the live API. */
@@ -2252,6 +2375,21 @@ export declare interface LiveServerContent {
     turnComplete?: boolean;
     /** If true, indicates that a client message has interrupted current model generation. If the client is playing out the content in realtime, this is a good signal to stop and empty the current queue. */
     interrupted?: boolean;
+    /** If true, indicates that the model is done generating. When model is
+     interrupted while generating there will be no generation_complete message
+     in interrupted turn, it will go through interrupted > turn_complete.
+     When model assumes realtime playback there will be delay between
+     generation_complete and turn_complete that is caused by model
+     waiting for playback to finish. If true, indicates that the model
+     has finished generating all content. This is a signal to the client
+     that it can stop sending messages. */
+    generationComplete?: boolean;
+}
+
+/** Server will not be able to service client soon. */
+export declare interface LiveServerGoAway {
+    /** The remaining time before the connection will be terminated as ABORTED. The minimal time returned here is specified differently together with the rate limits for a given model. */
+    timeLeft?: string;
 }
 
 /** Response message for API call. */
@@ -2264,6 +2402,29 @@ export declare interface LiveServerMessage {
     toolCall?: LiveServerToolCall;
     /** Notification for the client that a previously issued `ToolCallMessage` with the specified `id`s should have been not executed and should be cancelled. */
     toolCallCancellation?: LiveServerToolCallCancellation;
+    /** Usage metadata about model response(s). */
+    usageMetadata?: UsageMetadata;
+    /** Server will disconnect soon. */
+    goAway?: LiveServerGoAway;
+    /** Update of the session resumption state. */
+    sessionResumptionUpdate?: LiveServerSessionResumptionUpdate;
+}
+
+/** Update of the session resumption state.
+
+ Only sent if `session_resumption` was set in the connection config.
+ */
+export declare interface LiveServerSessionResumptionUpdate {
+    /** New handle that represents state that can be resumed. Empty if `resumable`=false. */
+    newHandle?: string;
+    /** True if session can be resumed at this point. It might be not possible to resume session at some points. In that case we send update empty new_handle and resumable=false. Example of such case could be model executing function calls or just generating. Resuming session (using previous session token) in such state will result in some data loss. */
+    resumable?: boolean;
+    /** Index of last message sent by client that is included in state represented by this SessionResumptionToken. Only sent when `SessionResumptionConfig.transparent` is set.
+
+     Presence of this index allows users to transparently reconnect and avoid issue of losing some part of realtime audio input/video. If client wishes to temporarily disconnect (for example as result of receiving GoAway) they can do it without losing state by buffering messages sent since last `SessionResmumptionTokenUpdate`. This field will enable them to limit buffering (avoid keeping all requests in RAM).
+
+     Note: This should not be used for when resuming a session at some time later -- in those cases partial audio and video frames arelikely not needed. */
+    lastConsumedClientMessageIndex?: string;
 }
 
 /** Sent in response to a `LiveGenerateContentSetup` message from the client. */
@@ -2345,6 +2506,7 @@ export declare interface MaskReferenceImage {
     config?: MaskReferenceConfig;
 }
 
+/** Enum representing the mask mode of a mask reference image. */
 export declare enum MaskReferenceMode {
     MASK_MODE_DEFAULT = "MASK_MODE_DEFAULT",
     MASK_MODE_USER_PROVIDED = "MASK_MODE_USER_PROVIDED",
@@ -2353,6 +2515,7 @@ export declare enum MaskReferenceMode {
     MASK_MODE_SEMANTIC = "MASK_MODE_SEMANTIC"
 }
 
+/** Server content modalities. */
 export declare enum MediaModality {
     MODALITY_UNSPECIFIED = "MODALITY_UNSPECIFIED",
     TEXT = "TEXT",
@@ -2362,6 +2525,7 @@ export declare enum MediaModality {
     DOCUMENT = "DOCUMENT"
 }
 
+/** The media resolution to use. */
 export declare enum MediaResolution {
     MEDIA_RESOLUTION_UNSPECIFIED = "MEDIA_RESOLUTION_UNSPECIFIED",
     MEDIA_RESOLUTION_LOW = "MEDIA_RESOLUTION_LOW",
@@ -2369,6 +2533,7 @@ export declare enum MediaResolution {
     MEDIA_RESOLUTION_HIGH = "MEDIA_RESOLUTION_HIGH"
 }
 
+/** Server content modalities. */
 export declare enum Modality {
     MODALITY_UNSPECIFIED = "MODALITY_UNSPECIFIED",
     TEXT = "TEXT",
@@ -2384,11 +2549,40 @@ export declare interface ModalityTokenCount {
     tokenCount?: number;
 }
 
+/** The mode of the predictor to be used in dynamic retrieval. */
 export declare enum Mode {
     MODE_UNSPECIFIED = "MODE_UNSPECIFIED",
     MODE_DYNAMIC = "MODE_DYNAMIC"
 }
 
+/** A trained machine learning model. */
+export declare interface Model {
+    /** Resource name of the model. */
+    name?: string;
+    /** Display name of the model. */
+    displayName?: string;
+    /** Description of the model. */
+    description?: string;
+    /** Version ID of the model. A new version is committed when a new
+     model version is uploaded or trained under an existing model ID. The
+     version ID is an auto-incrementing decimal number in string
+     representation. */
+    version?: string;
+    /** List of deployed models created from this base model. Note that a
+     model could have been deployed to endpoints in different locations. */
+    endpoints?: Endpoint[];
+    /** Labels with user-defined metadata to organize your models. */
+    labels?: Record<string, string>;
+    /** Information about the tuned model from the base model. */
+    tunedModelInfo?: TunedModelInfo;
+    /** The maximum number of input tokens that the model can handle. */
+    inputTokenLimit?: number;
+    /** The maximum number of output tokens that the model can generate. */
+    outputTokenLimit?: number;
+    /** List of actions that are supported by the model. */
+    supportedActions?: string[];
+}
+
 export declare class Models extends BaseModule {
     private readonly apiClient;
     constructor(apiClient: ApiClient);
@@ -2539,6 +2733,15 @@ export declare class Models extends BaseModule {
      * ```
      */
     private generateImagesInternal;
+    /**
+     * Fetches information about a model by name.
+     *
+     * @example
+     * ```ts
+     * const modelInfo = await ai.models.get({model: 'gemini-2.0-flash'});
+     * ```
+     */
+    get(params: types.GetModelParameters): Promise<types.Model>;
     /**
      * Counts the number of tokens in the given contents. Multimodal input is
      * supported for Gemini models.
@@ -2592,10 +2795,10 @@ export declare class Models extends BaseModule {
      *
      * while (!operation.done) {
      *   await new Promise(resolve => setTimeout(resolve, 10000));
-     *   operation = await ai.operations.get({operation: operation});
+     *   operation = await ai.operations.getVideosOperation({operation: operation});
      * }
      *
-     * console.log(operation.result?.generatedVideos?.[0]?.video?.uri);
+     * console.log(operation.response?.generatedVideos?.[0]?.video?.uri);
      * ```
      */
     generateVideos(params: types.GenerateVideosParameters): Promise<types.GenerateVideosOperation>;
@@ -2615,10 +2818,10 @@ export declare class Operations extends BaseModule {
     /**
      * Gets the status of a long-running operation.
      *
-     * @param operation The Operation object returned by a previous API call.
+     * @param parameters The parameters for the get operation request.
      * @return The updated Operation object, with the latest status or result.
      */
-    get(parameters: types.OperationGetParameters): Promise<types.GenerateVideosOperation>;
+    getVideosOperation(parameters: types.OperationGetParameters): Promise<types.GenerateVideosOperation>;
     private getVideosOperationInternal;
     private fetchPredictVideosOperationInternal;
 }
@@ -2628,6 +2831,7 @@ export declare class Operations extends BaseModule {
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+/** Required. Outcome of the code execution. */
 export declare enum Outcome {
     OUTCOME_UNSPECIFIED = "OUTCOME_UNSPECIFIED",
     OUTCOME_OK = "OUTCOME_OK",
@@ -2793,6 +2997,7 @@ export declare type PartListUnion = PartUnion[] | PartUnion;
 
 export declare type PartUnion = Part | string;
 
+/** Enum that controls the generation of people. */
 export declare enum PersonGeneration {
     DONT_ALLOW = "DONT_ALLOW",
     ALLOW_ADULT = "ALLOW_ADULT",
@@ -2821,6 +3026,20 @@ export declare interface RawReferenceImage {
     referenceType?: string;
 }
 
+/** Marks the end of user activity.
+
+ This can only be sent if automatic (i.e. server-side) activity detection is
+ disabled.
+ */
+export declare interface RealtimeInputConfig {
+    /** If not set, automatic activity detection is enabled by default. If automatic voice detection is disabled, the client must send activity signals. */
+    automaticActivityDetection?: AutomaticActivityDetection;
+    /** Defines what effect activity has. */
+    activityHandling?: ActivityHandling;
+    /** Defines which input is included in the user's turn. */
+    turnCoverage?: TurnCoverage;
+}
+
 /** Represents a recorded session. */
 export declare interface ReplayFile {
     replayId?: string;
@@ -2878,6 +3097,7 @@ export declare interface SafetyAttributes {
     contentType?: string;
 }
 
+/** Enum that controls the safety filter level for objectionable content. */
 export declare enum SafetyFilterLevel {
     BLOCK_LOW_AND_ABOVE = "BLOCK_LOW_AND_ABOVE",
     BLOCK_MEDIUM_AND_ABOVE = "BLOCK_MEDIUM_AND_ABOVE",
@@ -3126,7 +3346,31 @@ export declare class Session {
     close(): void;
 }
 
-declare function setValueByPath(data: Record<string, unknown>, keys: string[], value: unknown): void;
+/** Configuration of session resumption mechanism.
+
+ Included in `LiveConnectConfig.session_resumption`. If included server
+ will send `LiveServerSessionResumptionUpdate` messages.
+ */
+export declare interface SessionResumptionConfig {
+    /** Session resumption handle of previous session (session to restore).
+
+     If not present new session will be started. */
+    handle?: string;
+    /** If set the server will send `last_consumed_client_message_index` in the `session_resumption_update` messages to allow for transparent reconnections. */
+    transparent?: boolean;
+}
+
+/** Context window will be truncated by keeping only suffix of it.
+
+ Context window will always be cut at start of USER role turn. System
+ instructions and `BidiGenerateContentSetup.prefix_turns` will not be
+ subject to the sliding window mechanism, they will always stay at the
+ beginning of context window.
+ */
+export declare interface SlidingWindow {
+    /** Session reduction target -- how many tokens we should keep. Window shortening operation has some latency costs, so we should avoid running it on every turn. Should be < trigger_tokens. If not set, trigger_tokens/2 is assumed. */
+    targetTokens?: string;
+}
 
 /** The speech generation configuration. */
 export declare interface SpeechConfig {
@@ -3137,10 +3381,11 @@ export declare interface SpeechConfig {
 
 export declare type SpeechConfigUnion = SpeechConfig | string;
 
-export declare enum State {
-    STATE_UNSPECIFIED = "STATE_UNSPECIFIED",
-    ACTIVE = "ACTIVE",
-    ERROR = "ERROR"
+/** Start of speech sensitivity. */
+export declare enum StartSensitivity {
+    START_SENSITIVITY_UNSPECIFIED = "START_SENSITIVITY_UNSPECIFIED",
+    START_SENSITIVITY_HIGH = "START_SENSITIVITY_HIGH",
+    START_SENSITIVITY_LOW = "START_SENSITIVITY_LOW"
 }
 
 /** Configuration for a Style reference image. */
@@ -3195,6 +3440,7 @@ export declare interface SubjectReferenceImage {
     config?: SubjectReferenceConfig;
 }
 
+/** Enum representing the subject type of a subject reference image. */
 export declare enum SubjectReferenceType {
     SUBJECT_TYPE_DEFAULT = "SUBJECT_TYPE_DEFAULT",
     SUBJECT_TYPE_PERSON = "SUBJECT_TYPE_PERSON",
@@ -3233,6 +3479,9 @@ export declare interface ThinkingConfig {
     /** Indicates whether to include thoughts in the response. If true, thoughts are returned only if the model supports thought and thoughts are available.
      */
     includeThoughts?: boolean;
+    /** Indicates the thinking budget in tokens.
+     */
+    thinkingBudget?: number;
 }
 
 /** Tokens info with a list of tokens and the corresponding list of token ids. */
@@ -3275,6 +3524,31 @@ export declare interface ToolConfig {
 
 export declare type ToolListUnion = Tool[];
 
+/** Output only. Traffic type. This shows whether a request consumes Pay-As-You-Go or Provisioned Throughput quota. */
+export declare enum TrafficType {
+    TRAFFIC_TYPE_UNSPECIFIED = "TRAFFIC_TYPE_UNSPECIFIED",
+    ON_DEMAND = "ON_DEMAND",
+    PROVISIONED_THROUGHPUT = "PROVISIONED_THROUGHPUT"
+}
+
+/** A tuned machine learning model. */
+export declare interface TunedModelInfo {
+    /** ID of the base model that you want to tune. */
+    baseModel?: string;
+    /** Date and time when the base model was created. */
+    createTime?: string;
+    /** Date and time when the base model was last updated. */
+    updateTime?: string;
+}
+
+/** Options about which input is included in the user's turn. */
+export declare enum TurnCoverage {
+    TURN_COVERAGE_UNSPECIFIED = "TURN_COVERAGE_UNSPECIFIED",
+    TURN_INCLUDES_ONLY_ACTIVITY = "TURN_INCLUDES_ONLY_ACTIVITY",
+    TURN_INCLUDES_ALL_INPUT = "TURN_INCLUDES_ALL_INPUT"
+}
+
+/** Optional. The type of the data. */
 export declare enum Type {
     TYPE_UNSPECIFIED = "TYPE_UNSPECIFIED",
     STRING = "STRING",
@@ -3307,11 +3581,11 @@ declare namespace types {
         HarmProbability,
         HarmSeverity,
         BlockedReason,
+        TrafficType,
         Modality,
-        State,
+        MediaResolution,
         DynamicRetrievalConfigMode,
         FunctionCallingConfigMode,
-        MediaResolution,
         SafetyFilterLevel,
         PersonGeneration,
         ImagePromptLanguage,
@@ -3321,6 +3595,10 @@ declare namespace types {
         ControlReferenceType,
         SubjectReferenceType,
         MediaModality,
+        StartSensitivity,
+        EndSensitivity,
+        ActivityHandling,
+        TurnCoverage,
         VideoMetadata,
         CodeExecutionResult,
         ExecutableCode,
@@ -3386,6 +3664,11 @@ declare namespace types {
         SafetyAttributes,
         GeneratedImage,
         GenerateImagesResponse,
+        GetModelConfig,
+        GetModelParameters,
+        Endpoint,
+        TunedModelInfo,
+        Model,
         GenerationConfig,
         CountTokensConfig,
         CountTokensParameters,
@@ -3423,6 +3706,7 @@ declare namespace types {
         CreateFileParameters,
         HttpResponse,
         LiveCallbacks,
+        UploadFileParameters,
         CreateFileResponse,
         GetFileConfig,
         GetFileParameters,
@@ -3456,12 +3740,23 @@ declare namespace types {
         LiveServerContent,
         LiveServerToolCall,
         LiveServerToolCallCancellation,
+        UsageMetadata,
+        LiveServerGoAway,
+        LiveServerSessionResumptionUpdate,
         LiveServerMessage,
+        AutomaticActivityDetection,
+        RealtimeInputConfig,
+        SessionResumptionConfig,
+        SlidingWindow,
+        ContextWindowCompressionConfig,
         LiveClientSetup,
         LiveClientContent,
+        ActivityStart,
+        ActivityEnd,
         LiveClientRealtimeInput,
         LiveClientToolResponse,
         LiveClientMessage,
+        AudioTranscriptionConfig,
         LiveConnectConfig,
         LiveConnectParameters,
         CreateChatParameters,
@@ -3535,9 +3830,9 @@ export declare interface UploadFileConfig {
 }
 
 /** Parameters for the upload file method. */
-declare interface UploadFileParameters {
+export declare interface UploadFileParameters {
     /** The string path to the file to be uploaded or a Blob object. */
-    file: string | Blob;
+    file: string | globalThis.Blob;
     /** Configuration that contains optional parameters. */
     config?: UploadFileConfig;
 }
@@ -3573,6 +3868,33 @@ export declare interface UpscaleImageParameters {
     config?: UpscaleImageConfig;
 }
 
+/** Usage metadata about response(s). */
+export declare interface UsageMetadata {
+    /** Number of tokens in the prompt. When `cached_content` is set, this is still the total effective prompt size meaning this includes the number of tokens in the cached content. */
+    promptTokenCount?: number;
+    /** Number of tokens in the cached part of the prompt (the cached content). */
+    cachedContentTokenCount?: number;
+    /** Total number of tokens across all the generated response candidates. */
+    responseTokenCount?: number;
+    /** Number of tokens present in tool-use prompt(s). */
+    toolUsePromptTokenCount?: number;
+    /** Number of tokens of thoughts for thinking models. */
+    thoughtsTokenCount?: number;
+    /** Total token count for prompt, response candidates, and tool-use prompts(if present). */
+    totalTokenCount?: number;
+    /** List of modalities that were processed in the request input. */
+    promptTokensDetails?: ModalityTokenCount[];
+    /** List of modalities that were processed in the cache input. */
+    cacheTokensDetails?: ModalityTokenCount[];
+    /** List of modalities that were returned in the response. */
+    responseTokensDetails?: ModalityTokenCount[];
+    /** List of modalities that were processed in the tool-use prompt. */
+    toolUsePromptTokensDetails?: ModalityTokenCount[];
+    /** Traffic type. This shows whether a request consumes Pay-As-You-Go
+     or Provisioned Throughput quota. */
+    trafficType?: TrafficType;
+}
+
 /** Retrieve from Vertex AI Search datastore or engine for grounding. datastore and engine are mutually exclusive. See https://cloud.google.com/products/agent-builder */
 export declare interface VertexAISearch {
     /** Optional. Fully-qualified Vertex AI Search data store resource ID. Format: `projects/{project}/locations/{location}/collections/{collection}/dataStores/{dataStore}` */