@google/adk 2.2.1 → 2.4.0

package/dist/types/tools/application_integration_tool/clients/connections_client.d.ts

@@ -0,0 +1,229 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+import { JsonObject } from '../../../utils/json_utils.js';
+/** Options for {@link ConnectionsClient}. */
+export interface ConnectionsClientOptions {
+    /** The Google Cloud project ID. */
+    project: string;
+    /** The Google Cloud location, such as `us-central1`. */
+    location: string;
+    /** The connection name. */
+    connection: string;
+    /**
+     * A service-account key, as a JSON string. When omitted, requests use
+     * Application Default Credentials.
+     */
+    serviceAccountJson?: string;
+}
+/** Service details of an Integration Connectors connection. */
+export interface ConnectionDetails {
+    /** The resource name of the connection, or `''` when not reported. */
+    name?: string;
+    /**
+     * The Service Directory name of the connection. For a connection with a
+     * `host`, the TLS Service Directory name.
+     */
+    serviceName: string;
+    /** The host of the connection, or `''` when it has none. */
+    host: string;
+    /** Whether the connection lets a request override its authentication. */
+    authOverrideEnabled: boolean;
+}
+/** The schema of one entity of a connection, and the operations it supports. */
+export interface EntitySchemaAndOperations {
+    /** The JSON schema of the entity. */
+    schema: JsonObject;
+    /** The operations the entity supports, such as `LIST` or `GET`. */
+    operations: string[];
+}
+/** The input and output schemas of one action of a connection. */
+export interface ActionSchema {
+    /** The JSON schema of the action input. */
+    inputSchema: JsonObject;
+    /** The JSON schema of the action output. */
+    outputSchema: JsonObject;
+    /** The description of the action. */
+    description: string;
+    /** The display name of the action. */
+    displayName: string;
+}
+/** The OpenAPI document of the `ExecuteConnection` integration. */
+export interface ConnectorSpec {
+    openapi: string;
+    info: {
+        title: string;
+        description: string;
+        version: string;
+    };
+    servers: Array<{
+        url: string;
+    }>;
+    security: Array<Record<string, string[]>>;
+    /** Path items, keyed by path. */
+    paths: Record<string, JsonObject>;
+    components: {
+        /** Schemas, keyed by name. */
+        schemas: Record<string, JsonObject>;
+        securitySchemes: Record<string, OpenAPIV3.SecuritySchemeObject>;
+    };
+}
+/** Options for {@link getActionOperation}. */
+export interface GetActionOperationOptions {
+    /** The action name. */
+    action: string;
+    /** `EXECUTE_ACTION`, or `EXECUTE_QUERY` for a custom query. */
+    operation: string;
+    /** The display name of the action. */
+    actionDisplayName: string;
+    /** Prefix of the generated `operationId`. Defaults to `''`. */
+    toolName?: string;
+    /** Text appended to the description. Defaults to `''`. */
+    toolInstructions?: string;
+}
+/** Options for {@link listOperation} and {@link getOperation}. */
+export interface EntitySchemaOperationOptions {
+    /** The entity name. */
+    entity: string;
+    /**
+     * The entity JSON schema, quoted in the response description. Defaults to
+     * `''`.
+     */
+    schemaAsString?: string;
+    /** Prefix of the generated `operationId`. Defaults to `''`. */
+    toolName?: string;
+    /** Text appended to the description. Defaults to `''`. */
+    toolInstructions?: string;
+}
+/**
+ * Options for {@link createOperation}, {@link updateOperation} and
+ * {@link deleteOperation}.
+ */
+export interface EntityOperationOptions {
+    /** The entity name. */
+    entity: string;
+    /** Prefix of the generated `operationId`. Defaults to `''`. */
+    toolName?: string;
+    /** Text appended to the description. Defaults to `''`. */
+    toolInstructions?: string;
+}
+/** The base OpenAPI document of the `ExecuteConnection` integration. */
+export declare const CONNECTOR_BASE_SPEC: ConnectorSpec;
+/**
+ * Converts the JSON schema of an entity or an action payload into the
+ * OpenAPI schema the connector spec carries.
+ *
+ * Keeps `description`, maps a `type` array holding `null` to `nullable: true`
+ * plus the first other type, and recurses into `properties` of an object and
+ * `items` of an array. Every other keyword is dropped.
+ *
+ * @param jsonSchema The JSON schema.
+ * @returns The OpenAPI schema.
+ */
+export declare function connectorPayload(jsonSchema: JsonObject): JsonObject;
+/**
+ * Builds the path item that runs an action.
+ *
+ * @param options The action, operation, display name, tool name, and instructions.
+ */
+export declare function getActionOperation(options: GetActionOperationOptions): JsonObject;
+/**
+ * Builds the path item that lists the records of an entity.
+ *
+ * @param options The entity, schema string, tool name, and instructions.
+ */
+export declare function listOperation(options: EntitySchemaOperationOptions): JsonObject;
+/**
+ * Builds the path item that reads one record of an entity.
+ *
+ * @param options The entity, schema string, tool name, and instructions.
+ */
+export declare function getOperation(options: EntitySchemaOperationOptions): JsonObject;
+/**
+ * Builds the path item that creates a record of an entity.
+ *
+ * @param options The entity, tool name, and instructions.
+ */
+export declare function createOperation(options: EntityOperationOptions): JsonObject;
+/**
+ * Builds the path item that updates a record of an entity.
+ *
+ * @param options The entity, tool name, and instructions.
+ */
+export declare function updateOperation(options: EntityOperationOptions): JsonObject;
+/**
+ * Builds the path item that deletes a record of an entity.
+ *
+ * @param options The entity, tool name, and instructions.
+ */
+export declare function deleteOperation(options: EntityOperationOptions): JsonObject;
+/** Builds the request schema of the create operation of an entity. */
+export declare function createOperationRequest(entity: string, options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
+/** Builds the request schema of the update operation of an entity. */
+export declare function updateOperationRequest(entity: string, options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
+/** Builds the request schema of the get operation. */
+export declare function getOperationRequest(options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
+/** Builds the request schema of the delete operation. */
+export declare function deleteOperationRequest(options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
+/** Builds the request schema of the list operation. */
+export declare function listOperationRequest(options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
+/** Builds the request schema of an action. */
+export declare function actionRequest(action: string, options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
+/** Builds the response schema of an action. */
+export declare function actionResponse(action: string): JsonObject;
+/** Builds the request schema of the `ExecuteCustomQuery` action. */
+export declare function executeCustomQueryRequest(): JsonObject;
+/**
+ * A client for the Integration Connectors API.
+ *
+ * It reads the details, entity schemas and action schemas of one connection.
+ */
+export declare class ConnectionsClient {
+    private readonly project;
+    private readonly location;
+    private readonly connection;
+    private readonly tokenSource;
+    constructor(options: ConnectionsClientOptions);
+    /**
+     * Reads the resource name, service name and host of the connection, and
+     * whether it allows an authentication override.
+     */
+    getConnectionDetails(): Promise<ConnectionDetails>;
+    /**
+     * Reads the JSON schema of an entity and the operations it supports.
+     *
+     * @param entity The entity name.
+     * @throws Error When the API starts no operation for the entity.
+     */
+    getEntitySchemaAndOperations(entity: string): Promise<EntitySchemaAndOperations>;
+    /**
+     * Reads the input and output JSON schemas of an action.
+     *
+     * @param action The action name.
+     * @throws Error When the API starts no operation for the action.
+     */
+    getActionSchema(action: string): Promise<ActionSchema>;
+    /**
+     * Converts the JSON schema of an entity or an action payload into the
+     * OpenAPI schema the connector spec carries.
+     */
+    connectorPayload(jsonSchema: JsonObject): JsonObject;
+    private executeApiCall;
+    /** Polls a long-running operation until it reports `done`. */
+    private pollOperation;
+}

package/dist/types/tools/application_integration_tool/clients/integration_client.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { JsonObject } from '../../../utils/json_utils.js';
+import { ConnectorSpec } from './connections_client.js';
+/** Options for {@link IntegrationClient}. */
+export interface IntegrationClientOptions {
+    /** The Google Cloud project ID. */
+    project: string;
+    /** The Google Cloud location, such as `us-central1`. */
+    location: string;
+    /** The integration name. */
+    integration?: string;
+    /** The API trigger IDs of the integration. */
+    triggers?: string[];
+    /** The connection name. */
+    connection?: string;
+    /**
+     * Operations to expose, keyed by entity name, such as
+     * `{Issues: ['LIST', 'GET']}`. An empty list exposes every operation the
+     * entity supports.
+     */
+    entityOperations?: Record<string, string[]>;
+    /** Actions to expose. */
+    actions?: string[];
+    /**
+     * A service-account key, as a JSON string. When omitted, requests use
+     * Application Default Credentials.
+     */
+    serviceAccountJson?: string;
+}
+/**
+ * A client for Google Cloud Application Integration.
+ *
+ * It returns the OpenAPI spec of an integration API trigger, or builds one for
+ * the entity operations and actions of an Integration Connectors connection.
+ */
+export declare class IntegrationClient {
+    private readonly project;
+    private readonly location;
+    private readonly integration?;
+    private readonly triggers?;
+    private readonly connection?;
+    private readonly entityOperations;
+    private readonly actions;
+    private readonly serviceAccountJson?;
+    private readonly tokenSource;
+    constructor(options: IntegrationClientOptions);
+    /**
+     * Fetches the OpenAPI spec Application Integration generates for the API
+     * trigger of the integration.
+     *
+     * @throws Error For a rejected request, a missing credential, or a response
+     *   that carries no parseable spec.
+     */
+    getOpenApiSpecForIntegration(): Promise<JsonObject>;
+    /**
+     * Builds an OpenAPI spec for the entity operations and actions of the
+     * connection.
+     *
+     * Every operation becomes a POST to the `ExecuteConnection` integration,
+     * with a path fragment that keeps the paths distinct.
+     *
+     * @param toolName Prefix of every generated `operationId`.
+     * @param toolInstructions Text appended to every operation description.
+     * @throws Error When neither entity operations nor actions are configured,
+     *   or an operation is not one of create, update, delete, list or get.
+     */
+    getOpenApiSpecForConnection(toolName?: string, toolInstructions?: string): Promise<ConnectorSpec>;
+}

package/dist/types/tools/application_integration_tool/integration_connector_tool.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { AuthCredential } from '../../auth/auth_credential.js';
+import { AuthScheme } from '../../auth/auth_schemes.js';
+import { BaseTool, BaseToolParams, RunAsyncToolRequest } from '../base_tool.js';
+import { RestApiTool } from '../openapi_tool/rest_api_tool.js';
+/** Options for {@link IntegrationConnectorTool}. */
+export interface IntegrationConnectorToolOptions extends BaseToolParams {
+    /** The Integration Connectors connection resource name. */
+    connectionName: string;
+    /** The host of the connection, or `''` when it has none. */
+    connectionHost: string;
+    /** The Service Directory name of the connection. */
+    connectionServiceName: string;
+    /** The Integration Connectors entity targeted by the tool, if any. */
+    entity?: string;
+    /** The connector operation executed by the tool, if any. */
+    operation?: string;
+    /** The connector action executed by the tool, if any. */
+    action?: string;
+    /** The underlying {@link RestApiTool} that executes the HTTP request. */
+    restApiTool: RestApiTool;
+    /** The authentication scheme for dynamic end-user credentials, if any. */
+    authScheme?: AuthScheme;
+    /** The authentication credential for dynamic end-user credentials, if any. */
+    authCredential?: AuthCredential;
+}
+/**
+ * Wraps a {@link RestApiTool} for an Integration Connectors operation, hiding
+ * connection and routing fields from the model declaration and injecting them
+ * when the tool runs.
+ */
+export declare class IntegrationConnectorTool extends BaseTool {
+    /**
+     * Request fields that {@link IntegrationConnectorTool} injects at runtime and
+     * excludes from the function declaration shown to the model.
+     */
+    static readonly EXCLUDE_FIELDS: readonly string[];
+    /**
+     * Request fields that {@link IntegrationConnectorTool} removes from the
+     * `required` list in the function declaration shown to the model.
+     */
+    static readonly OPTIONAL_FIELDS: readonly string[];
+    readonly connectionName: string;
+    readonly connectionHost: string;
+    readonly connectionServiceName: string;
+    readonly entity: string;
+    readonly operation: string;
+    readonly action: string;
+    readonly restApiTool: RestApiTool;
+    readonly authScheme?: AuthScheme;
+    readonly authCredential?: AuthCredential;
+    constructor(options: IntegrationConnectorToolOptions);
+    /**
+     * Returns the Gemini `FunctionDeclaration` with connection routing fields
+     * removed from `parameters.properties` and optional and excluded fields
+     * removed from `parameters.required`.
+     */
+    _getDeclaration(): FunctionDeclaration;
+    /**
+     * Injects the connection details and the configured entity, operation, and
+     * action into a copy of `request.args` and delegates execution to the wrapped
+     * {@link RestApiTool}.
+     */
+    runAsync(request: RunAsyncToolRequest): Promise<unknown>;
+}

package/dist/types/tools/base_toolset.d.ts

@@ -8,11 +8,12 @@ import { LlmRequest } from '../models/llm_request.js';
 import { Context } from '../agents/context.js';
 import { BaseTool } from './base_tool.js';
 /**
- * Function to decide whether a tool should be exposed to LLM. Toolset
- * implementer could consider whether to accept such instance in the toolset's
- * constructor and apply the predicate in getTools method.
+ * Decides whether a tool should be exposed to the LLM based on the tool and
+ * optional context.
  */
-export type ToolPredicate = (tool: BaseTool, readonlyContext: ReadonlyContext) => boolean;
+export type ToolPredicate = {
+    bivariance(tool: BaseTool, readonlyContext?: ReadonlyContext): boolean;
+}['bivariance'];
 /**
  * A unique symbol to identify ADK agent classes.
  * Defined once and shared by all BaseTool instances.
@@ -55,7 +56,7 @@ export declare abstract class BaseToolset {
      * @param context Context used to filter tools available to the agent.
      * @return Whether the tool should be exposed to LLM.
      */
-    protected isToolSelected(tool: BaseTool, context: ReadonlyContext): boolean;
+    protected isToolSelected(tool: BaseTool, context?: ReadonlyContext): boolean;
     /**
      * Processes the outgoing LLM request for this toolset. This method will be
      * called before each tool processes the llm request.

package/dist/types/tools/example_tool.d.ts

@@ -12,9 +12,19 @@ import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_too
  * This tool is executed for each LLM request and is never called by the model;
  * it only mutates the outgoing request by appending few-shot instructions built
  * from the latest user query.
+ *
+ * The constructor checks `examples` at runtime, so a malformed value fails
+ * where it is supplied rather than on every later LLM request.
  */
 export declare class ExampleTool extends BaseTool {
+    /** The examples to add to the LLM request. */
     readonly examples: Example[] | BaseExampleProvider;
+    /**
+     * @param examples - A list of {@link Example}s, or a
+     *   {@link BaseExampleProvider} that returns them for a query.
+     * @throws {InputValidationError} When `examples` is neither a
+     *   {@link BaseExampleProvider} nor a list of well-formed examples.
+     */
     constructor(examples: Example[] | BaseExampleProvider);
     runAsync(_request: RunAsyncToolRequest): Promise<unknown>;
     processLlmRequest({ toolContext, llmRequest, }: ToolProcessLlmRequest): Promise<void>;

package/dist/types/tools/function_tool.d.ts

@@ -8,6 +8,8 @@ import { z as z3 } from 'zod/v3';
 import { z as z4 } from 'zod/v4';
 import { Context } from '../agents/context.js';
 import { BaseTool, RunAsyncToolRequest } from './base_tool.js';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { SchemaLike } from '../utils/schema.js';
 /**
  * Input parameters of the function tool.
  */
@@ -59,6 +61,8 @@ export type ToolOptions<TParameters extends ToolInputParameters> = {
     name?: string;
     description: string;
     parameters?: TParameters;
+    /** Optional schema describing the tool's return value. */
+    response?: SchemaLike;
     execute: ToolExecuteFunction<TParameters>;
     isLongRunning?: boolean;
     /**
@@ -80,6 +84,14 @@ export type ToolOptions<TParameters extends ToolInputParameters> = {
      */
     requireConfirmation?: RequireConfirmation<TParameters>;
 };
+/**
+ * The parameters for `_callLive`.
+ */
+export interface CallLiveToolRequest {
+    args: Record<string, unknown>;
+    toolContext: Context;
+    invocationContext: InvocationContext;
+}
 /**
  * A unique symbol to identify ADK agent classes.
  * Defined once and shared by all BaseTool instances.
@@ -114,6 +126,7 @@ export declare class FunctionTool<TParameters extends ToolInputParameters = unde
     readonly [FUNCTION_TOOL_SIGNATURE_SYMBOL] = true;
     private readonly execute;
     private readonly parameters?;
+    private readonly response?;
     private readonly requireConfirmation;
     /**
      * The constructor acts as the user-friendly factory.
@@ -136,6 +149,13 @@ export declare class FunctionTool<TParameters extends ToolInputParameters = unde
      *     `parameters` schema rejects the arguments or `execute` throws.
      */
     runAsync(req: RunAsyncToolRequest): Promise<unknown>;
+    /**
+     * Invokes the tool in live streaming mode, injecting any active input stream
+     * from the invocation context and yielding items from the returned stream.
+     *
+     * @param req The live tool invocation request.
+     */
+    _callLive(req: CallLiveToolRequest): AsyncGenerator<unknown, void, void>;
     /**
      * Whether this call is gated on human approval — the static flag, or the
      * predicate evaluated against the validated arguments.
@@ -157,4 +177,16 @@ export declare class FunctionTool<TParameters extends ToolInputParameters = unde
      */
     private checkConfirmation;
 }
+/**
+ * Builds a `FunctionDeclaration` from a normalized parameter schema.
+ */
+export declare function buildFunctionDeclarationUtil(vertexai: boolean, name: string, description: string, func: unknown, beforeParamSchema: Record<string, unknown>): FunctionDeclaration;
+/**
+ * Builds a `FunctionDeclaration` for a LangChain tool parameter map.
+ */
+export declare function buildFunctionDeclarationForLangchain(vertexai: boolean, name: string, description: string, func: unknown, paramSchema: Record<string, unknown>): FunctionDeclaration;
+/**
+ * Builds a `FunctionDeclaration` for a CrewAI tool parameter schema.
+ */
+export declare function buildFunctionDeclarationForParamsForCrewai(vertexai: boolean, name: string, description: string, func: unknown, paramSchema: Record<string, unknown>): FunctionDeclaration;
 export {};

package/dist/types/tools/google_api_tool/google_api_tool.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
+import { RestApiTool } from '../openapi_tool/rest_api_tool.js';
+declare const GOOGLE_API_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Options for constructing a {@link GoogleApiTool}.
+ */
+export interface GoogleApiToolOptions {
+    clientId?: string;
+    clientSecret?: string;
+}
+/**
+ * Type guard to check if an object is an instance of {@link GoogleApiTool}.
+ */
+export declare function isGoogleApiTool(obj: unknown): obj is GoogleApiTool;
+/**
+ * Wraps a {@link RestApiTool} created from a Google API specification and adds
+ * helper methods for configuring Google OpenID Connect credentials.
+ */
+export declare class GoogleApiTool extends BaseTool {
+    readonly [GOOGLE_API_TOOL_SIGNATURE_SYMBOL] = true;
+    private readonly restApiTool;
+    constructor(restApiTool: RestApiTool, options?: GoogleApiToolOptions);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync(request: RunAsyncToolRequest): Promise<unknown>;
+    /**
+     * Configures OpenID Connect OAuth2 client credentials on the underlying
+     * {@link RestApiTool}.
+     */
+    configureAuth(clientId?: string, clientSecret?: string): void;
+}
+export {};

package/dist/types/tools/google_api_tool/google_api_toolset.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { BaseToolset, ToolPredicate } from '../base_toolset.js';
+import { GoogleApiTool } from './google_api_tool.js';
+declare const GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Options for constructing a {@link GoogleApiToolset}.
+ */
+export interface GoogleApiToolsetOptions {
+    apiName?: string;
+    apiVersion?: string;
+    clientId?: string;
+    clientSecret?: string;
+    toolFilter?: ToolPredicate | string[];
+}
+/**
+ * Type guard to check if an object is an instance of {@link GoogleApiToolset}.
+ */
+export declare function isGoogleApiToolset(obj: unknown): obj is GoogleApiToolset;
+/**
+ * Toolset that wraps Google Discovery API operations as {@link GoogleApiTool}
+ * instances configured for Google OpenID Connect authentication.
+ */
+export declare class GoogleApiToolset extends BaseToolset {
+    readonly [GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL] = true;
+    toolFilter: ToolPredicate | string[];
+    readonly apiName?: string;
+    readonly apiVersion?: string;
+    private clientId?;
+    private clientSecret?;
+    private openapiToolset?;
+    private loadingPromise?;
+    private tools;
+    constructor(options?: GoogleApiToolsetOptions);
+    private loadToolsetWithOidcAuth;
+    private ensureToolsLoaded;
+    /**
+     * Returns all tools in the toolset matching the active `toolFilter`.
+     */
+    getTools(context?: ReadonlyContext): Promise<GoogleApiTool[]>;
+    /**
+     * Updates the tool filter used by {@link getTools}.
+     */
+    setToolFilter(toolFilter: ToolPredicate | string[]): void;
+    /**
+     * Configures OAuth2 client ID and secret across all tools in the toolset.
+     */
+    configureAuth(clientId?: string, clientSecret?: string): void;
+    close(): Promise<void>;
+}
+export {};

package/dist/types/tools/google_api_tool/google_api_toolsets.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GoogleApiToolset, type GoogleApiToolsetOptions } from './google_api_toolset.js';
+/**
+ * Toolset for the Google BigQuery v2 API.
+ */
+export declare class BigQueryToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}
+/**
+ * Toolset for the Google Calendar v3 API.
+ */
+export declare class CalendarToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}
+/**
+ * Toolset for the Gmail v1 API.
+ */
+export declare class GmailToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}
+/**
+ * Toolset for the YouTube Data v3 API.
+ */
+export declare class YoutubeToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}
+/**
+ * Toolset for the Google Slides v1 API.
+ */
+export declare class SlidesToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}
+/**
+ * Toolset for the Google Sheets v4 API.
+ */
+export declare class SheetsToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}
+/**
+ * Toolset for the Google Docs v1 API.
+ */
+export declare class DocsToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}