@wildix/wilma-tools-client 1.0.1

package/dist-types/models/models_0.d.ts

@@ -0,0 +1,1602 @@
+import type { DocumentType as __DocumentType } from "@smithy/types";
+import type { ConnectorAuthorizationMode, ConnectorToolAccess } from "./enums";
+/**
+ * A reference to a connection, held by other services in place of the credential. Resolved to a
+ * short-lived token server-to-server via GetConnectionToken.
+ * @public
+ */
+export interface ConnectionRef {
+    /**
+     * Unique identifier of a configured connection.
+     * @public
+     */
+    id: string;
+}
+/**
+ * Compact connector description used to build the model-facing connector meta-tool at agent
+ * load time. The service resolves the connector instance and its pinned definition
+ * internally from `companyId` + `id` — callers pass no definition key, version, or enabled
+ * tool list. The detailed action catalogue and usage guidance are obtained separately at
+ * runtime via the connector's reserved `help` action (`ExecuteConnector`); browsing the full
+ * definition for configuration/exploration stays on `GetConnectorDefinition`.
+ * @public
+ */
+export interface ConnectorDescription {
+    /**
+     * Connector instance identifier.
+     * @public
+     */
+    id: string;
+    /**
+     * Connector name exposed to administrators and AI agents. Used as the meta-tool name.
+     * @public
+     */
+    name: string;
+    /**
+     * Connector description exposed to administrators and AI agents. Used as the meta-tool
+     * description, which points the model at the `help` action.
+     * @public
+     */
+    description: string;
+}
+/**
+ * @public
+ */
+export interface ToolDescription {
+    /**
+     * Unique identifier of the tool
+     * @public
+     */
+    id: string;
+    /**
+     * Name of the tool, e.g.: 'send_email'
+     * @public
+     */
+    name: string;
+    /**
+     * Description of the tool for people and AI. Optional; can be overridden per agent via AgentTool.description.
+     * @public
+     */
+    description?: string | undefined;
+    /**
+     * JSON Schema (2020-12) of the tool arguments, matching Tool.input.schema. Absent for tools that take no arguments.
+     * @public
+     */
+    schema?: __DocumentType | undefined;
+}
+/**
+ * Description of one wilma-tools-backed capability, tagged by kind. Entries correspond
+ * positionally to the requested `CapabilityRefs`.
+ * @public
+ */
+export type CapabilityDescription = CapabilityDescription.ConnectorMember | CapabilityDescription.ToolMember | CapabilityDescription.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace CapabilityDescription {
+    /**
+     * Description of a standalone tool, same shape returned by `DescribeTools`.
+     * @public
+     */
+    interface ToolMember {
+        tool: ToolDescription;
+        connector?: never;
+        $unknown?: never;
+    }
+    /**
+     * Description of a configured connector, same shape returned by `DescribeConnectors`.
+     * @public
+     */
+    interface ConnectorMember {
+        tool?: never;
+        connector: ConnectorDescription;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        tool?: never;
+        connector?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        tool: (value: ToolDescription) => T;
+        connector: (value: ConnectorDescription) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * Reference to one wilma-tools-backed agent capability to describe: either a standalone
+ * Tool or a configured Connector. Mirrors the `tool` / `connector` members of the
+ * wilma-agents `AgentCapability` union.
+ * @public
+ */
+export type CapabilityRef = CapabilityRef.ConnectorMember | CapabilityRef.ToolMember | CapabilityRef.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace CapabilityRef {
+    /**
+     * Standalone tool identifier.
+     * @public
+     */
+    interface ToolMember {
+        tool: string;
+        connector?: never;
+        $unknown?: never;
+    }
+    /**
+     * Configured connector instance identifier.
+     * @public
+     */
+    interface ConnectorMember {
+        tool?: never;
+        connector: string;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        tool?: never;
+        connector?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        tool: (value: string) => T;
+        connector: (value: string) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * Company-managed connection resolved through wilma-secrets.
+ * @public
+ */
+export interface ConnectorSharedAuthorization {
+    /**
+     * Reference to a SHARED connection in wilma-secrets. The credential itself stays in
+     * wilma-secrets; the connector holds only this reference.
+     * @public
+     */
+    connection: ConnectionRef;
+}
+/**
+ * Marker selecting per-user authorization. Carries no connection reference: at execution the
+ * runtime resolves the executing user's own credential for this connector's provider through
+ * wilma-secrets (GetUserConnectionToken by provider + user). Users connect the provider
+ * themselves from the app; no admin connection is created.
+ * @public
+ */
+export interface ConnectorUserAuthorization {
+}
+/**
+ * Credential selection for a configured connector. Credentials remain in wilma-secrets.
+ * @public
+ */
+export type ConnectorAuthorization = ConnectorAuthorization.SharedMember | ConnectorAuthorization.UserMember | ConnectorAuthorization.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace ConnectorAuthorization {
+    /**
+     * Use one company-managed connection (a wilma-secrets Connection).
+     * @public
+     */
+    interface SharedMember {
+        shared: ConnectorSharedAuthorization;
+        user?: never;
+        $unknown?: never;
+    }
+    /**
+     * Resolve the executing user's own credential for the provider (a wilma-secrets USER connection).
+     * @public
+     */
+    interface UserMember {
+        shared?: never;
+        user: ConnectorUserAuthorization;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        shared?: never;
+        user?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        shared: (value: ConnectorSharedAuthorization) => T;
+        user: (value: ConnectorUserAuthorization) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * Reference to one immutable connector definition.
+ * @public
+ */
+export interface ConnectorDefinitionRef {
+    /**
+     * Stable definition identifier.
+     * @public
+     */
+    key: string;
+    /**
+     * Exact definition version.
+     * @public
+     */
+    version: string;
+}
+/**
+ * Marker: grant every tool, including DESTRUCTIVE.
+ * @public
+ */
+export interface ConnectorGrantAll {
+}
+/**
+ * Marker: grant every READ tool.
+ * @public
+ */
+export interface ConnectorGrantRead {
+}
+/**
+ * Marker: grant every READ and WRITE tool.
+ * @public
+ */
+export interface ConnectorGrantReadWrite {
+}
+/**
+ * Coarse, low-verbosity permission grant for a configured connector. The service computes the
+ * effective, server-enforced tool set by filtering the pinned definition's tools with this
+ * grant (using each tool's authoritative `ConnectorToolAccess`), and requests only the scopes
+ * the grant implies at connection time.
+ *
+ * The three coarse members carry no data (empty structures); `tools` is the advanced escape
+ * hatch that names tools explicitly.
+ * @public
+ */
+export type ConnectorToolGrant = ConnectorToolGrant.AllMember | ConnectorToolGrant.ReadMember | ConnectorToolGrant.ReadWriteMember | ConnectorToolGrant.ToolsMember | ConnectorToolGrant.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace ConnectorToolGrant {
+    /**
+     * "Allow read" — every READ tool. The common default.
+     * @public
+     */
+    interface ReadMember {
+        read: ConnectorGrantRead;
+        readWrite?: never;
+        all?: never;
+        tools?: never;
+        $unknown?: never;
+    }
+    /**
+     * "Allow write" — every READ and WRITE tool; DESTRUCTIVE tools excluded.
+     * @public
+     */
+    interface ReadWriteMember {
+        read?: never;
+        readWrite: ConnectorGrantReadWrite;
+        all?: never;
+        tools?: never;
+        $unknown?: never;
+    }
+    /**
+     * "Full access" — every tool, including DESTRUCTIVE.
+     * @public
+     */
+    interface AllMember {
+        read?: never;
+        readWrite?: never;
+        all: ConnectorGrantAll;
+        tools?: never;
+        $unknown?: never;
+    }
+    /**
+     * Advanced: an explicit allowlist of tool ids, regardless of access class.
+     * @public
+     */
+    interface ToolsMember {
+        read?: never;
+        readWrite?: never;
+        all?: never;
+        tools: string[];
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        read?: never;
+        readWrite?: never;
+        all?: never;
+        tools?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        read: (value: ConnectorGrantRead) => T;
+        readWrite: (value: ConnectorGrantReadWrite) => T;
+        all: (value: ConnectorGrantAll) => T;
+        tools: (value: string[]) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * Company-owned configured connector.
+ * @public
+ */
+export interface Connector {
+    /**
+     * Immutable definition used to validate configuration and execute tools.
+     * @public
+     */
+    definition: ConnectorDefinitionRef;
+    /**
+     * Values validated against the definition configuration schema.
+     * @public
+     */
+    configuration: __DocumentType;
+    /**
+     * Credential selection, omitted when no authorization is required. The same wilma-secrets
+     * connection reference may be reused across multiple Tools and Connectors.
+     * @public
+     */
+    authorization?: ConnectorAuthorization | undefined;
+    /**
+     * Name exposed to administrators and AI agents.
+     * @public
+     */
+    name: string;
+    /**
+     * Description exposed to administrators and AI agents.
+     * @public
+     */
+    description: string;
+    /**
+     * Which tools are available to callers and agents. Use a coarse grant (`read` / `readWrite`
+     * / `all`) for most connectors; use `tools` for an explicit allowlist. Server-enforced for
+     * `ExecuteConnector`.
+     * @public
+     */
+    grant: ConnectorToolGrant;
+    /**
+     * Unique connector instance identifier.
+     * @public
+     */
+    id: string;
+    /**
+     * Company that owns this connector.
+     * @public
+     */
+    companyId: string;
+    /**
+     * Monotonic revision, incremented on every update. Pass it back on update for optimistic locking.
+     * @public
+     */
+    revision: number;
+}
+/**
+ * Authorization requirements declared by a connector definition.
+ *
+ * Scopes are NOT declared here. The set of OAuth scopes a connection needs is derived at
+ * runtime from the tools a `ConnectorToolGrant` actually enables — the union of their
+ * `authorizationScopes` — layered on the default scopes of the wilma-secrets
+ * `Provider`. This makes least-privilege automatic (a `read` grant requests only the read
+ * tools' scopes) and removes the definition-vs-granted duplication.
+ * @public
+ */
+export interface ConnectorAuthorizationDefinition {
+    /**
+     * Provider key the connector authenticates against, e.g. `salesforce`.
+     * @public
+     */
+    provider: string;
+    /**
+     * Credential resolution modes supported by this connector.
+     * @public
+     */
+    modes: ConnectorAuthorizationMode[];
+}
+/**
+ * Configuration contract rendered by management clients and validated by the service.
+ * @public
+ */
+export interface ConnectorConfigurationDefinition {
+    /**
+     * JSON Schema 2020-12 document describing persisted configuration.
+     * @public
+     */
+    schema: __DocumentType;
+    /**
+     * Presentation hints for a compatible JSON Schema form renderer.
+     * @public
+     */
+    uiSchema?: __DocumentType | undefined;
+}
+/**
+ * Display metadata for a connector catalog entry.
+ * @public
+ */
+export interface ConnectorMetadata {
+    /**
+     * Human-readable connector name.
+     * @public
+     */
+    title: string;
+    /**
+     * Summary of the external system and supported use cases.
+     * @public
+     */
+    description: string;
+    /**
+     * Icon URL or renderer-known icon key.
+     * @public
+     */
+    icon?: string | undefined;
+    /**
+     * Catalog category used for discovery and filtering.
+     * @public
+     */
+    category?: string | undefined;
+    /**
+     * Link to external connector documentation.
+     * @public
+     */
+    documentationUrl?: string | undefined;
+}
+/**
+ * A named, on-demand help document. Reference documents implement progressive disclosure for
+ * rich connectors: the `help` index lists each reference's `name` + `summary`, and the model
+ * loads a document's `content` only when it decides it needs it (`\{"help": \{"reference": "..."\}\}`).
+ * This keeps a 100-tool connector from dumping every schema and guide into the context at once.
+ * @public
+ */
+export interface ConnectorReference {
+    /**
+     * Load key, unique within the definition.
+     * @public
+     */
+    name: string;
+    /**
+     * Human-readable title.
+     * @public
+     */
+    title: string;
+    /**
+     * One-line summary shown in the `help` index so the model can decide whether to load it.
+     * @public
+     */
+    summary: string;
+    /**
+     * Full Markdown body, returned only when the model loads this reference by name.
+     * @public
+     */
+    content: string;
+}
+/**
+ * @public
+ */
+export interface ToolInput {
+    /**
+     * JSON Schema (2020-12) describing the tool arguments. The model is offered this schema (minus any agent-predefined fields); ExecuteTool input is validated against it.
+     * @public
+     */
+    schema: __DocumentType;
+}
+/**
+ * Tool exposed by a connector definition.
+ * @public
+ */
+export interface ConnectorTool {
+    /**
+     * Stable dispatch identifier used in `ExecuteConnector` input keys.
+     * @public
+     */
+    id: string;
+    /**
+     * Agent-facing tool name.
+     * @public
+     */
+    name: string;
+    /**
+     * One-line description used by people and AI agents to select the tool. Kept short — it
+     * appears in the `help` index for every enabled tool; extended guidance goes in `docs`.
+     * @public
+     */
+    description: string;
+    /**
+     * Authoritative access class. Required so the service can compute the effective tool set
+     * from a coarse `ConnectorToolGrant` and derive least-privilege scopes.
+     * @public
+     */
+    access: ConnectorToolAccess;
+    /**
+     * Whether repeating the call with identical arguments has no additional effect (retry-safe).
+     * The only behavioral hint kept: read/write/destructive come from `access`, and an
+     * "open world" flag carried no signal for connectors (which are external by definition).
+     * @public
+     */
+    idempotent?: boolean | undefined;
+    /**
+     * Optional grouping used to organize large catalogs in the `help` index and management UI
+     * (e.g. "Issues", "Pull requests"). Not an access control.
+     * @public
+     */
+    category?: string | undefined;
+    /**
+     * Tool arguments exposed to agents, using the same contract as `Tool.input`.
+     * @public
+     */
+    input: ToolInput;
+    /**
+     * Per-tool configuration contract, filled by an administrator when a Tool is created
+     * from this connector tool; values are stored on `ToolConnectorHandler.toolConfiguration`.
+     * Distinct from the definition-level `configuration`, which an administrator fills once
+     * when adding the connector itself (instance-wide concerns such as transport, credentials,
+     * or sender identity) — this contract covers what varies per created Tool (e.g. a webhook
+     * tool's URL and body template, an sms tool's message template). Omitted when the tool
+     * needs no per-tool configuration.
+     * @public
+     */
+    configuration?: ConnectorConfigurationDefinition | undefined;
+    /**
+     * Worked examples returned in this tool's `help` detail. Teach argument shape and common
+     * call patterns; not shown in the `help` index.
+     * @public
+     */
+    examples?: string[] | undefined;
+    /**
+     * Long-form Markdown usage notes returned in this tool's `help` detail (edge cases, field
+     * semantics, prerequisites such as "call `issues.list` first to get an id"). Loaded on
+     * demand, never in the index.
+     * @public
+     */
+    docs?: string | undefined;
+    /**
+     * Extra OAuth scopes this tool needs. The runtime unions these across the tools a grant
+     * enables to derive the connection's scope set; nothing is declared at the connector level.
+     * @public
+     */
+    authorizationScopes?: string[] | undefined;
+}
+/**
+ * Immutable server-owned connector definition.
+ *
+ * Both external integrations (e.g. `sentry`) and built-in tool providers (e.g. `email`,
+ * `webhook`, `search`, `chat`, `sms`, `calendar`) are published through this shape and served
+ * from the same catalog. Built-in definitions are derived from the service's code-first
+ * provider registry (a TypeScript module per provider colocating schemas and handler) and
+ * follow the same immutable versioning: a breaking change to a provider's configuration or
+ * input schema publishes a new version, and the handler keeps serving tools pinned to older
+ * versions.
+ * @public
+ */
+export interface ConnectorDefinition {
+    /**
+     * Stable key and exact immutable version.
+     * @public
+     */
+    ref: ConnectorDefinitionRef;
+    /**
+     * Catalog display metadata.
+     * @public
+     */
+    metadata: ConnectorMetadata;
+    /**
+     * Connector instance configuration contract.
+     * @public
+     */
+    configuration: ConnectorConfigurationDefinition;
+    /**
+     * Authorization requirements, omitted when the connector needs no credentials.
+     * @public
+     */
+    authorization?: ConnectorAuthorizationDefinition | undefined;
+    /**
+     * Main help document (Markdown): the overview the model reads first via `\{"help": \{\}\}` —
+     * what the connector is for, how to work with it, and how its tools fit together. It should
+     * orient, not enumerate: the service appends the per-grant action index and the list of
+     * available reference documents automatically. Deep material belongs in `references`.
+     * @public
+     */
+    instructions?: string | undefined;
+    /**
+     * On-demand reference documents for progressive disclosure. Listed (name + summary) in the
+     * `help` index and loaded individually by name; keeps rich connectors from overwhelming the
+     * model's context.
+     * @public
+     */
+    references?: ConnectorReference[] | undefined;
+    /**
+     * Tools available in this definition version.
+     * @public
+     */
+    tools: ConnectorTool[];
+    /**
+     * Whether new instances should avoid this definition.
+     * @public
+     */
+    deprecated?: boolean | undefined;
+    /**
+     * Suggested replacement when this definition is deprecated.
+     * @public
+     */
+    replacedBy?: ConnectorDefinitionRef | undefined;
+}
+/**
+ * Result of executing a connector.
+ * @public
+ */
+export interface ConnectorExecutionResult {
+    /**
+     * Structured tool output.
+     * @public
+     */
+    output: __DocumentType;
+    /**
+     * Identifier used to correlate logs and traces.
+     * @public
+     */
+    executionId: string;
+    /**
+     * Definition version used for validation and execution.
+     * @public
+     */
+    definitionVersion: string;
+}
+/**
+ * Fields supplied when a connector is created or replaced.
+ * @public
+ */
+export interface CreateConnectorInput {
+    /**
+     * Immutable definition used to validate configuration and execute tools.
+     * @public
+     */
+    definition: ConnectorDefinitionRef;
+    /**
+     * Values validated against the definition configuration schema.
+     * @public
+     */
+    configuration: __DocumentType;
+    /**
+     * Credential selection, omitted when no authorization is required. The same wilma-secrets
+     * connection reference may be reused across multiple Tools and Connectors.
+     * @public
+     */
+    authorization?: ConnectorAuthorization | undefined;
+    /**
+     * Name exposed to administrators and AI agents.
+     * @public
+     */
+    name: string;
+    /**
+     * Description exposed to administrators and AI agents.
+     * @public
+     */
+    description: string;
+    /**
+     * Which tools are available to callers and agents. Use a coarse grant (`read` / `readWrite`
+     * / `all`) for most connectors; use `tools` for an explicit allowlist. Server-enforced for
+     * `ExecuteConnector`.
+     * @public
+     */
+    grant: ConnectorToolGrant;
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface CreateConnectorOutput {
+    /**
+     * Created connector.
+     * @public
+     */
+    connector: Connector;
+}
+/**
+ * Handler for a connector-backed Tool created through `CreateTool`.
+ *
+ * Carries two configuration layers: `configuration` (from the mixin) holds the
+ * definition-level values an administrator supplies for the connector as a whole
+ * (transport, credentials, sender identity — validated against the definition
+ * `configuration.schema`), while `toolConfiguration` holds the values specific to this
+ * created Tool (validated against the pinned connector tool's `configuration.schema`).
+ *
+ * `Tool.input` follows copy-at-create semantics: when `input` is omitted on create, the
+ * service snapshots the pinned connector tool's input schema into the Tool; callers may
+ * instead provide — and later edit — a custom schema (e.g. remove a field from the input and
+ * supply it as a static value in `toolConfiguration`). The Tool owns its copy; definition
+ * changes never propagate to existing tools. Reshaping the input of a tool whose handler
+ * does not consume input through configuration templates fails at execution, not at write.
+ * @public
+ */
+export interface ToolConnectorHandler {
+    /**
+     * Immutable definition used to validate configuration and execute tools.
+     * @public
+     */
+    definition: ConnectorDefinitionRef;
+    /**
+     * Values validated against the definition configuration schema.
+     * @public
+     */
+    configuration: __DocumentType;
+    /**
+     * Credential selection, omitted when no authorization is required. The same wilma-secrets
+     * connection reference may be reused across multiple Tools and Connectors.
+     * @public
+     */
+    authorization?: ConnectorAuthorization | undefined;
+    /**
+     * Connector tool from the pinned definition executed by this Tool.
+     * @public
+     */
+    toolId: string;
+    /**
+     * Values validated against the pinned connector tool's per-tool configuration schema
+     * (`ConnectorTool.configuration.schema`). Omitted when that tool declares no per-tool
+     * configuration contract.
+     * @public
+     */
+    toolConfiguration?: __DocumentType | undefined;
+}
+/**
+ * @public
+ */
+export type ToolMcpAuthorization = ToolMcpAuthorization.ConnectionMember | ToolMcpAuthorization.CustomHeadersMember | ToolMcpAuthorization.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace ToolMcpAuthorization {
+    /**
+     * Reference to a reusable authorization in wilma-secrets (a Connection), shared across MCP servers and tools.
+     * @public
+     */
+    interface ConnectionMember {
+        connection: ConnectionRef;
+        customHeaders?: never;
+        $unknown?: never;
+    }
+    /**
+     * Custom headers authorization (use headers map for custom auth headers)
+     * @public
+     */
+    interface CustomHeadersMember {
+        connection?: never;
+        customHeaders: Record<string, string>;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        connection?: never;
+        customHeaders?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        connection: (value: ConnectionRef) => T;
+        customHeaders: (value: Record<string, string>) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * @public
+ */
+export interface ToolMcpHandler {
+    /**
+     * MCP server endpoint URL
+     * @public
+     */
+    serverUrl: string;
+    /**
+     * Authorization configuration (API key, bearer token, or custom headers). Optional - MCP servers can be configured without authorization.
+     * @public
+     */
+    authorization?: ToolMcpAuthorization | undefined;
+    /**
+     * List of tools enabled for this MCP server.
+     * @public
+     */
+    tools: string[];
+}
+/**
+ * @public
+ */
+export interface ToolMcpToolHandler {
+    /**
+     * ID of the Tool that represents the MCP server connection (the Tool with handler.mcp containing serverUrl and authorization)
+     * @public
+     */
+    mcpToolId: string;
+    /**
+     * Name of the tool on the MCP server. This matches the tool name returned from DiscoverTools operation.
+     * @public
+     */
+    mcpToolName: string;
+}
+/**
+ * Handler of the tool. Every tool executes through one of three mechanisms: a pinned connector definition (built-in providers such as email, webhook, search, chat, sms, calendar — and external integrations — share the same contract), an MCP server registration, or a single tool on a registered MCP server.
+ * @public
+ */
+export type ToolHandler = ToolHandler.ConnectorMember | ToolHandler.McpMember | ToolHandler.McpToolMember | ToolHandler.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace ToolHandler {
+    /**
+     * Connector-backed Tool executing one tool from a pinned, immutable connector definition served by the connector catalog (ListConnectorDefinitions). Configuration is validated against the definition's configSchema on the backend; credentials referenced from the configuration are resolved server-to-server at execution time.
+     * @public
+     */
+    interface ConnectorMember {
+        connector: ToolConnectorHandler;
+        mcp?: never;
+        mcpTool?: never;
+        $unknown?: never;
+    }
+    /**
+     * MCP server registration: endpoint, authorization and the list of enabled tools.
+     * @public
+     */
+    interface McpMember {
+        connector?: never;
+        mcp: ToolMcpHandler;
+        mcpTool?: never;
+        $unknown?: never;
+    }
+    /**
+     * A single tool exposed by a registered MCP server.
+     * @public
+     */
+    interface McpToolMember {
+        connector?: never;
+        mcp?: never;
+        mcpTool: ToolMcpToolHandler;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        connector?: never;
+        mcp?: never;
+        mcpTool?: never;
+        $unknown: [string, any];
+    }
+    /**
+     * @deprecated unused in schema-serde mode.
+     *
+     */
+    interface Visitor<T> {
+        connector: (value: ToolConnectorHandler) => T;
+        mcp: (value: ToolMcpHandler) => T;
+        mcpTool: (value: ToolMcpToolHandler) => T;
+        _: (name: string, value: any) => T;
+    }
+}
+/**
+ * @public
+ */
+export interface CreateToolInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Name of the tool, e.g.: 'send_email'
+     * @public
+     */
+    name: string;
+    /**
+     * Category of the tool, e.g.: 'Support'
+     * @public
+     */
+    category: string;
+    /**
+     * Description of the tool, used by AI to understand the purpose of the tool. Optional.
+     * @public
+     */
+    description?: string | undefined;
+    /**
+     * Agent arguments (copy-at-create). For connector-backed tools, omit to copy the pinned connector tool's input schema into the created Tool, or provide a custom schema. The created Tool owns its copy; later definition changes never propagate.
+     * @public
+     */
+    input?: ToolInput | undefined;
+    /**
+     * Handler of the tool, used to execute the tool.
+     * @public
+     */
+    handler: ToolHandler;
+}
+/**
+ * @public
+ */
+export interface Tool {
+    /**
+     * Unique identifier of the tool
+     * @public
+     */
+    id: string;
+    /**
+     * Company ID that owns this tool
+     * @public
+     */
+    companyId: string;
+    /**
+     * Name of the tool, e.g.: 'send_email'
+     * @public
+     */
+    name: string;
+    /**
+     * Category of the tool, e.g.: 'Support'
+     * @public
+     */
+    category: string;
+    /**
+     * Description of the tool for people and AI. Optional; can be overridden per agent via AgentTool.description.
+     * @public
+     */
+    description?: string | undefined;
+    /**
+     * Tool arguments owned by this tool (copy-at-create). For connector-backed tools the service snapshots the pinned connector tool's input schema here when the caller omits it; the caller may also supply or later edit a custom schema. Definition changes never propagate to existing tools. Absent only for tools that take no arguments (e.g. MCP server registrations).
+     * @public
+     */
+    input?: ToolInput | undefined;
+    /**
+     * Handler of the tool, used to execute the tool
+     * @public
+     */
+    handler: ToolHandler;
+    /**
+     * Monotonic revision, incremented on every update. Pass it back on update for optimistic locking.
+     * @public
+     */
+    revision: number;
+}
+/**
+ * @public
+ */
+export interface CreateToolOutput {
+    tool: Tool;
+}
+/**
+ * @public
+ */
+export interface DeleteConnectorInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Connector instance identifier.
+     * @public
+     */
+    connectorId: string;
+}
+/**
+ * @public
+ */
+export interface DeleteConnectorOutput {
+}
+/**
+ * @public
+ */
+export interface DeleteToolInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Unique identifier of the tool.
+     * @public
+     */
+    toolId: string;
+}
+/**
+ * @public
+ */
+export interface DeleteToolOutput {
+}
+/**
+ * @public
+ */
+export interface DescribeCapabilitiesInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Tool and connector references to describe.
+     * @public
+     */
+    capabilities: CapabilityRef[];
+}
+/**
+ * @public
+ */
+export interface DescribeCapabilitiesOutput {
+    /**
+     * Capability descriptions, corresponding positionally to the requested `capabilities`.
+     * @public
+     */
+    descriptions: CapabilityDescription[];
+}
+/**
+ * @public
+ */
+export interface DescribeConnectorsInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Configured connector instance identifiers.
+     * @public
+     */
+    ids: string[];
+}
+/**
+ * @public
+ */
+export interface DescribeConnectorsOutput {
+    /**
+     * Connector descriptions, one per requested id.
+     * @public
+     */
+    descriptions: ConnectorDescription[];
+}
+/**
+ * @public
+ */
+export interface DescribeToolsInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * List of tool IDs.
+     * @public
+     */
+    ids: string[];
+}
+/**
+ * @public
+ */
+export interface DescribeToolsOutput {
+    /**
+     * List of tool descriptions.
+     * @public
+     */
+    descriptions: ToolDescription[];
+}
+/**
+ * @public
+ */
+export interface DiscoveredTool {
+    /**
+     * Name of the tool on the MCP server
+     * @public
+     */
+    name: string;
+    /**
+     * Description of the tool
+     * @public
+     */
+    description: string;
+    /**
+     * JSON Schema for the tool's input parameters
+     * @public
+     */
+    inputSchema: __DocumentType;
+}
+/**
+ * @public
+ */
+export interface DiscoverToolsInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * MCP server endpoint URL
+     * @public
+     */
+    serverUrl: string;
+    /**
+     * Authorization configuration (API key, bearer token, or custom headers)
+     * @public
+     */
+    authorization?: ToolMcpAuthorization | undefined;
+}
+/**
+ * @public
+ */
+export interface DiscoverToolsOutput {
+    /**
+     * List of discovered tools from the MCP server
+     * @public
+     */
+    tools: DiscoveredTool[];
+}
+/**
+ * @public
+ */
+export interface ExecuteConnectorInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Connector instance identifier.
+     * @public
+     */
+    connectorId: string;
+    /**
+     * Invocation payload from the model or agent. For multi-tool connectors this
+     * is typically an object with exactly one connector tool id key and argument object.
+     *
+     * `help` is a reserved, progressive-disclosure action producing guidance in `result.output`
+     * (nothing external is dispatched; a definition must not declare a tool with id `help`):
+     *   - `\{"help": \{\}\}` — the INDEX: the connector's `instructions` overview, the enabled
+     *     actions grouped by `category` (id, name, one-line description, access) filtered by the
+     *     grant, and the list of reference documents (name + summary). Deliberately omits input
+     *     schemas, examples, and long docs so a rich connector stays light on first read.
+     *   - `\{"help": \{"action": "<toolId>"\}\}` — DETAIL for one action: full input schema,
+     *     `examples`, and `docs`.
+     *   - `\{"help": \{"reference": "<name>"\}\}` — the full body of one reference document.
+     *   - `\{"help": \{"category": "<name>"\}\}` — details for every action in a category.
+     * The model reads the index first, then loads only the action or reference it needs.
+     * @public
+     */
+    input: __DocumentType;
+    /**
+     * Service executing the connector, such as `chatbots` or `voicebots`.
+     * @public
+     */
+    service?: string | undefined;
+    /**
+     * User identity required by user-authorized connectors.
+     * @public
+     */
+    user?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface ExecuteConnectorOutput {
+    /**
+     * Structured tool result and execution metadata.
+     * @public
+     */
+    result: ConnectorExecutionResult;
+}
+/**
+ * @public
+ */
+export interface ExecuteToolInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Unique identifier of the tool.
+     * @public
+     */
+    id: string;
+    /**
+     * Input of the tool, used to pass data to the tool.
+     * @public
+     */
+    input: __DocumentType;
+    /**
+     * Optional parameter, by which service the tool is executed, e.g. chatbots.
+     * @public
+     */
+    service?: string | undefined;
+    /**
+     * Optional parameter, for which user the tool is executed, e.g. john.doe@example.com.
+     * @public
+     */
+    user?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface ToolExecutionResult {
+    /**
+     * Output of the tool execution
+     * @public
+     */
+    output: __DocumentType;
+}
+/**
+ * @public
+ */
+export interface ExecuteToolOutput {
+    /**
+     * Result of the tool execution.
+     * @public
+     */
+    result: ToolExecutionResult;
+}
+/**
+ * @public
+ */
+export interface GetConnectorInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Connector instance identifier.
+     * @public
+     */
+    connectorId: string;
+}
+/**
+ * @public
+ */
+export interface GetConnectorOutput {
+    /**
+     * Requested connector.
+     * @public
+     */
+    connector: Connector;
+}
+/**
+ * @public
+ */
+export interface GetConnectorDefinitionInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Stable connector definition key.
+     * @public
+     */
+    key: string;
+    /**
+     * Exact immutable definition version.
+     * @public
+     */
+    version: string;
+}
+/**
+ * @public
+ */
+export interface GetConnectorDefinitionOutput {
+    /**
+     * Requested connector definition.
+     * @public
+     */
+    definition: ConnectorDefinition;
+}
+/**
+ * @public
+ */
+export interface GetToolInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Unique identifier of the tool.
+     * @public
+     */
+    toolId: string;
+}
+/**
+ * @public
+ */
+export interface GetToolOutput {
+    /**
+     * Tool object with configuration.
+     * @public
+     */
+    tool: Tool;
+}
+/**
+ * @public
+ */
+export interface ListConnectorDefinitionsInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Case-insensitive filter applied to connector titles, keys, and descriptions.
+     * @public
+     */
+    query?: string | undefined;
+    /**
+     * Maximum number of definitions to return.
+     * @public
+     */
+    pageSize?: number | undefined;
+    /**
+     * Token returned by the previous request.
+     * @public
+     */
+    nextToken?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface ListConnectorDefinitionsOutput {
+    /**
+     * Connector definitions in the current page.
+     * @public
+     */
+    definitions: ConnectorDefinition[];
+    /**
+     * Token for the next page, omitted when no more results exist.
+     * @public
+     */
+    nextToken?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface ListConnectorsInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Maximum number of connectors to return.
+     * @public
+     */
+    pageSize?: number | undefined;
+    /**
+     * Token returned by the previous request.
+     * @public
+     */
+    nextToken?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface ListConnectorsOutput {
+    /**
+     * Connectors in the current page.
+     * @public
+     */
+    connectors: Connector[];
+    /**
+     * Token for the next page, omitted when no more results exist.
+     * @public
+     */
+    nextToken?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface ListToolsInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface ListToolsOutput {
+    /**
+     * List of tools.
+     * @public
+     */
+    tools: Tool[];
+}
+/**
+ * @public
+ */
+export interface ResolveConnectorConfigurationInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Stable connector definition key.
+     * @public
+     */
+    key: string;
+    /**
+     * Exact immutable definition version.
+     * @public
+     */
+    version: string;
+    /**
+     * When set, resolve the per-tool configuration contract of this connector tool
+     * (`ConnectorTool.configuration`) instead of the definition-level configuration.
+     * @public
+     */
+    toolId?: string | undefined;
+    /**
+     * Current partial form values.
+     * @public
+     */
+    values: __DocumentType;
+    /**
+     * Credentials used to resolve account-dependent options.
+     * @public
+     */
+    authorization?: ConnectorAuthorization | undefined;
+    /**
+     * Executing user when user authorization is selected.
+     * @public
+     */
+    user?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface ResolveConnectorConfigurationOutput {
+    /**
+     * Configuration contract resolved for the current values and account.
+     * @public
+     */
+    configuration: ConnectorConfigurationDefinition;
+}
+/**
+ * Fields supplied when a connector is created or replaced.
+ * @public
+ */
+export interface UpdateConnectorInput {
+    /**
+     * Immutable definition used to validate configuration and execute tools.
+     * @public
+     */
+    definition: ConnectorDefinitionRef;
+    /**
+     * Values validated against the definition configuration schema.
+     * @public
+     */
+    configuration: __DocumentType;
+    /**
+     * Credential selection, omitted when no authorization is required. The same wilma-secrets
+     * connection reference may be reused across multiple Tools and Connectors.
+     * @public
+     */
+    authorization?: ConnectorAuthorization | undefined;
+    /**
+     * Name exposed to administrators and AI agents.
+     * @public
+     */
+    name: string;
+    /**
+     * Description exposed to administrators and AI agents.
+     * @public
+     */
+    description: string;
+    /**
+     * Which tools are available to callers and agents. Use a coarse grant (`read` / `readWrite`
+     * / `all`) for most connectors; use `tools` for an explicit allowlist. Server-enforced for
+     * `ExecuteConnector`.
+     * @public
+     */
+    grant: ConnectorToolGrant;
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Connector instance identifier.
+     * @public
+     */
+    connectorId: string;
+    /**
+     * Connector revision this update is based on (optimistic locking). When it does not match the
+     * current revision, RevisionConflictException is returned.
+     * @public
+     */
+    revision: number;
+}
+/**
+ * @public
+ */
+export interface UpdateConnectorOutput {
+    /**
+     * Updated connector.
+     * @public
+     */
+    connector: Connector;
+}
+/**
+ * @public
+ */
+export interface UpdateToolInput {
+    /**
+     * The unique identifier of the tenant when a service token is used.
+     * @public
+     */
+    companyId?: string | undefined;
+    /**
+     * Unique identifier of the tool.
+     * @public
+     */
+    toolId: string;
+    /**
+     * Tool revision this update is based on (optimistic locking). When it does not match the current revision, RevisionConflictException is returned.
+     * @public
+     */
+    revision: number;
+    /**
+     * Name of the tool, e.g.: 'send_email'
+     * @public
+     */
+    name: string;
+    /**
+     * Category of the tool, e.g.: 'Support'
+     * @public
+     */
+    category: string;
+    /**
+     * Description of the tool, used by AI to understand the purpose of the tool. Optional.
+     * @public
+     */
+    description?: string | undefined;
+    /**
+     * Agent arguments (copy semantics). For connector-backed tools, omit to re-copy the pinned connector tool's input schema, or provide a custom schema to keep or change the tool's own copy.
+     * @public
+     */
+    input?: ToolInput | undefined;
+    /**
+     * Handler of the tool, used to execute the tool.
+     * @public
+     */
+    handler: ToolHandler;
+}
+/**
+ * @public
+ */
+export interface UpdateToolOutput {
+    /**
+     * Updated tool object with configuration.
+     * @public
+     */
+    tool: Tool;
+}