@stacklink/sdk 0.2.0

package/dist/src/sdk/index.d.ts

@@ -0,0 +1,3443 @@
+import { type StacklinkMetaToolName, type StacklinkMetaToolSurface } from '../domain/stacklink-meta-tools.js';
+import type { KnowledgeMetaToolName } from '../domain/knowledge-meta-tools.js';
+import { type PlatformMcpToolName } from '../domain/platform-mcp-tools.js';
+import type { ProviderBrandDescriptor } from '../domain/provider-branding.js';
+import type { MemoryMetaToolName } from '../domain/memory-meta-tools.js';
+import type { MemoryContextInput, MemoryConversationTurnInput, MemoryConnectedSourceInput, MemoryConnectedSourcePreviewInput, MemoryExportInput, MemoryGraphQueryInput, MemoryIngestInput, MemoryRichIngestInput, MemoryLegalHoldInput, MemoryPolicyPreviewInput, MemoryProjectPolicyInput, MemoryProjectPolicyUpdateInput, MemorySearchInput, MemorySourceBindingInput, MemorySourceBindingUpdateInput, MemorySubjectRef } from '../domain/memory-contract.js';
+export type { ProviderBrandDescriptor };
+export type { MemoryContextInput, MemoryConversationTurnInput, MemoryConnectedSourceInput, MemoryConnectedSourcePreviewInput, MemoryExportInput, MemoryGraphQueryInput, MemoryIngestInput, MemoryRichIngestInput, MemoryLegalHoldInput, MemoryPolicyPreviewInput, MemoryProjectPolicyInput, MemoryProjectPolicyUpdateInput, MemorySearchInput, MemorySourceBindingInput, MemorySourceBindingUpdateInput, MemorySubjectRef, };
+export { StacklinkMemoryLifecycle, StacklinkMemoryLifecycleError, createStacklinkMemoryLifecycle, serializeCompletedConversationTurn, } from './memory-lifecycle.js';
+export type { StacklinkMemoryAvailabilityMode, StacklinkMemoryCaptureMode, StacklinkMemoryDiagnostic, StacklinkMemoryLifecycleOptions, StacklinkMemorySessionLike, StacklinkMemoryTurnContext, StacklinkMemoryTurnOptions, } from './memory-lifecycle.js';
+export declare const platformToolSurfaceNames: readonly ["PLATFORM_LIST_AUTH_CONFIGS", "PLATFORM_LIST_SESSIONS", "PLATFORM_UPDATE_WORKBENCH_PROVIDER_ACCESS", "PLATFORM_LIST_WORKSPACES", "PLATFORM_LIST_MEMBERS", "PLATFORM_LIST_WORKBENCH_BUDGETS", "PLATFORM_QUERY_LOGS", "PLATFORM_GET_EXECUTION_DETAILS", "PLATFORM_ENABLE_TOOLKIT", "PLATFORM_CREATE_TRIGGER", "PLATFORM_GET_WEBHOOK", "PLATFORM_UPDATE_WEBHOOK", "PLATFORM_ROTATE_WEBHOOK_SECRET", "PLATFORM_APPROVE_WEBHOOK_SECRET_ROTATION", "PLATFORM_SEND_WEBHOOK_TEST", "PLATFORM_PROPOSE_AUTH_CONFIG", "PLATFORM_APPROVE_AUTH_CONFIG", "PLATFORM_PROPOSE_API_KEY", "PLATFORM_APPROVE_API_KEY", "PLATFORM_REVOKE_API_KEY", "PLATFORM_PROPOSE_WORKSPACE_MUTATION", "PLATFORM_APPROVE_WORKSPACE_MUTATION", "PLATFORM_PROPOSE_WORKBENCH_BUDGET", "PLATFORM_APPROVE_WORKBENCH_BUDGET", "PLATFORM_APPROVE_EXECUTION", "PLATFORM_DENY_APPROVAL", "PLATFORM_CANCEL_APPROVAL"];
+export type PlatformToolSurfaceName = PlatformMcpToolName;
+export type StacklinkFetch = typeof fetch;
+export type StacklinkMcpToolName = StacklinkMetaToolName | PlatformMcpToolName | KnowledgeMetaToolName | MemoryMetaToolName;
+export type StacklinkToolSurfaceName = StacklinkMcpToolName | (string & {});
+export declare const stacklinkTypeScriptSdkVersion = "0.2.0";
+export declare class StacklinkApiError extends Error {
+    readonly statusCode: number;
+    readonly code?: string | undefined;
+    readonly details?: unknown | undefined;
+    constructor(message: string, statusCode: number, code?: string | undefined, details?: unknown | undefined);
+}
+type QueryPrimitive = string | number | boolean | null | undefined;
+type QueryValue = QueryPrimitive | QueryPrimitive[];
+export type JsonRecord = Record<string, unknown>;
+export type StacklinkExecutionKind = 'tool' | 'batch' | 'workbench_bash' | 'workbench_code' | 'workbench_proxy';
+export interface StacklinkRequestOptions {
+    signal?: AbortSignal | undefined;
+}
+interface StacklinkRequestInit extends StacklinkRequestOptions {
+    method?: string | undefined;
+    body?: unknown;
+    query?: Record<string, QueryValue> | undefined;
+    registration?: boolean | undefined;
+    headers?: Record<string, string> | undefined;
+}
+export interface StacklinkMcpProgressNotification {
+    jsonrpc: '2.0';
+    method: 'notifications/progress';
+    params: {
+        progressToken: string | number;
+        progress: number;
+        total?: number | undefined;
+        message?: string | undefined;
+    };
+}
+export interface StacklinkMcpStreamOptions extends StacklinkRequestOptions {
+    onProgress?: (notification: StacklinkMcpProgressNotification['params']) => void;
+}
+export interface StacklinkExecutionCapability {
+    mode?: 'sync' | 'background_job' | 'streaming' | 'hybrid' | undefined;
+    cancellable: 'hard' | 'cooperative' | 'request_only' | 'none';
+    streamingSupport: 'none' | 'progress' | 'output_delta' | 'both';
+    backgroundSupport: 'none' | 'optional' | 'required';
+    parallelSafety?: 'safe' | 'account_serial' | 'resource_serial' | 'unsafe' | undefined;
+    defaultTimeoutMs?: number | undefined;
+    maxTimeoutMs?: number | undefined;
+    idempotency?: {
+        requiredForMutation?: boolean | undefined;
+        providerIdempotencyKey?: string | undefined;
+    } | undefined;
+}
+export interface StacklinkToolOutputPolicy {
+    maxInlineBytes: number;
+    largeResult: 'inline' | 'preview_and_artifact' | 'workbench_sync' | 'reject';
+    artifactExtractors: Array<{
+        kind: 'provider_url' | 'file_bytes' | 'export_ref' | 'attachment';
+        path: string[];
+        contentTypePath?: string[] | undefined;
+        sizeBytesPath?: string[] | undefined;
+        expiresAtPath?: string[] | undefined;
+    }>;
+    redactionProfile: 'default_provider' | 'financial' | 'messaging' | 'file';
+}
+export interface StacklinkToolFamily {
+    familyKey: string;
+    resource: string;
+    operationKind: 'list' | 'get' | 'create' | 'update' | 'delete' | 'export' | 'job_start' | 'job_status';
+    workflowTags: string[];
+}
+export interface StacklinkToolNavigation {
+    categoryKey: string;
+    categoryLabel: string;
+    categoryOrder: number;
+    moduleKey: string;
+    moduleLabel: string;
+    moduleOrder: number;
+    actionLabel: string;
+    actionOrder?: number | undefined;
+    facets: string[];
+}
+export interface StacklinkProviderOperation {
+    transport: 'rest' | 'graphql' | 'sdk' | 'local' | 'mcp';
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | undefined;
+    path?: string | undefined;
+    graphqlOperationName?: string | undefined;
+    docsUrl?: string | undefined;
+    source: 'official_openapi' | 'official_docs' | 'hand_authored';
+}
+export interface StacklinkToolAuthPolicy {
+    connectionRequired: boolean;
+    scopeRequirements: Array<{
+        all?: string[] | undefined;
+        any?: string[] | undefined;
+        authModes?: string[] | undefined;
+        reauthRequired?: boolean | undefined;
+        allowProviderValidatedFallback?: boolean | undefined;
+    }>;
+    rawAccess?: {
+        enabled?: boolean | undefined;
+        tenantFlag?: string | undefined;
+        appFlag?: string | undefined;
+        approvalRequired?: boolean | undefined;
+    } | undefined;
+    confirmation: {
+        required: boolean;
+        exactToolKey: boolean;
+    };
+    approval?: {
+        required: boolean;
+        reason?: string | undefined;
+    } | undefined;
+}
+export type ProviderConnectorType = 'app' | 'platform' | 'sandbox' | 'api';
+export interface ProviderProfileCapabilityItem {
+    key: string;
+    label: string;
+    description: string;
+}
+export interface ProviderProfileCapabilityGroup {
+    key: string;
+    title: string;
+    items: ProviderProfileCapabilityItem[];
+}
+export interface ProviderProfileDetails {
+    connectorType: ProviderConnectorType;
+    author: 'Stacklink';
+    providerKey: string;
+    websiteUrl?: string | undefined;
+    docsUrl?: string | undefined;
+    privacyPolicyUrl?: string | undefined;
+    termsUrl?: string | undefined;
+}
+export interface ProviderMarketplaceProfile {
+    visible: boolean;
+    connectable: boolean;
+    recommended: boolean;
+    internal: boolean;
+}
+export interface ProviderProfile {
+    headline: string;
+    summary: string;
+    examplePrompts: string[];
+    capabilityGroups: ProviderProfileCapabilityGroup[];
+    accessText: string;
+    authText: string;
+    safetyText: string;
+    details: ProviderProfileDetails;
+    marketplace: ProviderMarketplaceProfile;
+}
+export type ProviderRuntimeKind = 'native_api' | 'native_sdk' | 'remote_mcp' | 'managed_mcp_gateway';
+export type ProviderRuntimeOwner = 'stacklink' | 'provider' | 'third_party';
+export type ProviderMcpTransport = 'streamable_http';
+export type ProviderMcpAuthType = 'oauth_dcr' | 'oauth_static_client' | 'bearer' | 'none';
+export type ProviderMcpImportPolicy = 'certified_allowlist' | 'discover_then_review';
+export type ProviderMcpIdentityKind = 'user' | 'workspace' | 'organization' | 'project';
+export type ProviderMcpResourceKind = 'user' | 'workspace' | 'organization' | 'project' | 'site' | 'space' | 'component' | 'repository' | 'channel' | 'label' | 'folder' | 'document' | 'spreadsheet' | 'database';
+export interface ProviderRuntime {
+    kind: ProviderRuntimeKind;
+    owner: ProviderRuntimeOwner;
+    label: string;
+    mcp?: {
+        endpointUrl: string;
+        transport: ProviderMcpTransport;
+        auth: {
+            type: ProviderMcpAuthType;
+        };
+        sourceUrl: string;
+        importPolicy: ProviderMcpImportPolicy;
+        allowlisted: boolean;
+        identity?: {
+            strategy: 'tool_call';
+            identityKind: ProviderMcpIdentityKind;
+            toolName: string;
+            arguments: Record<string, unknown>;
+            payloadRoot?: {
+                source: 'result' | 'content_text_json';
+                contentIndex?: number | undefined;
+                path?: string[] | undefined;
+            } | undefined;
+            externalAccountIdPath?: string[] | undefined;
+            displayNamePath?: string[] | undefined;
+            displayNameTemplate?: string | undefined;
+            metadataPaths?: Record<string, string[]> | undefined;
+            fallbackDisplayName: string;
+            timeoutMs: number;
+            contractVersion: number;
+        } | undefined;
+        resources?: Array<{
+            key: string;
+            strategy: 'tool_call';
+            resourceKind: ProviderMcpResourceKind;
+            toolName: string;
+            arguments: Record<string, unknown>;
+            payloadRoot?: {
+                source: 'result' | 'content_text_json';
+                contentIndex?: number | undefined;
+                path?: string[] | undefined;
+            } | undefined;
+            externalResourceIdPath: string[];
+            labelPath?: string[] | undefined;
+            labelTemplate?: string | undefined;
+            parent?: {
+                kind: ProviderMcpResourceKind;
+                externalResourceIdPath?: string[] | undefined;
+                labelPath?: string[] | undefined;
+                labelTemplate?: string | undefined;
+            } | undefined;
+            metadataPaths?: Record<string, string[]> | undefined;
+            enrichments?: Array<{
+                toolName: string;
+                argumentsTemplate: Record<string, string | number | boolean | null>;
+                payloadRoot?: {
+                    source: 'result' | 'content_text_json';
+                    contentIndex?: number | undefined;
+                    path?: string[] | undefined;
+                } | undefined;
+                metadataPaths?: Record<string, string[]> | undefined;
+                urlPath?: string[] | undefined;
+                timeoutMs?: number | undefined;
+            }> | undefined;
+            timeoutMs: number;
+            maxItems: number;
+            contractVersion: number;
+        }> | undefined;
+    } | undefined;
+}
+export interface ProviderToolkit {
+    id?: string | undefined;
+    key: string;
+    displayName: string;
+    category?: string | undefined;
+    status?: string | undefined;
+    authModes?: string[] | undefined;
+    capabilities?: string[] | undefined;
+    metadata?: unknown;
+    brand?: ProviderBrandDescriptor | undefined;
+    profile?: ProviderProfile | undefined;
+    runtime?: ProviderRuntime | undefined;
+    billingSummary?: StacklinkPublicBillingSummary | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}
+export interface ProjectProvider {
+    key?: string | undefined;
+    providerKey?: string | undefined;
+    name?: string | undefined;
+    displayName?: string | undefined;
+    category?: string | undefined;
+    status?: string | undefined;
+    projectStatus?: string | undefined;
+    authModes?: string[] | undefined;
+    capabilities?: string[] | undefined;
+    metadata?: unknown;
+    brand?: ProviderBrandDescriptor | undefined;
+    profile?: ProviderProfile | undefined;
+    runtime?: ProviderRuntime | undefined;
+    billingSummary?: StacklinkPublicBillingSummary | undefined;
+    toolCount?: number | undefined;
+    triggerCount?: number | undefined;
+    enabledAt?: string | null | undefined;
+    disabledAt?: string | null | undefined;
+    connection?: {
+        isActive: boolean;
+        connectedAccounts: ConnectedAccount[];
+    } | undefined;
+    toolkit?: ProviderToolkit | undefined;
+}
+export interface StacklinkProject {
+    id: string;
+    projectId?: string | undefined;
+    name: string;
+    projectName?: string | undefined;
+    slug: string;
+    clientName?: string | undefined;
+    environment: string;
+    status: string;
+    defaultTimeZone?: string | undefined;
+    dashboardWorkspaceId?: string | null | undefined;
+    dashboardWorkspace?: {
+        id: string;
+        name: string;
+        slug: string;
+        status: string;
+    } | null | undefined;
+    logsPurgeAt?: string | null | undefined;
+    deletedAt?: string | null | undefined;
+    metadata?: JsonRecord | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}
+export interface ProviderTool {
+    id?: string | undefined;
+    key: string;
+    toolkitKey?: string | undefined;
+    displayName: string;
+    description?: string | undefined;
+    capability?: string | undefined;
+    mutationLevel?: string | undefined;
+    status?: string | undefined;
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    searchDescriptor?: unknown;
+    metadata?: unknown;
+    aliases?: unknown[] | undefined;
+    providerBrand?: ProviderBrandDescriptor | undefined;
+    providerProfile?: ProviderProfile | undefined;
+    brand?: ProviderBrandDescriptor | undefined;
+    execution?: StacklinkExecutionCapability | undefined;
+    billing?: StacklinkBillingDescriptor | undefined;
+    outputPolicy?: StacklinkToolOutputPolicy | undefined;
+    family?: StacklinkToolFamily | undefined;
+    navigation?: StacklinkToolNavigation | undefined;
+    providerOperation?: StacklinkProviderOperation | undefined;
+    authPolicy?: StacklinkToolAuthPolicy | undefined;
+    contractVersion?: string | undefined;
+    connection?: unknown;
+    schema?: unknown;
+    accountScopedSchemas?: unknown;
+    executionBinding?: unknown;
+    modelCallable?: unknown;
+}
+export interface AuthRequirement {
+    authConfigId: string;
+    authMode: string;
+    flow: string;
+    family?: string | null | undefined;
+    surface?: string | null | undefined;
+    ownership?: unknown;
+    managedBy?: 'stacklink' | 'project' | undefined;
+    requiredFields: string[];
+    optionalFields: string[];
+    description: string;
+    credentialSchema: unknown;
+    oauthConfig: unknown;
+}
+export interface AuthConfig {
+    id: string;
+    providerKey: string;
+    providerBrand?: ProviderBrandDescriptor | undefined;
+    key: string;
+    displayName: string;
+    status?: string | undefined;
+    authMode: string;
+    flow: string;
+    family?: string | null | undefined;
+    surface?: string | null | undefined;
+    ownership?: unknown;
+    credentialSchema: unknown;
+    oauthConfig: unknown;
+    isDefault: boolean;
+    metadata: unknown;
+    managedBy?: string | undefined;
+    secretRefs?: unknown;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}
+export interface ConnectedAccount {
+    id: string;
+    tenantId: string;
+    authConfigId: string | null;
+    providerKey: string;
+    providerBrand?: ProviderBrandDescriptor | undefined;
+    externalAccountId: string;
+    displayName: string | null;
+    status: string;
+    authMode: string;
+    isDefault: boolean;
+    region?: string | null | undefined;
+    scopes: unknown;
+    identity?: {
+        kind: ProviderMcpIdentityKind;
+        source: 'oauth_profile' | 'mcp_identity' | 'manual' | 'fallback';
+        label: string;
+        status: 'resolved' | 'fallback' | 'failed';
+        resolvedAt?: string | undefined;
+        email?: string | undefined;
+        projectUrl?: string | undefined;
+        workspace?: string | undefined;
+        organization?: string | undefined;
+        details?: Record<string, string | number | boolean> | undefined;
+        resourceSummary?: ConnectedAccountResourceSummary[] | undefined;
+    } | null | undefined;
+    resourceSummary?: ConnectedAccountResourceSummary[] | undefined;
+    aliases: string[];
+    aliasValues?: string[] | undefined;
+    connectedAt?: string | null | undefined;
+    lastVerifiedAt?: string | null | undefined;
+    expiresAt: string | null;
+}
+export interface ConnectedAccountResourceSummary {
+    resourceKey: string;
+    kind: ProviderMcpResourceKind | string;
+    count: number;
+}
+export interface ConnectedAccountResource {
+    id: string;
+    accountId: string;
+    providerKey: string;
+    resourceKey: string;
+    kind: ProviderMcpResourceKind | string;
+    externalResourceId: string;
+    label: string;
+    parent?: {
+        kind: ProviderMcpResourceKind | string;
+        externalResourceId?: string | undefined;
+        label?: string | undefined;
+    } | undefined;
+    status: string;
+    url?: string | null | undefined;
+    details: Record<string, string | number | boolean>;
+    discoveredAt: string | Date;
+    lastSeenAt: string | Date;
+    contractVersion: number;
+}
+export interface ConnectedAccountResourcesResponse {
+    accountId: string;
+    providerKey: string;
+    resources: ConnectedAccountResource[];
+    resourceSummary: ConnectedAccountResourceSummary[];
+    page: {
+        limit: number;
+        total: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    };
+    sync?: {
+        status: 'resolved' | 'empty' | 'failed' | 'skipped_no_contract' | 'skipped_no_secret';
+        discovered: number;
+        resourceKeys: string[];
+        errors?: Array<{
+            resourceKey: string;
+            toolName: string;
+            message: string;
+            code?: string | undefined;
+        }> | undefined;
+    } | undefined;
+    syncJob?: {
+        id: string;
+        status: 'pending' | 'processing' | 'retry' | 'completed' | 'failed' | 'cancelled';
+        attempts: number;
+        queuedAt: string | Date;
+        completedAt: string | Date | null;
+    } | undefined;
+}
+export interface ConnectedAccountResourceListOptions {
+    search?: string | undefined;
+    resourceKey?: string | undefined;
+    resourceKinds?: string[] | undefined;
+    cursor?: string | undefined;
+    limit?: number | undefined;
+}
+export interface ConnectedAccountResourceResolveInput {
+    resourceKey: string;
+    externalResourceId: string;
+}
+export interface StacklinkApiKey {
+    id: string;
+    name: string;
+    keyPrefix?: string | undefined;
+    status: string;
+    scopes: string[];
+    rawKey?: string | undefined;
+    expiresAt?: string | null | undefined;
+    lastUsedAt?: string | null | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}
+export interface CreateStacklinkApiKeyInput {
+    name: string;
+    scopes?: string[] | undefined;
+    expiresAt?: string | undefined;
+}
+export type ConnectionRequestPhase = 'request_created' | 'connect_page_opened' | 'oauth_started' | 'provider_authorizing' | 'oauth_callback_received' | 'token_exchange_started' | 'account_storing' | 'remote_mcp_tools_importing' | 'remote_mcp_tools_imported' | 'completed' | 'failed' | 'expired';
+export type ConnectionRequestNextAction = 'open_connect_url' | 'continue_to_provider' | 'wait_for_user' | 'wait_for_provider' | 'wait_for_stacklink' | 'refresh_toolkits' | 'retry' | 'none';
+export interface ConnectionRequestResponse {
+    id: string;
+    providerKey: string;
+    providerName?: string | undefined;
+    authConfigId?: string | null | undefined;
+    authMode?: string | null | undefined;
+    status: string;
+    phase?: ConnectionRequestPhase | undefined;
+    nextAction?: ConnectionRequestNextAction | undefined;
+    redirectUrl?: string | undefined;
+    callbackUrl?: string | null | undefined;
+    failureReason?: string | null | undefined;
+    failureCode?: string | null | undefined;
+    expiresAt?: string | undefined;
+    authModes?: string[] | undefined;
+    authRequirements?: AuthRequirement[] | undefined;
+    connectedAccount?: ConnectedAccount | undefined;
+    error?: string | null | undefined;
+    metadata?: unknown;
+}
+export interface ConnectionAuthorizationResponse {
+    id: string;
+    providerKey: string;
+    authConfigId?: string | undefined;
+    authMode?: string | undefined;
+    status: string;
+    phase?: ConnectionRequestPhase | undefined;
+    nextAction?: ConnectionRequestNextAction | undefined;
+    redirectUrl: string;
+    hostedUrl?: string | undefined;
+    expiresAt: string;
+    authModes: string[];
+    authRequirements?: AuthRequirement[] | undefined;
+}
+export interface TriggerType {
+    id?: string | undefined;
+    key: string;
+    providerKey: string;
+    displayName: string;
+    description?: string | undefined;
+    deliveryModes?: string[] | undefined;
+    configSchema?: unknown;
+    eventSchema?: unknown;
+    metadata?: unknown;
+}
+export interface TriggerSubscription {
+    id: string;
+    tenantId?: string | undefined;
+    triggerType?: string | unknown;
+    triggerTypeId?: string | undefined;
+    providerKey: string;
+    accountId?: string | null | undefined;
+    connectedAccountId?: string | null | undefined;
+    status: string;
+    deliveryMode: string;
+    config?: unknown;
+    idempotencyKey?: string | null | undefined;
+    lastEventAt?: string | null | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}
+export interface CreateTriggerSubscriptionInput {
+    tenantId: string;
+    accountId?: string | undefined;
+    triggerTypeId: string;
+    deliveryMode?: 'webhook' | 'polling' | undefined;
+    config?: Record<string, unknown> | undefined;
+    idempotencyKey?: string | undefined;
+}
+export interface UpdateTriggerSubscriptionInput {
+    status?: 'active' | 'disabled' | undefined;
+    config?: Record<string, unknown> | undefined;
+}
+export interface ListTriggerSubscriptionsInput {
+    tenantId?: string | undefined;
+    providerKey?: string | undefined;
+    status?: string | undefined;
+}
+export type StacklinkWebhookEventType = 'stacklink.trigger.event' | 'stacklink.connected_account.connected' | 'stacklink.connected_account.refreshed' | 'stacklink.connected_account.expired' | 'stacklink.connected_account.disabled' | 'stacklink.connected_account.deleted' | 'stacklink.remote_mcp.tools_imported' | 'stacklink.remote_mcp.tools_import_failed' | 'stacklink.trigger.disabled';
+export interface StacklinkWebhookEndpoint {
+    id: string;
+    consumerAppId?: string | undefined;
+    status: string;
+    callbackUrl?: string | null | undefined;
+    eventTypes: StacklinkWebhookEventType[];
+    secretRef?: string | null | undefined;
+    metadata?: unknown;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}
+export interface StacklinkWebhookTestResult {
+    deliveryId: string;
+    attemptId: string;
+    status: string;
+    statusCode: number | null;
+    durationMs: number;
+}
+export type StacklinkUsageOperationClass = 'standard' | 'premium' | 'free';
+export type StacklinkBillingUnit = 'call' | 'runtime_10s' | 'token_block' | 'byte_block';
+export type StacklinkBillingQuantitySource = 'fixed' | 'duration_ms' | 'tokens' | 'bytes';
+export type StacklinkBillingInterval = 'monthly' | 'annual';
+export type StacklinkBillingPolicyClass = 'free' | 'rate_limit_only' | 'standard_ops' | 'premium_ops';
+export interface StacklinkBillingDescriptor {
+    class: StacklinkUsageOperationClass;
+    unit: StacklinkBillingUnit;
+    multiplier?: 1 | 2 | 3 | undefined;
+    quantitySource: StacklinkBillingQuantitySource;
+    version: 'stacklink-billing-v1';
+}
+export interface StacklinkBillingPlan {
+    key: string;
+    displayName: string;
+    monthlyPriceCents: number;
+    annualPriceCents?: number | null | undefined;
+    standardOpsIncluded: number;
+    premiumOpsIncluded: number;
+    standardOveragePerThousandCents: number;
+    premiumOveragePerThousandCents: number;
+    rateLimitPerMinute: number;
+    logRetentionDays: number;
+    projectsIncluded?: number | null | undefined;
+    status: string;
+    metadata?: unknown;
+}
+export interface StacklinkPublicBillingSummary {
+    policy: StacklinkBillingPolicyClass;
+    operationClass: StacklinkUsageOperationClass | null;
+    meterName: 'standard_ops' | 'premium_ops' | null;
+    label: string;
+    description: string;
+}
+export interface StacklinkWorkspaceSubscription {
+    id: string;
+    dashboardWorkspaceId: string;
+    planKey: string;
+    status: string;
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    cancelAtPeriodEnd: boolean;
+    billingProvider: string;
+    externalCustomerPresent?: boolean | undefined;
+    externalSubscriptionPresent?: boolean | undefined;
+    metadata?: unknown;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}
+export interface StacklinkUsageBucket {
+    used: number;
+    included: number;
+    remaining: number;
+    overage: number;
+    overageCents: number;
+}
+export interface StacklinkUsageSummary {
+    workspace?: {
+        id: string;
+        name: string;
+        slug: string;
+        status: string;
+    } | undefined;
+    subscription: StacklinkWorkspaceSubscription;
+    plan: StacklinkBillingPlan;
+    period: {
+        start: string;
+        end: string;
+    };
+    usage: {
+        standard: StacklinkUsageBucket;
+        premium: StacklinkUsageBucket;
+    };
+    overagePending: boolean;
+}
+export interface StacklinkUsageMeterEvent {
+    id: string;
+    consumerAppId: string;
+    tenantId?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    sourceType: string;
+    sourceId: string;
+    operationClass: StacklinkUsageOperationClass;
+    billingVisibility: 'customer' | 'internal';
+    quantity: number;
+    idempotencyKey: string;
+    occurredAt: string;
+    metadata?: unknown;
+    ratedUsage?: {
+        id: string;
+        pricingRuleKey: string;
+        pricingVersion: string;
+        productArea: string;
+        providerKey?: string | null | undefined;
+        toolKey?: string | null | undefined;
+        runtimeKind?: string | null | undefined;
+        knowledgePackKey?: string | null | undefined;
+        modelProvider?: string | null | undefined;
+        model?: string | null | undefined;
+        quantity: number;
+        unit: string;
+        upstreamCostMicros: string;
+        baseCostMicros: string;
+        markupBps: number;
+        markupAmountMicros: string;
+        finalChargeMicros: string;
+        currency: string;
+        createdAt: string;
+    } | null | undefined;
+    createdAt?: string | undefined;
+}
+export interface StacklinkBillingCheckoutSession {
+    provider: string;
+    checkoutSessionId: string;
+    url: string;
+    planKey: string;
+    billingInterval: StacklinkBillingInterval;
+}
+export interface StacklinkBillingPortalSession {
+    provider: string;
+    portalSessionId: string;
+    url: string;
+}
+export interface UpdateStacklinkSessionInput {
+    expectedConfigVersion?: number | undefined;
+    status?: 'active' | 'closed' | 'failed' | undefined;
+    toolRouter?: CreateStacklinkSessionInput['toolRouter'];
+    preset?: CreateStacklinkSessionInput['preset'];
+    preload?: CreateStacklinkSessionInput['preload'];
+    toolkits?: CreateStacklinkSessionInput['toolkits'];
+    tools?: CreateStacklinkSessionInput['tools'];
+    authConfigs?: CreateStacklinkSessionInput['authConfigs'];
+    connectedAccounts?: CreateStacklinkSessionInput['connectedAccounts'];
+    providerMutationMode?: CreateStacklinkSessionInput['providerMutationMode'];
+    multiAccount?: CreateStacklinkSessionInput['multiAccount'];
+    workbench?: CreateStacklinkSessionInput['workbench'];
+    knowledgePacks?: CreateStacklinkSessionInput['knowledgePacks'];
+    metaTools?: CreateStacklinkSessionInput['metaTools'];
+    memory?: CreateStacklinkSessionInput['memory'];
+    metadata?: Record<string, unknown> | undefined;
+}
+export interface StacklinkWebhookEnvelope<TType extends StacklinkWebhookEventType = StacklinkWebhookEventType, TData = unknown> {
+    version: 'v1';
+    id: string;
+    type: TType;
+    metadata: {
+        trigger_id?: string | null | undefined;
+        trigger_slug?: string | null | undefined;
+        connected_account_id?: string | null | undefined;
+        tenant_id?: string | null | undefined;
+        provider_key?: string | null | undefined;
+        auth_config_id?: string | null | undefined;
+        raw_event_id?: string | null | undefined;
+        [key: string]: unknown;
+    };
+    data: TData;
+    timestamp: string;
+}
+export type StacklinkTriggerEventEnvelope<TData = unknown> = StacklinkWebhookEnvelope<'stacklink.trigger.event', TData>;
+export type StacklinkConnectedAccountExpiredEnvelope<TData = unknown> = StacklinkWebhookEnvelope<'stacklink.connected_account.expired', TData>;
+export type StacklinkTriggerDisabledEnvelope<TData = unknown> = StacklinkWebhookEnvelope<'stacklink.trigger.disabled', TData>;
+export interface StacklinkWebhookSignatureInput {
+    id: string;
+    timestamp: string;
+    signature: string;
+    body: string;
+    secret: string;
+    toleranceSeconds?: number | undefined;
+    now?: Date | undefined;
+}
+export interface WorkbenchSession {
+    id: string;
+    consumerAppId?: string | undefined;
+    tenantId?: string | undefined;
+    platformSessionId?: string | undefined;
+    sessionId?: string | undefined;
+    runtimeProvider?: string | null | undefined;
+    runtimeSessionId?: string | null | undefined;
+    sandboxSize?: 'standard' | 'medium' | 'large' | undefined;
+    runtimeSandboxSize?: 'standard' | 'medium' | 'large' | null | undefined;
+    runtimeGeneration?: number | undefined;
+    runtimeEnvironmentRestoredGeneration?: number | undefined;
+    activeExecutionCount?: number | undefined;
+    workspaceStorageKind?: 'r2_workspace' | string | undefined;
+    workspaceStorageRef?: string | null | undefined;
+    environmentManifest?: unknown;
+    status?: string | undefined;
+    model?: string | undefined;
+    metadata?: unknown;
+    lastActiveAt?: string | null | undefined;
+    destroyedAt?: string | null | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}
+export interface WorkbenchSessionDeleteReceipt {
+    deleted: true;
+    workbenchSessionId: string;
+    platformSessionId: string;
+    computeDestroyed: boolean;
+    deletedArtifactObjects: number;
+    deletedUploadObjects: number;
+    deletedSnapshots: number;
+    workspace: {
+        deleted: true;
+        workspaceKey: string;
+        deletedWorkspaceObjects: number;
+        deletedExecutionObjects: number;
+        deletedObjects: number;
+    };
+    deletedDatabaseRows: {
+        workbenchSessions: number;
+        files: number;
+        fileUploads: number;
+        artifacts: number;
+        executionLogs: number;
+        executionEvents: number;
+        executionEventStreams: number;
+        runDefinitions: number;
+        environmentSnapshots: number;
+        usageEvents: number;
+        costLedger: number;
+        budgetPolicies: number;
+        budgetReservations: number;
+        runtimeHeartbeats: number;
+        approvalRequests: number;
+    };
+    databaseDeleted: true;
+}
+export type WorkbenchRuntimeLanguage = 'python' | 'javascript' | 'typescript';
+export type WorkbenchOutputMode = 'inline' | 'preview' | 'events' | 'artifact';
+export interface WorkbenchReusableRunRequest {
+    mode?: 'auto' | 'off' | undefined;
+    seriesId?: string | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    versionReason?: string | undefined;
+}
+export interface WorkbenchRunCodeInput {
+    workbenchSessionId?: string | undefined;
+    language: WorkbenchRuntimeLanguage;
+    code: string;
+    timeoutMs?: number | undefined;
+    background?: boolean | undefined;
+    notifyOnComplete?: boolean | undefined;
+    outputMode?: WorkbenchOutputMode | undefined;
+    maxOutputBytes?: number | undefined;
+    reusableRun?: WorkbenchReusableRunRequest | undefined;
+    currentStep?: string | undefined;
+    currentStepMetric?: string | undefined;
+    thought?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}
+export interface WorkbenchRunBashInput {
+    workbenchSessionId?: string | undefined;
+    command: string;
+    timeoutMs?: number | undefined;
+    background?: boolean | undefined;
+    notifyOnComplete?: boolean | undefined;
+    outputMode?: WorkbenchOutputMode | undefined;
+    maxOutputBytes?: number | undefined;
+    reusableRun?: WorkbenchReusableRunRequest | undefined;
+    currentStep?: string | undefined;
+    currentStepMetric?: string | undefined;
+    thought?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}
+export interface WorkbenchRuntimeDiagnostics {
+    code?: string | undefined;
+    message?: string | undefined;
+    runtimeStatus?: string | undefined;
+    exitCode?: number | undefined;
+    error?: unknown;
+}
+export type WorkbenchExecutionStatus = 'queued' | 'started' | 'running' | 'cancel_requested' | 'completed' | 'failed' | 'cancelled' | 'timed_out';
+export interface WorkbenchExecutionLog {
+    id: string;
+    executionId?: string | undefined;
+    executionKind?: 'workbench_code' | 'workbench_bash' | undefined;
+    workbenchSessionId: string;
+    operation: string;
+    language: WorkbenchRuntimeLanguage | null;
+    status: WorkbenchExecutionStatus;
+    durationMs: number | null;
+    artifactId: string | null;
+    timeoutMs: number | null;
+    deadlineAt: string | null;
+    cancelRequestedAt: string | null;
+    cancelledAt: string | null;
+    runtimeProvider: string | null;
+    runtimeSessionId: string | null;
+    runtimeProcessId: string | null;
+    runtimeOutputCursor: string | null;
+    approvalRequestId: string | null;
+    idempotencyKey: string | null;
+    startedAt: string;
+    runtimeStartedAt?: string | null | undefined;
+    completedAt: string | null;
+    outputMode?: WorkbenchOutputMode | undefined;
+    result?: WorkbenchRuntimeEnvelope | WorkbenchBackgroundExecutionResult | WorkbenchOutputPreview | undefined;
+    artifact?: WorkbenchArtifact | null | undefined;
+    stdout?: string | null | undefined;
+    stderr?: string | null | undefined;
+    error?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+    reusableRun?: {
+        mode: 'auto' | 'off';
+        status: 'pending' | 'ready' | 'failed' | 'skipped';
+        seriesId?: string | null | undefined;
+        name?: string | null | undefined;
+        description?: string | null | undefined;
+        versionReason?: string | null | undefined;
+        errorCode?: string | null | undefined;
+        runDefinitionId?: string | null | undefined;
+        version?: number | null | undefined;
+        replayOfRunDefinitionId?: string | null | undefined;
+        observableResultContractVersion?: string | null | undefined;
+        observableResult?: WorkbenchObservableResultV1 | null | undefined;
+        observableResultSha256?: string | null | undefined;
+        comparisonStatus?: 'matched' | 'mismatched' | null | undefined;
+        comparison?: WorkbenchRunComparison | null | undefined;
+        comparedAt?: string | null | undefined;
+        nextAction?: 'get_execution' | 'get_reusable_run' | null | undefined;
+    } | undefined;
+    inputEnvironmentSnapshotId?: string | null | undefined;
+    observableResultContractVersion?: string | null | undefined;
+    observableResult?: WorkbenchObservableResultV1 | null | undefined;
+    observableResultSha256?: string | null | undefined;
+    replayOfRunDefinitionId?: string | null | undefined;
+    replayComparisonStatus?: 'matched' | 'mismatched' | null | undefined;
+    replayComparison?: WorkbenchRunComparison | null | undefined;
+    replayComparedAt?: string | null | undefined;
+}
+export interface WorkbenchRuntimeResult {
+    status: 'completed' | 'failed' | 'cancelled' | 'timed_out' | string;
+    success: boolean;
+    exitCode: number | null;
+    terminalReason?: string | undefined;
+    stdout: string;
+    stderr: string;
+    outputBytes?: number | undefined;
+    outputTruncated?: boolean | undefined;
+    diagnostics?: WorkbenchRuntimeDiagnostics | undefined;
+}
+export interface WorkbenchRuntimeEnvelope {
+    runtime?: {
+        provider: 'cloudflare' | string;
+        sessionId: string;
+        workspaceKey?: string | undefined;
+    } | undefined;
+    result: WorkbenchRuntimeResult;
+}
+export interface WorkbenchBackgroundExecutionResult {
+    executionKind: 'workbench_code' | 'workbench_bash';
+    executionId: string;
+    status: 'queued' | 'running';
+    runtimeProcessId: string | null;
+    outputMode: 'events';
+}
+export interface WorkbenchOutputPreview {
+    outputMode: 'preview';
+    outputBytes: number;
+    preview: string;
+}
+export interface WorkbenchExecutionResponse {
+    workbenchSession: WorkbenchSession;
+    executionKind: 'workbench_code' | 'workbench_bash';
+    executionId: string;
+    status?: WorkbenchExecutionStatus | undefined;
+    outputMode?: WorkbenchOutputMode | undefined;
+    execution?: WorkbenchExecutionLog | undefined;
+    executionLog?: WorkbenchExecutionLog | undefined;
+    result?: WorkbenchRuntimeEnvelope | WorkbenchBackgroundExecutionResult | WorkbenchOutputPreview | undefined;
+    artifact?: WorkbenchArtifact | undefined;
+}
+export interface WorkbenchFile {
+    id: string;
+    path: string;
+    contentType: string;
+    sizeBytes: number | string;
+    storageKind: 'r2_workspace' | 'database_blob' | string;
+    sha256?: string | null | undefined;
+    etag?: string | null | undefined;
+    contentBase64?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}
+export interface WorkbenchFileSignedUpload {
+    uploadId: string;
+    path: string;
+    contentType: string;
+    sizeBytes: number;
+    storageKind: 'r2_workspace';
+    uploadUrl: string;
+    expiresAt: string;
+    requiredHeaders: Record<string, string>;
+}
+export interface WorkbenchFileSignedDownload {
+    file: Omit<WorkbenchFile, 'id'> & {
+        etag?: string | undefined;
+    };
+    downloadUrl: string;
+    expiresAt: string;
+}
+export interface WorkbenchArtifact {
+    id: string;
+    artifactRef: string;
+    path: string;
+    label: string | null;
+    contentType: string | null;
+    sizeBytes: number | string | null;
+    sha256: string | null;
+    storageKind: 'r2_object' | 'database_blob' | 'workbench_file' | string;
+    status: string;
+    downloadUrl?: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface WorkbenchRunDefinition {
+    id: string;
+    seriesId: string;
+    version: number;
+    workbenchSessionId: string;
+    platformSessionId: string;
+    sourceExecutionId: string;
+    environmentSnapshotId: string | null;
+    name: string;
+    description?: string | null | undefined;
+    kind: 'code' | 'bash';
+    language?: WorkbenchRuntimeLanguage | null | undefined;
+    source: string;
+    publicationStatus: 'draft' | 'published' | 'retired';
+    validationStatus: 'unvalidated' | 'matched' | 'mismatched';
+    validatedAt?: string | null | undefined;
+    validatedByExecutionId?: string | null | undefined;
+    sourceObservableResult?: WorkbenchObservableResultV1 | null | undefined;
+    sourceObservableResultSha256?: string | null | undefined;
+    sourceCodeSha256?: string | null | undefined;
+    environmentManifestSha256?: string | null | undefined;
+    creationMode: 'auto' | 'migrated_manual';
+    versionReason?: string | null | undefined;
+    environmentManifest: unknown;
+    metadata?: unknown;
+    replayCount?: number | undefined;
+    replays?: Array<{
+        executionId: string;
+        status: WorkbenchExecutionStatus;
+        comparison: WorkbenchRunComparison;
+    }> | undefined;
+    publishedAt?: string | null | undefined;
+    retiredAt?: string | null | undefined;
+    createdAt: string;
+}
+export type WorkbenchReplayEnvironmentMode = 'require_match' | 'restore_snapshot' | 'current';
+export interface WorkbenchRunComparison {
+    contractVersion?: 'workbench.observable-result.v1' | undefined;
+    status: 'pending' | 'pending_finalization' | 'matched' | 'mismatched';
+    sourceExecutionId?: string | undefined;
+    replayExecutionId: string;
+    terminalMatch?: boolean | undefined;
+    outputMatch?: boolean | undefined;
+    artifactMatch?: boolean | undefined;
+    sourceObservableResultSha256?: string | undefined;
+    replayObservableResultSha256?: string | undefined;
+    nextAction?: 'get_reusable_run' | undefined;
+}
+export interface WorkbenchObservableResultV1 {
+    contractVersion: 'workbench.observable-result.v1';
+    terminal: {
+        status: 'completed' | 'failed' | 'cancelled' | 'timed_out';
+        exitCode: number | null;
+    };
+    output: {
+        orderedSha256: string;
+        stdoutSha256: string;
+        stderrSha256: string;
+        structuredResultSha256: string;
+        byteCount: number;
+    };
+    artifact: null | {
+        sha256: string;
+        sizeBytes: number;
+        contentType: string | null;
+    };
+}
+export interface WorkbenchRunReplayResponse {
+    runDefinition: WorkbenchRunDefinition;
+    execution: WorkbenchExecutionResponse;
+    environment: {
+        mode: WorkbenchReplayEnvironmentMode;
+        status: 'queued' | 'completed' | 'failed';
+        matchedBeforeReplay: boolean | null;
+        restored: boolean;
+        snapshotId: string | null;
+    };
+    comparison: WorkbenchRunComparison;
+}
+export type WorkbenchBudgetPeriod = 'daily' | 'weekly' | 'monthly' | 'all_time';
+export interface WorkbenchBudgetPolicy {
+    id: string;
+    tenantId: string;
+    workbenchSessionId?: string | null | undefined;
+    status: 'active' | 'disabled' | string;
+    period: WorkbenchBudgetPeriod;
+    maxCostMicros?: number | string | null | undefined;
+    maxDurationMs?: number | null | undefined;
+    maxArtifactBytes?: number | string | null | undefined;
+    maxLlmTokens?: number | null | undefined;
+    metadata?: unknown;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}
+export interface WorkbenchUsage {
+    usageEvents?: unknown[];
+    costLedger?: unknown[];
+    heartbeats?: unknown[];
+    events?: unknown[];
+    ledger?: unknown[];
+    summary?: unknown;
+    budgets?: WorkbenchBudgetPolicy[];
+}
+export interface WorkbenchModelOption {
+    provider: string;
+    model: string;
+    label?: string | undefined;
+    supportsWebSearch?: boolean | undefined;
+    supportsReasoning?: boolean | undefined;
+    default?: boolean | undefined;
+}
+export interface StacklinkSessionData {
+    id: string;
+    tenantId: string;
+    status?: string | undefined;
+    userId?: string | null | undefined;
+    tenantExternalId?: string | undefined;
+    tenantDisplayName?: string | null | undefined;
+    userExternalId?: string | null | undefined;
+    userDisplayName?: string | null | undefined;
+    userEmail?: string | null | undefined;
+    toolkits?: string[] | undefined;
+    connectedAccounts?: unknown;
+    providerMutationMode?: 'read_only' | 'ask' | 'full_access' | undefined;
+    authConfigs?: unknown;
+    workbench?: unknown;
+    memory?: unknown;
+    mcp?: StacklinkSessionMcpDescriptor | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}
+export interface StacklinkSessionMcpDescriptor {
+    url: string;
+    headers: Record<string, string>;
+    auth: {
+        type: 'bearer';
+        envVar: string;
+    };
+    protocolVersion: string;
+    sessionId: string;
+}
+export interface StacklinkSessionMcpConnection {
+    url: string;
+    headers: Record<string, string>;
+}
+export interface StacklinkSessionMetaToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface ProviderArtifact {
+    id: string;
+    providerKey?: string | undefined;
+    objectType?: string | undefined;
+    sourceUrl?: string | null | undefined;
+    storageKind?: string | undefined;
+    storageRef?: string | null | undefined;
+    mimeType?: string | null | undefined;
+    sizeBytes?: number | string | null | undefined;
+    downloadUrl?: string | undefined;
+    metadata?: unknown;
+    createdAt?: string | undefined;
+}
+export interface LogSummary {
+    requests?: unknown;
+    tools?: unknown;
+    triggers?: unknown;
+    webhooks?: unknown;
+    workbench?: unknown;
+    sourceBreakdown?: unknown;
+}
+export interface RequestLog {
+    id: string;
+    status?: string | undefined;
+    method?: string | undefined;
+    route?: string | null | undefined;
+    path?: string | undefined;
+    statusCode?: number | null | undefined;
+    durationMs?: number | null | undefined;
+    clientChannel?: 'rest_api' | 'ts_sdk' | 'python_sdk' | 'mcp' | 'dashboard' | string | undefined;
+    clientName?: string | undefined;
+    clientVersion?: string | null | undefined;
+    clientRequestId?: string | null | undefined;
+    clientSurface?: string | null | undefined;
+    createdAt?: string | undefined;
+    startedAt?: string | undefined;
+    completedAt?: string | null | undefined;
+    metadata?: unknown;
+}
+export interface ToolExecutionLog {
+    id: string;
+    toolKey?: string | undefined;
+    status?: string | undefined;
+    requestLogId?: string | null | undefined;
+    requestLog?: RequestLog | null | undefined;
+    clientChannel?: 'rest_api' | 'ts_sdk' | 'python_sdk' | 'mcp' | 'dashboard' | string | undefined;
+    clientName?: string | undefined;
+    clientVersion?: string | null | undefined;
+    clientRequestId?: string | null | undefined;
+    clientSurface?: string | null | undefined;
+    createdAt?: string | undefined;
+    startedAt?: string | undefined;
+    completedAt?: string | null | undefined;
+    durationMs?: number | null | undefined;
+    metadata?: unknown;
+}
+export interface TriggerEventLog {
+    id: string;
+    triggerType?: string | undefined;
+    status?: string | undefined;
+    createdAt?: string | undefined;
+    metadata?: unknown;
+}
+export interface StacklinkOptions {
+    apiKey: string;
+    baseUrl: string;
+    fetch?: StacklinkFetch;
+    registrationKey?: string | undefined;
+    cache?: StacklinkClientCacheOptions | undefined;
+}
+export interface StacklinkClientCacheOptions {
+    enabled?: boolean | undefined;
+    toolsListTtlMs?: number | undefined;
+    toolkitsTtlMs?: number | undefined;
+    schemasTtlMs?: number | undefined;
+    searchTtlMs?: number | undefined;
+    maxEntries?: number | undefined;
+}
+export interface StacklinkDiscoveryCacheControl {
+    cache?: 'default' | 'bypass' | undefined;
+}
+export interface StacklinkPrepareToolsInput extends StacklinkDiscoveryCacheControl {
+    intents: string[];
+    includeSchemas?: boolean | undefined;
+    limitPerIntent?: number | undefined;
+    includePlanned?: boolean | undefined;
+    toolkitKey?: string | undefined;
+    capability?: string | undefined;
+    model?: string | undefined;
+}
+export interface StacklinkPreparedTools {
+    tools: ProviderTool[];
+    schemas: ProviderTool[];
+    toolKeys: string[];
+    search: {
+        tools: ProviderTool[];
+        queries?: unknown[] | undefined;
+        meta?: unknown;
+    };
+}
+export interface StacklinkDiscoveryConfig {
+    preset: 'meta_tools' | 'direct_tools' | 'hybrid';
+    preload: {
+        tools?: string[] | undefined;
+        toolkits?: string[] | undefined;
+        includeMetaTools?: boolean | undefined;
+        includeWorkbench?: boolean | undefined;
+        includeConnectionManagement?: boolean | undefined;
+    };
+}
+export interface CreateStacklinkSessionInput {
+    tenantId?: string | undefined;
+    userId?: string | undefined;
+    tenantDisplayName?: string | undefined;
+    userDisplayName?: string | undefined;
+    userEmail?: string | undefined;
+    scopes?: string[] | undefined;
+    toolRouter?: Record<string, unknown> | undefined;
+    preset?: 'meta_tools' | 'direct_tools' | 'hybrid' | undefined;
+    preload?: {
+        tools?: string[] | undefined;
+        toolkits?: string[] | undefined;
+        includeMetaTools?: boolean | undefined;
+        includeWorkbench?: boolean | undefined;
+        includeConnectionManagement?: boolean | undefined;
+    } | undefined;
+    toolkits?: string[] | {
+        enable?: string[];
+        disable?: string[];
+    } | undefined;
+    tools?: string[] | Record<string, unknown> | undefined;
+    authConfigs?: Record<string, string> | undefined;
+    connectedAccounts?: Record<string, string | string[]> | undefined;
+    providerMutationMode?: 'read_only' | 'ask' | 'full_access' | undefined;
+    multiAccount?: {
+        enable?: boolean;
+        maxAccountsPerToolkit?: number;
+        requireExplicitSelection?: boolean;
+    } | undefined;
+    workbench?: {
+        enable?: boolean;
+        sandboxSize?: 'standard' | 'medium' | 'large';
+        autoSaveRuns?: boolean;
+    } | undefined;
+    knowledgePacks?: string[] | {
+        enable?: string[];
+        disable?: string[];
+    } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        agentExternalId?: string | undefined;
+        readableSubjects?: Array<'session_user' | 'session_agent' | 'tenant_shared'> | undefined;
+        writableSubjects?: Array<'session_user' | 'session_agent' | 'tenant_shared'> | undefined;
+        captureMode?: 'explicit' | 'bound_sources' | undefined;
+        includeProfile?: boolean | undefined;
+        includeBlocks?: boolean | undefined;
+        contextTokenBudget?: number | undefined;
+        policyKey?: string | undefined;
+    } | undefined;
+    metaTools?: {
+        surface?: StacklinkMetaToolSurface;
+        includeInternal?: boolean;
+        enable?: string[];
+        disable?: string[];
+    } | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}
+export interface ListStacklinkSessionsInput {
+    status?: 'active' | 'closed' | 'failed' | undefined;
+    tenantId?: string | undefined;
+    externalTenantId?: string | undefined;
+    userId?: string | undefined;
+    externalUserId?: string | undefined;
+    cursor?: string | undefined;
+    limit?: number | undefined;
+}
+export interface ListStacklinkSessionsResponse {
+    sessions: StacklinkSessionData[];
+    nextCursor?: string | null | undefined;
+}
+export interface StacklinkTool {
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (input: Record<string, unknown>) => Promise<unknown>;
+}
+export type StacklinkTools = Record<string, StacklinkTool>;
+export type KnowledgeRetrievalMode = 'canonical_lookup' | 'hybrid_search' | 'semantic_search' | 'text_search' | 'semantic_unavailable';
+export interface KnowledgeEvidenceReceipt {
+    evidenceId: string;
+    knowledgePackKey: string;
+    releaseId: string;
+    releaseKey: string;
+    sourceReleaseKey: string | null;
+    status: string;
+    allowedClaimScopes: string[];
+    canonicalId: string | null;
+    sourceKey: string;
+    blockId: string;
+    documentId: string;
+    exactQuote: string;
+    sourceUrl: string | null;
+    sourcePdfUrl: string | null;
+    sourceClass: string | null;
+    officiality: string | null;
+    legallyBinding: boolean;
+    amendmentState: string;
+    evidenceHash: string;
+}
+export interface KnowledgeAgentWarning {
+    code: string;
+    message: string;
+}
+export interface KnowledgeNextAction {
+    tool: string;
+    reason: string;
+}
+export interface KnowledgeAgentGuidance {
+    canAnswerDirectly: boolean;
+    requiresStructuredTool: boolean;
+    evidenceConfidence: 'verified' | 'partial' | 'source_missing' | 'missing' | (string & {});
+    currentnessState: string;
+    nextRecommendedActions: KnowledgeNextAction[];
+    warnings: KnowledgeAgentWarning[];
+}
+export interface KnowledgeSemanticMeta {
+    enabled: boolean;
+    model?: string | undefined;
+    dimensions?: number | undefined;
+    reason?: string | undefined;
+    retrievalEngine?: 'pgvector_hnsw' | 'jsonb_cosine' | (string & {}) | undefined;
+    candidateLimit?: number | undefined;
+    candidateLimitReached?: boolean | undefined;
+    candidateCount?: number | undefined;
+    comparedCount?: number | undefined;
+    returnedCount?: number | undefined;
+    filteredBelowMinSimilarityCount?: number | undefined;
+    minSimilarity?: number | undefined;
+    durationMs?: number | undefined;
+}
+export interface KnowledgeRetrievalLaneMeta {
+    name: 'exact' | 'lexical' | 'semantic' | (string & {});
+    enabled: boolean;
+    engine?: 'canonical_lookup' | 'postgres_fts' | 'pgvector_hnsw' | (string & {}) | undefined;
+    returnedCount: number;
+    durationMs?: number | undefined;
+    reason?: string | undefined;
+}
+export interface KnowledgeRetrievalMeta {
+    strategy: 'canonical_lookup' | 'hybrid_rrf' | 'lexical_fallback' | (string & {});
+    lanes: KnowledgeRetrievalLaneMeta[];
+    fusion: {
+        algorithm: 'rrf' | (string & {});
+        k: number;
+        candidateCount: number;
+        finalCount: number;
+    };
+    filters: {
+        sourceKeys: string[];
+        claimScope?: string | undefined;
+        currentnessPolicy: 'fail_closed' | (string & {});
+    };
+}
+export interface KnowledgeSearchInput {
+    sessionId: string;
+    packKey?: string | undefined;
+    releaseKey?: string | undefined;
+    query?: string | undefined;
+    canonicalId?: string | undefined;
+    sourceKey?: string | undefined;
+    sourceKeys?: string[] | undefined;
+    claimScope?: string | undefined;
+    limit?: number | undefined;
+    semanticCandidateLimit?: number | undefined;
+    minSimilarity?: number | undefined;
+}
+export interface KnowledgeSearchResult {
+    blockId: string;
+    documentId: string;
+    canonicalId: string | null;
+    sourceKey: string;
+    title: string;
+    exactQuote: string;
+    amendmentState: string;
+    sourceClass: string | null;
+    officiality: string | null;
+    legallyBinding: boolean;
+    sourceUrl: string | null;
+    sourcePdfUrl: string | null;
+    allowedClaimScopes: string[];
+    match?: {
+        retrievalMode: KnowledgeRetrievalMode;
+        similarity?: number | undefined;
+        lexicalScore?: number | undefined;
+        rrfScore?: number | undefined;
+        lanes?: string[] | undefined;
+    } | undefined;
+    evidence: KnowledgeEvidenceReceipt;
+}
+export interface KnowledgeSearchResponse {
+    knowledgePackKey: string;
+    releaseKey: string;
+    retrievalMode: KnowledgeRetrievalMode;
+    semantic: KnowledgeSemanticMeta;
+    retrieval?: KnowledgeRetrievalMeta | undefined;
+    results: KnowledgeSearchResult[];
+    agentGuidance?: KnowledgeAgentGuidance | undefined;
+}
+export interface KnowledgeCitationLookupInput {
+    sessionId: string;
+    packKey?: string | undefined;
+    releaseKey?: string | undefined;
+    canonicalId?: string | undefined;
+    citationText?: string | undefined;
+    limit?: number | undefined;
+}
+export interface KnowledgeCitationLookupResponse {
+    knowledgePackKey: string;
+    releaseKey: string;
+    results: KnowledgeSearchResult[];
+    agentGuidance?: KnowledgeAgentGuidance | undefined;
+}
+export interface KnowledgeAmendmentTrailInput {
+    sessionId: string;
+    packKey?: string | undefined;
+    releaseKey?: string | undefined;
+    canonicalId?: string | undefined;
+    blockId?: string | undefined;
+    limit?: number | undefined;
+}
+export interface KnowledgeAmendmentTrailEdge {
+    id: string;
+    relationship: string;
+    sourceBlockId: string | null;
+    targetBlockId: string | null;
+    sourceCanonicalId: string | null;
+    targetCanonicalId: string | null;
+    effectiveFrom: string | null;
+    effectiveTo: string | null;
+    evidenceText: string | null;
+    metadata: unknown;
+    sourceBlock: KnowledgeSearchResult | null;
+    targetBlock: KnowledgeSearchResult | null;
+}
+export interface KnowledgeAmendmentTrailResult {
+    knowledgePackKey: string;
+    releaseKey: string;
+    target: KnowledgeSearchResult | {
+        canonicalId?: string | undefined;
+    };
+    edges: KnowledgeAmendmentTrailEdge[];
+    agentGuidance?: KnowledgeAgentGuidance | undefined;
+}
+export interface KnowledgeEvidenceVerifyInput {
+    sessionId: string;
+    evidenceId?: string | undefined;
+    packKey?: string | undefined;
+    releaseKey?: string | undefined;
+    blockId?: string | undefined;
+    exactQuote?: string | undefined;
+    claimScope?: string | undefined;
+}
+export interface KnowledgeEvidenceVerifyResult {
+    verified: boolean;
+    quoteMatches?: boolean | undefined;
+    receipt: KnowledgeEvidenceReceipt | unknown;
+}
+export interface KnowledgeAnswerVerifyInput {
+    sessionId: string;
+    answer?: string | undefined;
+    evidenceIds: string[];
+    requireAllVerified?: boolean | undefined;
+}
+export interface KnowledgeAnswerVerifyResult {
+    verified: boolean;
+    evidenceStatus: string;
+    requireAllVerified: boolean;
+    evidenceIds: string[];
+    verifiedEvidenceIds: string[];
+    missingEvidenceIds: string[];
+    unverifiedEvidenceIds: string[];
+    cannotAnswerReasons: string[];
+    receipts: unknown[];
+    agentGuidance: KnowledgeAgentGuidance;
+}
+export interface KnowledgeCapabilityResponse {
+    capabilities: Array<{
+        packKey: string;
+        displayName: string;
+        description?: string | null | undefined;
+        category: string;
+        status: string;
+        defaultClaimScopes: unknown;
+        subscribed: boolean;
+        sessionEnabled: boolean | null;
+        activeRelease: {
+            key: string;
+            sourceReleaseKey?: string | null | undefined;
+            status: string;
+            activatedAt?: string | null | undefined;
+            embeddingModel?: string | null | undefined;
+            embeddingDimensions?: number | null | undefined;
+        } | null;
+        retrievalTools: string[];
+        structuredModules: Array<{
+            moduleKey: string;
+            displayName: string;
+            domain: string;
+            status: string;
+            activeRelease: unknown;
+            tools: string[];
+            evidenceStatus: string;
+            legalConfidence: string;
+            evidenceSummary: unknown;
+            recommendedFlows: Array<{
+                task: string;
+                tool: string;
+                when: string;
+            }>;
+            metadata: unknown;
+        }>;
+        recommendedFlows: Array<{
+            task: string;
+            tool: string;
+            when: string;
+        }>;
+        setupStatus: {
+            ready: boolean;
+            missing: string[];
+        };
+        metadata: unknown;
+    }>;
+    agentContract: {
+        sessionRequirement: string;
+        subscriptionRequirement: string;
+        evidencePolicy: string;
+        structuredToolPolicy: string;
+    };
+}
+export interface KnowledgePackListResponse {
+    packs: Array<{
+        id: string;
+        key: string;
+        displayName: string;
+        description?: string | null | undefined;
+        category?: string | undefined;
+        status: string;
+        defaultClaimScopes: unknown;
+        subscribed: boolean;
+        activeRelease: {
+            id: string;
+            key: string;
+            sourceReleaseKey?: string | null | undefined;
+            status: string;
+            activatedAt?: string | null | undefined;
+        } | null;
+        metadata: unknown;
+    }>;
+}
+export interface KnowledgeReleaseListResponse {
+    pack: {
+        id: string;
+        key: string;
+        displayName: string;
+    };
+    releases: Array<{
+        id: string;
+        key: string;
+        sourceReleaseKey?: string | null | undefined;
+        status: string;
+        active: boolean;
+        manifestHash?: string | null | undefined;
+        embeddingModel?: string | null | undefined;
+        embeddingDimensions?: number | null | undefined;
+        publishedAt?: string | null | undefined;
+        activatedAt?: string | null | undefined;
+        manifest: unknown;
+    }>;
+}
+export interface GstRuleEvidenceLink {
+    id: string;
+    entityType: string;
+    entityKey: string;
+    knowledgePackKey: string;
+    knowledgeReleaseKey: string;
+    knowledgeBlockId: string | null;
+    canonicalId: string | null;
+    evidenceId: string | null;
+    claimScope: string | null;
+    currentnessState: string;
+    verificationStatus: string;
+    sourceUrl: string | null;
+    exactQuote: string | null;
+    metadata: unknown;
+}
+export interface GstRuleWarning {
+    code: string;
+    message: string;
+    entityKey?: string | undefined;
+}
+export interface GstComplianceRuleRow {
+    id: string;
+    ruleKey: string;
+    ruleFamily: string;
+    ruleType: string;
+    category: string | null;
+    subjectKey: string | null;
+    formKey: string | null;
+    periodType: string | null;
+    taxpayerClass: string | null;
+    jurisdiction: string;
+    lawDomain: string;
+    title: string;
+    description: string | null;
+    claimScope: string;
+    currentnessState: string;
+    verificationStatus: string;
+    origin: string;
+    valueType: string | null;
+    unit: string | null;
+    value: unknown;
+    conditions: unknown;
+    priority: number;
+    applicability: unknown;
+    calculation: unknown;
+    sourceUrl: string | null;
+    sourceSection: string | null;
+    effectiveFrom: string | null;
+    effectiveTo: string | null;
+    reviewedAt: string | null;
+    reviewedBy: string | null;
+    lastVerifiedAt: string | null;
+    metadata: unknown;
+    evidenceLinks: GstRuleEvidenceLink[];
+}
+export interface GstComplianceRuleQueryInput {
+    sessionId: string;
+    packKey?: string | undefined;
+    moduleKey?: string | undefined;
+    releaseKey?: string | undefined;
+    asOfDate?: string | undefined;
+    ruleKey?: string | undefined;
+    ruleFamily?: string | undefined;
+    ruleType?: string | undefined;
+    subjectKey?: string | undefined;
+    formKey?: string | undefined;
+    periodType?: string | undefined;
+    taxpayerClass?: string | undefined;
+    limit?: number | undefined;
+}
+export interface GstFormRuleInput {
+    sessionId: string;
+    packKey?: string | undefined;
+    moduleKey?: string | undefined;
+    releaseKey?: string | undefined;
+    asOfDate?: string | undefined;
+    formKey: string;
+    periodType?: string | undefined;
+    taxpayerClass?: string | undefined;
+}
+export interface GstDueDateCalculationInput extends GstFormRuleInput {
+    periodEnd: string;
+}
+export interface GstLateFeeRuleInput extends GstFormRuleInput {
+    nilReturn?: boolean | undefined;
+}
+export interface GstLateFeeCalculationInput extends GstLateFeeRuleInput {
+    dueDate: string;
+    filedDate: string;
+}
+export interface GstInterestRuleInput {
+    sessionId: string;
+    packKey?: string | undefined;
+    moduleKey?: string | undefined;
+    releaseKey?: string | undefined;
+    asOfDate?: string | undefined;
+    taxHead?: string | undefined;
+}
+export interface GstInterestCalculationInput extends GstInterestRuleInput {
+    amountMinor: number;
+    dueDate: string;
+    paidDate: string;
+}
+export interface GstRateLookupInput {
+    sessionId: string;
+    packKey?: string | undefined;
+    moduleKey?: string | undefined;
+    releaseKey?: string | undefined;
+    asOfDate?: string | undefined;
+    codeType: 'hsn' | 'sac';
+    code: string;
+}
+export interface GstRcmCheckInput {
+    sessionId: string;
+    packKey?: string | undefined;
+    moduleKey?: string | undefined;
+    releaseKey?: string | undefined;
+    asOfDate?: string | undefined;
+    supplyKey: string;
+}
+export interface GstNoticeRuleInput {
+    sessionId: string;
+    packKey?: string | undefined;
+    moduleKey?: string | undefined;
+    releaseKey?: string | undefined;
+    asOfDate?: string | undefined;
+    noticeCode: string;
+}
+export interface GstAppealStageRuleInput {
+    sessionId: string;
+    packKey?: string | undefined;
+    moduleKey?: string | undefined;
+    releaseKey?: string | undefined;
+    asOfDate?: string | undefined;
+    stageKey: string;
+}
+export interface GstStructuredResponseContext {
+    knowledgePackKey: string;
+    knowledgeReleaseKey: string;
+    structuredModuleKey: string;
+    structuredReleaseKey: string;
+    evidenceStatus: string;
+    legalConfidence: string;
+    evidenceSummary: unknown;
+}
+export interface GstRuleQueryResponse extends GstStructuredResponseContext {
+    inputsUsed: unknown;
+    results: GstComplianceRuleRow[];
+    warnings: GstRuleWarning[];
+}
+export interface GstSingleRuleResponse extends GstStructuredResponseContext {
+    inputsUsed: unknown;
+    rule: GstComplianceRuleRow;
+    warnings: GstRuleWarning[];
+}
+export interface GstCalculationResponse extends GstStructuredResponseContext {
+    result: unknown;
+    inputsUsed: unknown;
+    ruleRowsUsed: GstComplianceRuleRow[];
+    evidenceLinks: GstRuleEvidenceLink[];
+    warnings: GstRuleWarning[];
+}
+export interface GstRateLookupResponse extends GstStructuredResponseContext {
+    inputsUsed: unknown;
+    result: unknown;
+    evidenceLinks: GstRuleEvidenceLink[];
+    warnings: GstRuleWarning[];
+}
+export interface GstRcmCheckResponse extends GstRateLookupResponse {
+}
+export interface GstNoticeRuleResponse extends GstRateLookupResponse {
+}
+export interface GstAppealStageRuleResponse extends GstRateLookupResponse {
+}
+export declare function verifyWebhookSignature(input: StacklinkWebhookSignatureInput): Promise<boolean>;
+export declare class Stacklink {
+    private readonly apiKey;
+    private readonly registrationKey;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly cacheOptions;
+    private readonly responseCache;
+    readonly webhooks: StacklinkWebhooksClient;
+    readonly triggers: StacklinkTriggersClient;
+    readonly sessions: StacklinkSessionsClient;
+    readonly logs: StacklinkLogsClient;
+    readonly apiKeys: StacklinkApiKeysClient;
+    readonly connectedAccounts: StacklinkConnectedAccountsClient;
+    readonly authConfigs: StacklinkAuthConfigsClient;
+    readonly toolkits: StacklinkToolkitsClient;
+    readonly tools: StacklinkProviderToolsClient;
+    readonly billing: StacklinkBillingClient;
+    readonly memory: StacklinkMemoryClient;
+    constructor(options: StacklinkOptions);
+    sessionMcpConnection(descriptor: StacklinkSessionMcpDescriptor): StacklinkSessionMcpConnection;
+    create(input: CreateStacklinkSessionInput): Promise<ToolRouterSession>;
+    use(sessionId: string): Promise<ToolRouterSession>;
+    clearCache(prefix?: string): void;
+    listSessions(query?: ListStacklinkSessionsInput): Promise<ListStacklinkSessionsResponse>;
+    getSession(sessionId: string): Promise<{
+        session: StacklinkSessionData;
+    }>;
+    updateSession(sessionId: string, patch: UpdateStacklinkSessionInput): Promise<{
+        session: StacklinkSessionData;
+    }>;
+    closeSession(sessionId: string): Promise<{
+        session: StacklinkSessionData;
+    }>;
+    failSession(sessionId: string, input?: {
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        session: StacklinkSessionData;
+    }>;
+    listSessionRouterFacts(sessionId: string, query?: {
+        kind?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        entries: unknown[];
+        nextCursor?: string | null;
+        kinds?: Array<{
+            kind: string;
+            count: number;
+        }>;
+    }>;
+    listSessionConnectionEvents(sessionId: string): Promise<{
+        events: unknown[];
+    }>;
+    getSessionTrace(sessionId: string, query?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<{
+        sessionId: string;
+        selectedConnectedAccountIds: string[];
+        entries: unknown[];
+        nextCursor: string | null;
+    }>;
+    getSessionConfigHistory(sessionId: string, query?: {
+        beforeVersion?: number;
+        limit?: number;
+    }): Promise<{
+        sessionId: string;
+        currentVersion: number | null;
+        versions: Array<{
+            version: number;
+            config: Record<string, unknown>;
+            changeMetadata: Record<string, unknown>;
+            createdAt: string;
+        }>;
+        nextBeforeVersion: number | null;
+    }>;
+    getSessionWorkbench(sessionId: string): Promise<{
+        workbenchSessions: WorkbenchSession[];
+        artifacts: WorkbenchArtifact[];
+        usage: unknown[];
+        cost: unknown[];
+    }>;
+    getSessionMetaTools(sessionId: string): Promise<{
+        contractVersion: string;
+        tools: StacklinkSessionMetaToolDefinition[];
+        toolRouterSession?: StacklinkSessionData;
+    }>;
+    createApiKey(input: CreateStacklinkApiKeyInput): Promise<{
+        apiKey: StacklinkApiKey;
+    }>;
+    deleteApiKey(apiKeyId: string): Promise<{
+        apiKey: StacklinkApiKey;
+    }>;
+    listProviders(): Promise<{
+        providers: ProviderToolkit[];
+    }>;
+    listProjectProviders(query?: {
+        tenantId?: string;
+    }): Promise<{
+        providers: ProjectProvider[];
+    }>;
+    listProviderTools(providerKey: string, input?: {
+        includePlanned?: boolean | undefined;
+        responseMode?: 'compact' | 'full' | undefined;
+    }): Promise<{
+        providerKey: string;
+        tools: ProviderTool[];
+        meta?: {
+            responseMode?: "compact" | "full" | undefined;
+            provider?: ProviderToolkit | undefined;
+        } | undefined;
+    }>;
+    createProject(input: {
+        clientName: string;
+        projectName?: string | undefined;
+        projectSlug?: string | undefined;
+        environment?: string | undefined;
+        keyName?: string | undefined;
+        scopes?: string[] | undefined;
+        enabledProviders?: string[] | undefined;
+        metadata?: JsonRecord | undefined;
+    }): Promise<{
+        project: StacklinkProject;
+        apiKey: {
+            id: string;
+            apiKeyId: string;
+            name: string;
+            keyName: string;
+            apiKey: string;
+            value: string;
+            prefix: string;
+            scopes: string[];
+            status: string;
+            createdAt: string;
+        };
+        enabledProviders: Array<{
+            providerKey: string;
+            status: string;
+        }>;
+    }>;
+    listProjects(input?: {
+        status?: 'active' | 'deleted' | 'all' | undefined;
+        limit?: number | undefined;
+        cursor?: string | undefined;
+        registration?: boolean | undefined;
+    }): Promise<{
+        projects: StacklinkProject[];
+        nextCursor: string | null;
+    }>;
+    getProject(projectId: string, input?: {
+        registration?: boolean | undefined;
+    }): Promise<{
+        project: StacklinkProject;
+    }>;
+    resetProjectAuthConfigs(projectId: string): Promise<{
+        resetAt: string;
+        resetCount: {
+            authConfigs: number;
+            accounts: number;
+            triggers: number;
+        };
+        providerSideTokensRevoked: boolean;
+    }>;
+    listProjectProviderAccess(projectId: string): Promise<{
+        providers: ProjectProvider[];
+    }>;
+    setProjectProviderAccess(projectId: string, providerKey: string, input?: {
+        status?: 'enabled' | 'disabled' | 'planned' | undefined;
+        enabledBy?: string | undefined;
+        metadata?: JsonRecord | undefined;
+    }): Promise<{
+        provider: ProjectProvider;
+    }>;
+    inspectConnectToken(publicToken: string): Promise<{
+        connectionRequest: ConnectionRequestResponse;
+    }>;
+    completeConnectToken(publicToken: string, input: Record<string, unknown>): Promise<{
+        connectedAccount: ConnectedAccount;
+        connectionRequest?: ConnectionRequestResponse;
+    }>;
+    startOAuthConnect(publicToken: string): Promise<Record<string, unknown>>;
+    getConnectionRequest(requestId: string): Promise<{
+        connectionRequest: ConnectionRequestResponse;
+    }>;
+    searchTools(input: Record<string, unknown>): Promise<{
+        tools: ProviderTool[];
+        queries?: unknown[];
+        meta?: unknown;
+    }>;
+    getToolSchemas(input: {
+        sessionId: string;
+        toolKeys: string[];
+        includePlanned?: boolean | undefined;
+    }): Promise<{
+        tools: ProviderTool[];
+    }>;
+    getRuntimeToolContracts(input: {
+        sessionId: string;
+        toolkitKeys?: string[] | undefined;
+        toolKeys?: string[] | undefined;
+        includePlanned?: boolean | undefined;
+    }): Promise<{
+        contract: string;
+        sessionId: string;
+        tools: ProviderTool[];
+        meta?: unknown;
+    }>;
+    executeTool(input: Record<string, unknown>, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    executeToolsBatch(input: Record<string, unknown>, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    getSubscription(): Promise<StacklinkUsageSummary>;
+    listBillingPlans(): Promise<{
+        plans: StacklinkBillingPlan[];
+    }>;
+    getUsage(): Promise<StacklinkUsageSummary>;
+    listUsageEvents(query?: {
+        sourceType?: string | undefined;
+        operationClass?: StacklinkUsageOperationClass | undefined;
+        limit?: number | undefined;
+    }): Promise<{
+        events: StacklinkUsageMeterEvent[];
+    }>;
+    createBillingCheckout(input: {
+        planKey: string;
+        billingInterval?: StacklinkBillingInterval | undefined;
+        successUrl?: string | undefined;
+        cancelUrl?: string | undefined;
+    }): Promise<StacklinkBillingCheckoutSession>;
+    createBillingPortal(input?: {
+        returnUrl?: string | undefined;
+    }): Promise<StacklinkBillingPortalSession>;
+    setWorkspaceSubscriptionPlanForProject(projectId: string, input: {
+        planKey: string;
+        status?: string | undefined;
+        metadata?: JsonRecord | undefined;
+    }): Promise<{
+        subscription: StacklinkWorkspaceSubscription;
+        usage: StacklinkUsageSummary;
+    }>;
+    listAuthConfigs(query?: {
+        providerKey?: string;
+        includeDisabled?: boolean;
+    }): Promise<{
+        authConfigs: AuthConfig[];
+    }>;
+    createAuthConfig(input: Record<string, unknown>): Promise<{
+        authConfig: AuthConfig;
+    }>;
+    workbenchModels(): Promise<{
+        models: WorkbenchModelOption[];
+        defaultModel: string;
+        webSearchDefaultProvider: string;
+    }>;
+    runWorkbench(input: Record<string, unknown>, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    useWorkbenchSession(input: {
+        sessionId: string;
+        workbenchSessionId?: string | undefined;
+        createNew?: boolean | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }): Promise<{
+        workbenchSession: WorkbenchSession;
+        reused: boolean;
+    }>;
+    deleteWorkbenchSession(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+    }): Promise<WorkbenchSessionDeleteReceipt>;
+    listWorkbenchFiles(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+    }): Promise<{
+        workbenchSession: WorkbenchSession;
+        files: WorkbenchFile[];
+    }>;
+    readWorkbenchFile(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+        path: string;
+    }): Promise<{
+        workbenchSession: WorkbenchSession;
+        file: WorkbenchFile;
+    }>;
+    uploadWorkbenchFile(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+        path: string;
+        content: string | Uint8Array;
+        contentType?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }): Promise<{
+        workbenchSession: WorkbenchSession;
+        file: WorkbenchFile;
+    }>;
+    prepareWorkbenchFileUpload(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+        path: string;
+        contentType: string;
+        sizeBytes: number;
+    }): Promise<{
+        workbenchSession: WorkbenchSession;
+        upload: WorkbenchFileSignedUpload;
+    }>;
+    finalizeWorkbenchFileUpload(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+        uploadId: string;
+        metadata?: Record<string, unknown> | undefined;
+    }): Promise<{
+        file: WorkbenchFile;
+    }>;
+    uploadWorkbenchFileDirect(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+        path: string;
+        content: string | Uint8Array;
+        contentType?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }): Promise<{
+        file: WorkbenchFile;
+    }>;
+    getWorkbenchFileDownload(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+        path: string;
+    }): Promise<WorkbenchFileSignedDownload>;
+    downloadWorkbenchFile(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+        path: string;
+    }): Promise<Response>;
+    deleteWorkbenchFile(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+        path: string;
+    }): Promise<{
+        workbenchSession: WorkbenchSession;
+        file: WorkbenchFile;
+        deleted: true;
+    }>;
+    createWorkbenchRunDefinition(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+        executionId: string;
+        seriesId?: string | undefined;
+        name: string;
+        description?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }): Promise<{
+        runDefinition: WorkbenchRunDefinition;
+    }>;
+    listWorkbenchRunDefinitions(input: {
+        sessionId: string;
+        workbenchSessionId?: string | undefined;
+        seriesId?: string | undefined;
+        cursor?: string | undefined;
+        limit?: number | undefined;
+    }): Promise<{
+        runDefinitions: WorkbenchRunDefinition[];
+        limit: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    }>;
+    getWorkbenchRunDefinition(input: {
+        sessionId: string;
+        runDefinitionId: string;
+    }): Promise<{
+        runDefinition: WorkbenchRunDefinition;
+    }>;
+    updateWorkbenchRunDefinition(input: {
+        sessionId: string;
+        runDefinitionId: string;
+        name?: string | undefined;
+        description?: string | null | undefined;
+        versionReason?: string | null | undefined;
+    }): Promise<{
+        runDefinition: WorkbenchRunDefinition;
+    }>;
+    replayWorkbenchRunDefinition(input: {
+        sessionId: string;
+        runDefinitionId: string;
+        background?: boolean | undefined;
+        timeoutMs?: number | undefined;
+        environmentMode?: WorkbenchReplayEnvironmentMode | undefined;
+        idempotencyKey: string;
+    }): Promise<WorkbenchRunReplayResponse>;
+    publishWorkbenchRunDefinition(input: {
+        sessionId: string;
+        runDefinitionId: string;
+        expectedPublishedVersion: number | null;
+    }): Promise<{
+        runDefinition: WorkbenchRunDefinition;
+    }>;
+    rollbackWorkbenchRunDefinition(input: {
+        sessionId: string;
+        runDefinitionId: string;
+        expectedPublishedVersion: number | null;
+    }): Promise<{
+        runDefinition: WorkbenchRunDefinition;
+    }>;
+    destroyWorkbenchSession(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+    }, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    runWorkbenchBash(input: Record<string, unknown>, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    waitForWorkbenchResponse(input: Record<string, unknown>, accepted: Record<string, unknown>, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    listExecutions(input: {
+        sessionId: string;
+        executionKind?: StacklinkExecutionKind | undefined;
+        workbenchSessionId?: string | undefined;
+        status?: string | undefined;
+        cursor?: string | undefined;
+        limit?: number | undefined;
+    }, options?: StacklinkRequestOptions): Promise<{
+        executions: unknown[];
+        limit: number;
+        nextCursor: string | null;
+        liveCount: number;
+    }>;
+    getExecution(input: {
+        sessionId: string;
+        executionKind: StacklinkExecutionKind;
+        executionId: string;
+        includeEvents?: boolean | undefined;
+        eventLimit?: number | undefined;
+    }, options?: StacklinkRequestOptions): Promise<{
+        execution: unknown;
+        events?: unknown[] | undefined;
+        limit?: number | undefined;
+        hasMore?: boolean | undefined;
+        nextCursor?: string | null | undefined;
+    }>;
+    readExecutionEvents(input: {
+        sessionId: string;
+        executionKind: StacklinkExecutionKind;
+        executionId: string;
+        afterSequence?: string | number | bigint | undefined;
+        limit?: number | undefined;
+    }, options?: StacklinkRequestOptions): Promise<{
+        events: unknown[];
+        limit: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    }>;
+    waitForExecution(input: {
+        sessionId: string;
+        executionKind: StacklinkExecutionKind;
+        executionId: string;
+        waitTimeoutMs?: number | undefined;
+        pollIntervalMs?: number | undefined;
+    }, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    cancelExecution(input: {
+        sessionId: string;
+        executionKind: StacklinkExecutionKind;
+        executionId: string;
+        reason?: string | undefined;
+    }, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    getAuthConfig(authConfigId: string): Promise<{
+        authConfig: AuthConfig;
+    }>;
+    updateAuthConfig(authConfigId: string, patch: Record<string, unknown>): Promise<{
+        authConfig: AuthConfig;
+    }>;
+    enableAuthConfig(authConfigId: string): Promise<{
+        authConfig: AuthConfig;
+    }>;
+    disableAuthConfig(authConfigId: string): Promise<{
+        authConfig: AuthConfig;
+    }>;
+    deleteAuthConfig(authConfigId: string): Promise<{
+        authConfig: AuthConfig;
+    }>;
+    listConnectedAccounts(tenantId: string): Promise<{
+        connections: ConnectedAccount[];
+    }>;
+    createConnectedAccount(input: Record<string, unknown>): Promise<{
+        account: ConnectedAccount;
+    }>;
+    getConnectedAccount(accountId: string): Promise<{
+        account: ConnectedAccount;
+    }>;
+    listConnectedAccountTools(accountId: string, input?: {
+        includePlanned?: boolean | undefined;
+        toolKeys?: string[] | undefined;
+    }): Promise<{
+        contract: string;
+        sessionId: string;
+        tools: ProviderTool[];
+        meta?: unknown;
+    }>;
+    listConnectedAccountResources(accountId: string, input?: ConnectedAccountResourceListOptions): Promise<ConnectedAccountResourcesResponse>;
+    refreshConnectedAccountResources(accountId: string, input?: ConnectedAccountResourceListOptions): Promise<ConnectedAccountResourcesResponse>;
+    resolveConnectedAccountResource(accountId: string, input: ConnectedAccountResourceResolveInput): Promise<{
+        accountId: string;
+        providerKey: string;
+        resource: ConnectedAccountResource;
+    }>;
+    updateConnectedAccount(accountId: string, patch: Record<string, unknown>): Promise<{
+        account: ConnectedAccount;
+    }>;
+    enableConnectedAccount(accountId: string): Promise<{
+        account: ConnectedAccount;
+    }>;
+    disableConnectedAccount(accountId: string): Promise<{
+        account: ConnectedAccount;
+    }>;
+    refreshConnectedAccount(accountId: string): Promise<{
+        account: ConnectedAccount;
+    }>;
+    validateConnectedAccount(accountId: string): Promise<unknown>;
+    deleteConnectedAccount(accountId: string): Promise<{
+        account: ConnectedAccount;
+    }>;
+    listConnectedAccountSecrets(accountId: string): Promise<{
+        secrets: unknown[];
+    }>;
+    runConnectionHealthCheck(input?: Record<string, unknown>): Promise<unknown>;
+    listTriggerTypes(query?: {
+        providerKey?: string;
+    }): Promise<{
+        triggerTypes: TriggerType[];
+    }>;
+    listTriggerSubscriptions(query?: ListTriggerSubscriptionsInput): Promise<{
+        subscriptions: TriggerSubscription[];
+    }>;
+    createTriggerSubscription(input: CreateTriggerSubscriptionInput): Promise<{
+        subscription: TriggerSubscription;
+    }>;
+    getTriggerSubscription(subscriptionId: string): Promise<{
+        subscription: TriggerSubscription;
+    }>;
+    updateTriggerSubscription(subscriptionId: string, patch: UpdateTriggerSubscriptionInput): Promise<{
+        subscription: TriggerSubscription;
+    }>;
+    deleteTriggerSubscription(subscriptionId: string): Promise<{
+        subscription: TriggerSubscription;
+    }>;
+    listWebhookEventTypes(): Promise<{
+        eventTypes: Array<{
+            eventType: StacklinkWebhookEventType;
+        }>;
+    }>;
+    getWebhook(): Promise<{
+        webhook: StacklinkWebhookEndpoint;
+    }>;
+    updateWebhook(input: {
+        callbackUrl?: string | null;
+        status?: 'active' | 'disabled';
+        eventTypes?: StacklinkWebhookEventType[];
+    }): Promise<{
+        webhook: StacklinkWebhookEndpoint;
+        signingSecret?: string;
+    }>;
+    rotateWebhookSecret(): Promise<{
+        webhook: StacklinkWebhookEndpoint;
+        signingSecret: string;
+    }>;
+    sendWebhookTest(input: {
+        eventType: StacklinkWebhookEventType;
+    }): Promise<StacklinkWebhookTestResult>;
+    verifyWebhookSignature(input: StacklinkWebhookSignatureInput): Promise<boolean>;
+    replayProviderEvent(eventId: string): Promise<unknown>;
+    retryWebhookDelivery(deliveryId: string, input?: {
+        force?: boolean;
+    }): Promise<unknown>;
+    redriveDeadLetterWebhookDeliveries(input?: {
+        limit?: number;
+        force?: boolean;
+    }): Promise<unknown>;
+    runTriggerPoller(input?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    runTriggerDeliveries(input?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getProviderArtifact(artifactId: string): Promise<{
+        artifact: ProviderArtifact;
+    }>;
+    getLogSummary(query?: {
+        clientChannel?: string;
+        clientName?: string;
+        tenantId?: string;
+        sessionId?: string;
+        providerKey?: string;
+        toolKey?: string;
+        requestId?: string;
+        apiKeyId?: string;
+        route?: string;
+        status?: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+    }): Promise<{
+        summary: LogSummary;
+    }>;
+    listRequestLogs(query?: {
+        clientChannel?: string;
+        clientName?: string;
+        tenantId?: string;
+        sessionId?: string;
+        providerKey?: string;
+        toolKey?: string;
+        requestId?: string;
+        apiKeyId?: string;
+        route?: string;
+        status?: string;
+        cursor?: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+    }): Promise<{
+        logs: RequestLog[];
+        nextCursor?: string | null;
+    }>;
+    getRequestLog(logId: string): Promise<{
+        log: RequestLog;
+    }>;
+    listToolLogs(query?: {
+        clientChannel?: string;
+        clientName?: string;
+        tenantId?: string;
+        sessionId?: string;
+        accountId?: string;
+        requestLogId?: string;
+        providerKey?: string;
+        toolKey?: string;
+        status?: string;
+        cursor?: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+    }): Promise<{
+        logs: ToolExecutionLog[];
+        nextCursor?: string | null;
+    }>;
+    getToolLog(logId: string): Promise<{
+        log: ToolExecutionLog;
+    }>;
+    listTriggerLogs(query?: {
+        tenantId?: string;
+        accountId?: string;
+        providerKey?: string;
+        eventScope?: string;
+        eventType?: string;
+        externalEventId?: string;
+        status?: string;
+        cursor?: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+    }): Promise<{
+        events: TriggerEventLog[];
+        logs?: TriggerEventLog[];
+        nextCursor?: string | null;
+    }>;
+    getTriggerLog(logId: string): Promise<{
+        event: TriggerEventLog;
+    }>;
+    listWebhookDeliveries(query?: {
+        tenantId?: string;
+        accountId?: string;
+        providerKey?: string;
+        eventScope?: string;
+        externalEventId?: string;
+        deliveryId?: string;
+        rawEventId?: string;
+        subscriptionId?: string;
+        status?: string;
+        cursor?: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+    }): Promise<{
+        deliveries: unknown[];
+        logs?: unknown[];
+        nextCursor?: string | null;
+    }>;
+    getWebhookDeliveryLog(deliveryId: string): Promise<{
+        delivery: unknown;
+    }>;
+    listWorkbenchSessions(query?: {
+        tenantId?: string;
+        platformSessionId?: string;
+        status?: string;
+        limit?: number;
+    }): Promise<{
+        workbenchSessions: WorkbenchSession[];
+    }>;
+    getWorkbenchSession(workbenchSessionId: string): Promise<{
+        workbenchSession: WorkbenchSession;
+    }>;
+    getWorkbenchUsage(workbenchSessionId: string): Promise<WorkbenchUsage>;
+    listWorkbenchArtifacts(query?: {
+        tenantId?: string;
+        workbenchSessionId?: string;
+        status?: string;
+        limit?: number;
+    }): Promise<{
+        artifacts: WorkbenchArtifact[];
+    }>;
+    getWorkbenchArtifactDownloadUrl(artifactId: string): Promise<unknown>;
+    downloadWorkbenchArtifact(artifactId: string): Promise<Response>;
+    promoteWorkbenchArtifact(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+        path: string;
+        label?: string | undefined;
+        contentType?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }): Promise<{
+        workbenchSession: WorkbenchSession;
+        artifact: WorkbenchArtifact;
+    }>;
+    deleteWorkbenchArtifact(input: {
+        sessionId: string;
+        workbenchSessionId: string;
+        artifactId: string;
+        path?: string | undefined;
+    }): Promise<{
+        workbenchSession: WorkbenchSession;
+        artifact: WorkbenchArtifact;
+        deleted: boolean;
+    }>;
+    listWorkbenchBudgets(query?: {
+        tenantId?: string;
+        workbenchSessionId?: string;
+        status?: string;
+        limit?: number;
+    }): Promise<{
+        budgetPolicies: WorkbenchBudgetPolicy[];
+    }>;
+    createWorkbenchBudget(input: Record<string, unknown>): Promise<{
+        budgetPolicy: WorkbenchBudgetPolicy;
+    }>;
+    updateWorkbenchBudget(budgetPolicyId: string, patch: Record<string, unknown>): Promise<{
+        budgetPolicy: WorkbenchBudgetPolicy;
+    }>;
+    deleteWorkbenchBudget(budgetPolicyId: string): Promise<{
+        budgetPolicy: WorkbenchBudgetPolicy;
+    }>;
+    mcpRequest(input: Record<string, unknown> | Array<Record<string, unknown>>, options?: StacklinkRequestOptions): Promise<unknown>;
+    mcpSessionRequest(sessionId: string, input: Record<string, unknown> | Array<Record<string, unknown>>, options?: StacklinkRequestOptions): Promise<unknown>;
+    private mcpRequestAtPath;
+    mcpRequestStream(input: Record<string, unknown>, options?: StacklinkMcpStreamOptions): Promise<unknown>;
+    mcpSessionRequestStream(sessionId: string, input: Record<string, unknown>, options?: StacklinkMcpStreamOptions): Promise<unknown>;
+    private mcpRequestStreamAtPath;
+    listMcpTools(): Promise<unknown>;
+    callMcpTool(name: StacklinkToolSurfaceName, args: Record<string, unknown>): Promise<unknown>;
+    callSessionMcpTool(sessionId: string, name: StacklinkToolSurfaceName, args: Record<string, unknown>): Promise<unknown>;
+    listKnowledgePacks(): Promise<KnowledgePackListResponse>;
+    getKnowledgeCapabilities(input?: {
+        sessionId?: string | undefined;
+        packKey?: string | undefined;
+    }): Promise<KnowledgeCapabilityResponse>;
+    listKnowledgeReleases(packKey: string): Promise<KnowledgeReleaseListResponse>;
+    subscribeKnowledgePack(packKey: string, input?: Record<string, unknown>): Promise<unknown>;
+    searchKnowledge(input: KnowledgeSearchInput): Promise<KnowledgeSearchResponse>;
+    lookupKnowledgeCitation(input: KnowledgeCitationLookupInput): Promise<KnowledgeCitationLookupResponse>;
+    getKnowledgeAmendmentTrail(input: KnowledgeAmendmentTrailInput): Promise<KnowledgeAmendmentTrailResult>;
+    verifyKnowledgeEvidence(input: KnowledgeEvidenceVerifyInput): Promise<KnowledgeEvidenceVerifyResult>;
+    verifyKnowledgeAnswer(input: KnowledgeAnswerVerifyInput): Promise<KnowledgeAnswerVerifyResult>;
+    getGstComplianceRule(input: GstComplianceRuleQueryInput): Promise<GstRuleQueryResponse>;
+    getGstDueDateRule(input: GstFormRuleInput): Promise<GstSingleRuleResponse>;
+    calculateGstDueDate(input: GstDueDateCalculationInput): Promise<GstCalculationResponse>;
+    getGstLateFeeRule(input: GstLateFeeRuleInput): Promise<GstSingleRuleResponse>;
+    calculateGstLateFee(input: GstLateFeeCalculationInput): Promise<GstCalculationResponse>;
+    getGstInterestRule(input: GstInterestRuleInput): Promise<GstSingleRuleResponse>;
+    calculateGstInterest(input: GstInterestCalculationInput): Promise<GstCalculationResponse>;
+    lookupGstHsnSacRate(input: GstRateLookupInput): Promise<GstRateLookupResponse>;
+    checkGstRcm(input: GstRcmCheckInput): Promise<GstRcmCheckResponse>;
+    getGstNoticeRule(input: GstNoticeRuleInput): Promise<GstNoticeRuleResponse>;
+    getGstAppealStageRule(input: GstAppealStageRuleInput): Promise<GstAppealStageRuleResponse>;
+    private attachAbortSignalCancellation;
+    request<T>(path: string, init?: StacklinkRequestInit): Promise<T>;
+    requestRaw(path: string, init?: StacklinkRequestInit): Promise<Response>;
+    cachedDiscoveryRequest<T>(cacheKey: string, ttlMs: number, control: StacklinkDiscoveryCacheControl | undefined, producer: () => Promise<T>): Promise<T>;
+    discoveryCacheTtl(kind: 'toolsList' | 'toolkits' | 'schemas' | 'search'): number;
+    private trimResponseCache;
+    private readMcpEventStream;
+    private requestHeaders;
+}
+export declare class StacklinkWebhooksClient {
+    private readonly client;
+    constructor(client: Stacklink);
+    listEventTypes(): Promise<{
+        eventTypes: {
+            eventType: StacklinkWebhookEventType;
+        }[];
+    }>;
+    get(): Promise<{
+        webhook: StacklinkWebhookEndpoint;
+    }>;
+    update(input: {
+        callbackUrl?: string | null;
+        status?: 'active' | 'disabled';
+        eventTypes?: StacklinkWebhookEventType[];
+    }): Promise<{
+        webhook: StacklinkWebhookEndpoint;
+        signingSecret?: string;
+    }>;
+    rotateSecret(): Promise<{
+        webhook: StacklinkWebhookEndpoint;
+        signingSecret: string;
+    }>;
+    sendTest(input: {
+        eventType: StacklinkWebhookEventType;
+    }): Promise<StacklinkWebhookTestResult>;
+    retryDelivery(deliveryId: string, input?: {
+        force?: boolean;
+    }): Promise<unknown>;
+    redriveDeadLetters(input?: {
+        limit?: number;
+        force?: boolean;
+    }): Promise<unknown>;
+    replayEvent(eventId: string): Promise<unknown>;
+    verifySignature(input: StacklinkWebhookSignatureInput): Promise<boolean>;
+}
+export declare class StacklinkTriggersClient {
+    private readonly client;
+    constructor(client: Stacklink);
+    listTypes(query?: {
+        providerKey?: string;
+    }): Promise<{
+        triggerTypes: TriggerType[];
+    }>;
+    listSubscriptions(query?: ListTriggerSubscriptionsInput): Promise<{
+        subscriptions: TriggerSubscription[];
+    }>;
+    createSubscription(input: CreateTriggerSubscriptionInput): Promise<{
+        subscription: TriggerSubscription;
+    }>;
+    getSubscription(subscriptionId: string): Promise<{
+        subscription: TriggerSubscription;
+    }>;
+    updateSubscription(subscriptionId: string, patch: UpdateTriggerSubscriptionInput): Promise<{
+        subscription: TriggerSubscription;
+    }>;
+    deleteSubscription(subscriptionId: string): Promise<{
+        subscription: TriggerSubscription;
+    }>;
+    runPoll(input?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    runDeliveries(input?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+export interface StacklinkMemoryAccessSelector {
+    tenantId?: string | undefined;
+    externalTenantId?: string | undefined;
+    sessionId?: string | undefined;
+    subjectType?: MemorySubjectRef['type'] | undefined;
+    externalSubjectId?: string | undefined;
+}
+export declare class StacklinkMemoryClient {
+    private readonly client;
+    constructor(client: Stacklink);
+    listPolicies(): Promise<JsonRecord>;
+    createPolicy(input: MemoryProjectPolicyInput): Promise<JsonRecord>;
+    getPolicy(policyKey?: string): Promise<JsonRecord>;
+    policyHistory(policyKey?: string): Promise<JsonRecord>;
+    previewPolicy(input: MemoryPolicyPreviewInput, policyKey?: string): Promise<JsonRecord>;
+    updatePolicy(policyKey: string, input: MemoryProjectPolicyUpdateInput): Promise<JsonRecord>;
+    deletePolicy(policyKey: string): Promise<JsonRecord>;
+    ingest(input: MemoryIngestInput): Promise<JsonRecord>;
+    ingestRich(input: MemoryRichIngestInput): Promise<JsonRecord>;
+    getRichIngest(jobId: string): Promise<JsonRecord>;
+    recordConversationTurn(input: MemoryConversationTurnInput): Promise<JsonRecord>;
+    add(input: Omit<MemoryIngestInput, 'mode'>): Promise<JsonRecord>;
+    search(input: MemorySearchInput): Promise<JsonRecord>;
+    context(input: MemoryContextInput): Promise<JsonRecord>;
+    list(input: StacklinkMemoryAccessSelector & {
+        kind?: 'fact' | 'episode' | 'profile_item' | 'block' | undefined;
+        sourceKind?: 'direct' | 'conversation' | 'document' | 'provider' | 'tool_execution' | 'artifact' | undefined;
+        state?: 'current' | 'conflicted' | undefined;
+        cursor?: string | undefined;
+        limit?: number | undefined;
+    }): Promise<JsonRecord>;
+    listForgotten(input: StacklinkMemoryAccessSelector & {
+        kind?: 'fact' | 'episode' | 'profile_item' | 'block' | undefined;
+        sourceKind?: 'direct' | 'conversation' | 'document' | 'provider' | 'tool_execution' | 'artifact' | undefined;
+        cursor?: string | undefined;
+        limit?: number | undefined;
+    }): Promise<JsonRecord>;
+    get(memoryId: string, selector: StacklinkMemoryAccessSelector): Promise<JsonRecord>;
+    history(memoryId: string, selector: StacklinkMemoryAccessSelector): Promise<JsonRecord>;
+    update(memoryId: string, input: StacklinkMemoryAccessSelector & {
+        patch: {
+            content?: string | undefined;
+            title?: string | null | undefined;
+            memoryType?: 'preference' | 'decision' | 'commitment' | 'goal' | 'constraint' | 'relationship' | 'durable_fact' | undefined;
+            sensitivityClass?: 'standard' | 'personal' | 'restricted' | undefined;
+            restrictedDataClasses?: Array<'health' | 'biometric' | 'government_identity' | 'precise_location' | 'protected_trait' | 'minor' | 'detailed_personal_financial'> | undefined;
+            topicTags?: string[] | undefined;
+            language?: string | null | undefined;
+            validFrom?: string | null | undefined;
+            validTo?: string | null | undefined;
+            state?: 'current' | 'conflicted' | undefined;
+            reason?: string | undefined;
+            metadata?: JsonRecord | undefined;
+        };
+    }): Promise<JsonRecord>;
+    forget(memoryId: string, input: StacklinkMemoryAccessSelector & {
+        reason?: string | undefined;
+    }): Promise<JsonRecord>;
+    restore(memoryId: string, input: StacklinkMemoryAccessSelector & {
+        reason?: string | undefined;
+    }): Promise<JsonRecord>;
+    erase(memoryId: string, input: StacklinkMemoryAccessSelector & {
+        reason?: string | undefined;
+    }): Promise<JsonRecord>;
+    previewErasure(memoryId: string, selector: StacklinkMemoryAccessSelector): Promise<JsonRecord>;
+    getErasure(erasureJobId: string): Promise<JsonRecord>;
+    profile(selector: StacklinkMemoryAccessSelector): Promise<JsonRecord>;
+    subjectProfile(subjectId: string, selector: StacklinkMemoryAccessSelector): Promise<JsonRecord>;
+    listSubjects(input: {
+        tenantId?: string | undefined;
+        externalTenantId?: string | undefined;
+        type?: MemorySubjectRef['type'] | undefined;
+        status?: 'active' | 'erased' | undefined;
+        cursor?: string | undefined;
+        limit?: number | undefined;
+    }): Promise<JsonRecord>;
+    eraseSubject(subjectId: string, input: {
+        tenantId?: string | undefined;
+        externalTenantId?: string | undefined;
+        reason?: string | undefined;
+    }): Promise<JsonRecord>;
+    createBlock(input: {
+        tenantId?: string | undefined;
+        externalTenantId?: string | undefined;
+        sessionId?: string | undefined;
+        subjects?: MemorySubjectRef[] | undefined;
+        title: string;
+        content: string;
+        access?: 'read_only' | 'editable' | undefined;
+        priority?: number | undefined;
+        required?: boolean | undefined;
+        metadata?: JsonRecord | undefined;
+    }): Promise<JsonRecord>;
+    listBlocks(selector: StacklinkMemoryAccessSelector): Promise<JsonRecord>;
+    updateBlock(blockId: string, input: StacklinkMemoryAccessSelector & {
+        patch: {
+            title?: string | undefined;
+            content?: string | undefined;
+            access?: 'read_only' | 'editable' | undefined;
+            priority?: number | undefined;
+            required?: boolean | undefined;
+            metadata?: JsonRecord | undefined;
+        };
+    }): Promise<JsonRecord>;
+    revokeBlock(blockId: string, selector: StacklinkMemoryAccessSelector): Promise<JsonRecord>;
+    queryGraph(input: MemoryGraphQueryInput): Promise<JsonRecord>;
+    createSource(input: MemorySourceBindingInput): Promise<JsonRecord>;
+    previewConnectedSource(input: MemoryConnectedSourcePreviewInput): Promise<JsonRecord>;
+    createConnectedSource(input: MemoryConnectedSourceInput): Promise<JsonRecord>;
+    listSources(input: {
+        tenantId?: string | undefined;
+        externalTenantId?: string | undefined;
+        status?: 'active' | 'paused' | 'degraded' | 'failed' | undefined;
+    }): Promise<JsonRecord>;
+    getSource(bindingId: string): Promise<JsonRecord>;
+    setSourceStatus(bindingId: string, status: 'active' | 'paused'): Promise<JsonRecord>;
+    updateSource(bindingId: string, input: MemorySourceBindingUpdateInput): Promise<JsonRecord>;
+    deleteSource(bindingId: string): Promise<JsonRecord>;
+    replaySourceItem(bindingId: string, itemId: string): Promise<JsonRecord>;
+    listSourceDeliveries(input?: {
+        tenantId?: string | undefined;
+        status?: 'pending' | 'processing' | 'retry' | 'completed' | 'dead_letter' | undefined;
+        limit?: number | undefined;
+    }): Promise<JsonRecord>;
+    replaySourceDelivery(deliveryId: string): Promise<JsonRecord>;
+    export(input: MemoryExportInput): Promise<JsonRecord>;
+    getExport(exportId: string): Promise<JsonRecord>;
+    dataManagement(input?: {
+        tenantId?: string | undefined;
+    }): Promise<JsonRecord>;
+    createLegalHold(input: MemoryLegalHoldInput): Promise<JsonRecord>;
+    releaseLegalHold(holdId: string): Promise<JsonRecord>;
+}
+export declare class StacklinkSessionsClient {
+    private readonly client;
+    constructor(client: Stacklink);
+    create(input: CreateStacklinkSessionInput): Promise<ToolRouterSession>;
+    use(sessionId: string): Promise<ToolRouterSession>;
+    list(query?: ListStacklinkSessionsInput): Promise<ListStacklinkSessionsResponse>;
+    get(sessionId: string): Promise<{
+        session: StacklinkSessionData;
+    }>;
+    update(sessionId: string, patch: UpdateStacklinkSessionInput): Promise<{
+        session: StacklinkSessionData;
+    }>;
+    close(sessionId: string): Promise<{
+        session: StacklinkSessionData;
+    }>;
+    fail(sessionId: string, input?: {
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        session: StacklinkSessionData;
+    }>;
+    metaTools(sessionId: string): Promise<{
+        contractVersion: string;
+        tools: StacklinkSessionMetaToolDefinition[];
+        toolRouterSession?: StacklinkSessionData;
+    }>;
+    toolkits(sessionId: string): Promise<{
+        toolkits: ProjectProvider[];
+    }>;
+    streamEvents(sessionId: string, input?: {
+        after?: string;
+        eventTypes?: string[];
+        limit?: number;
+        pollIntervalMs?: number;
+    }): Promise<Response>;
+    listRouterFacts(sessionId: string, query?: {
+        kind?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        entries: unknown[];
+        nextCursor?: string | null;
+        kinds?: {
+            kind: string;
+            count: number;
+        }[];
+    }>;
+    listConnectionEvents(sessionId: string): Promise<{
+        events: unknown[];
+    }>;
+    workbench(sessionId: string): Promise<{
+        workbenchSessions: WorkbenchSession[];
+        artifacts: WorkbenchArtifact[];
+        usage: unknown[];
+        cost: unknown[];
+    }>;
+}
+export declare class StacklinkLogsClient {
+    private readonly client;
+    constructor(client: Stacklink);
+    summary(): Promise<{
+        summary: LogSummary;
+    }>;
+    listRequests(query?: Parameters<Stacklink['listRequestLogs']>[0]): Promise<{
+        logs: RequestLog[];
+        nextCursor?: string | null;
+    }>;
+    getRequest(logId: string): Promise<{
+        log: RequestLog;
+    }>;
+    listTools(query?: Parameters<Stacklink['listToolLogs']>[0]): Promise<{
+        logs: ToolExecutionLog[];
+        nextCursor?: string | null;
+    }>;
+    getTool(logId: string): Promise<{
+        log: ToolExecutionLog;
+    }>;
+    listTriggers(query?: Parameters<Stacklink['listTriggerLogs']>[0]): Promise<{
+        events: TriggerEventLog[];
+        logs?: TriggerEventLog[];
+        nextCursor?: string | null;
+    }>;
+    getTrigger(logId: string): Promise<{
+        event: TriggerEventLog;
+    }>;
+    listWebhookDeliveries(query?: Parameters<Stacklink['listWebhookDeliveries']>[0]): Promise<{
+        deliveries: unknown[];
+        logs?: unknown[];
+        nextCursor?: string | null;
+    }>;
+    getWebhookDelivery(deliveryId: string): Promise<{
+        delivery: unknown;
+    }>;
+    retryWebhookDelivery(deliveryId: string, input?: {
+        force?: boolean;
+    }): Promise<unknown>;
+    redriveDeadLetters(input?: {
+        limit?: number;
+        force?: boolean;
+    }): Promise<unknown>;
+    replayProviderEvent(eventId: string): Promise<unknown>;
+}
+export declare class StacklinkApiKeysClient {
+    private readonly client;
+    constructor(client: Stacklink);
+    create(input: CreateStacklinkApiKeyInput): Promise<{
+        apiKey: StacklinkApiKey;
+    }>;
+    delete(apiKeyId: string): Promise<{
+        apiKey: StacklinkApiKey;
+    }>;
+}
+export declare class StacklinkBillingClient {
+    private readonly client;
+    constructor(client: Stacklink);
+    getSubscription(): Promise<StacklinkUsageSummary>;
+    listPlans(): Promise<{
+        plans: StacklinkBillingPlan[];
+    }>;
+    getUsage(): Promise<StacklinkUsageSummary>;
+    listUsageEvents(query?: {
+        sourceType?: string | undefined;
+        operationClass?: StacklinkUsageOperationClass | undefined;
+        limit?: number | undefined;
+    }): Promise<{
+        events: StacklinkUsageMeterEvent[];
+    }>;
+    createCheckout(input: {
+        planKey: string;
+        billingInterval?: StacklinkBillingInterval | undefined;
+        successUrl?: string | undefined;
+        cancelUrl?: string | undefined;
+    }): Promise<StacklinkBillingCheckoutSession>;
+    createPortal(input?: {
+        returnUrl?: string | undefined;
+    }): Promise<StacklinkBillingPortalSession>;
+    setWorkspacePlanForProject(projectId: string, input: {
+        planKey: string;
+        status?: string | undefined;
+        metadata?: JsonRecord | undefined;
+    }): Promise<{
+        subscription: StacklinkWorkspaceSubscription;
+        usage: StacklinkUsageSummary;
+    }>;
+}
+export declare class StacklinkConnectedAccountsClient {
+    private readonly client;
+    constructor(client: Stacklink);
+    list(tenantId: string): Promise<{
+        connections: ConnectedAccount[];
+    }>;
+    create(input: Record<string, unknown>): Promise<{
+        account: ConnectedAccount;
+    }>;
+    get(accountId: string): Promise<{
+        account: ConnectedAccount;
+    }>;
+    listTools(accountId: string, input?: {
+        includePlanned?: boolean | undefined;
+        toolKeys?: string[] | undefined;
+    }): Promise<{
+        contract: string;
+        sessionId: string;
+        tools: ProviderTool[];
+        meta?: unknown;
+    }>;
+    listResources(accountId: string): Promise<ConnectedAccountResourcesResponse>;
+    refreshResources(accountId: string): Promise<ConnectedAccountResourcesResponse>;
+    resolveResource(accountId: string, input: ConnectedAccountResourceResolveInput): Promise<{
+        accountId: string;
+        providerKey: string;
+        resource: ConnectedAccountResource;
+    }>;
+    update(accountId: string, patch: Record<string, unknown>): Promise<{
+        account: ConnectedAccount;
+    }>;
+    enable(accountId: string): Promise<{
+        account: ConnectedAccount;
+    }>;
+    disable(accountId: string): Promise<{
+        account: ConnectedAccount;
+    }>;
+    refresh(accountId: string): Promise<{
+        account: ConnectedAccount;
+    }>;
+    validate(accountId: string): Promise<unknown>;
+    delete(accountId: string): Promise<{
+        account: ConnectedAccount;
+    }>;
+}
+export declare class StacklinkAuthConfigsClient {
+    private readonly client;
+    constructor(client: Stacklink);
+    list(query?: {
+        providerKey?: string;
+        includeDisabled?: boolean;
+    }): Promise<{
+        authConfigs: AuthConfig[];
+    }>;
+    create(input: Record<string, unknown>): Promise<{
+        authConfig: AuthConfig;
+    }>;
+    get(authConfigId: string): Promise<{
+        authConfig: AuthConfig;
+    }>;
+    update(authConfigId: string, patch: Record<string, unknown>): Promise<{
+        authConfig: AuthConfig;
+    }>;
+    enable(authConfigId: string): Promise<{
+        authConfig: AuthConfig;
+    }>;
+    disable(authConfigId: string): Promise<{
+        authConfig: AuthConfig;
+    }>;
+    delete(authConfigId: string): Promise<{
+        authConfig: AuthConfig;
+    }>;
+}
+export declare class StacklinkToolkitsClient {
+    private readonly client;
+    constructor(client: Stacklink);
+    list(): Promise<{
+        providers: ProviderToolkit[];
+    }>;
+    listProject(query?: {
+        tenantId?: string;
+    }): Promise<{
+        providers: ProjectProvider[];
+    }>;
+    listTools(providerKey: string): Promise<{
+        providerKey: string;
+        tools: ProviderTool[];
+        meta?: {
+            responseMode?: "compact" | "full" | undefined;
+            provider?: ProviderToolkit | undefined;
+        } | undefined;
+    }>;
+}
+export declare class StacklinkProviderToolsClient {
+    private readonly client;
+    constructor(client: Stacklink);
+    search(input: Record<string, unknown>): Promise<{
+        tools: ProviderTool[];
+        queries?: unknown[];
+        meta?: unknown;
+    }>;
+    schemas(input: {
+        sessionId: string;
+        toolKeys: string[];
+        includePlanned?: boolean | undefined;
+    }): Promise<{
+        tools: ProviderTool[];
+    }>;
+    runtimeContracts(input: {
+        sessionId: string;
+        toolkitKeys?: string[] | undefined;
+        toolKeys?: string[] | undefined;
+        includePlanned?: boolean | undefined;
+    }): Promise<{
+        contract: string;
+        sessionId: string;
+        tools: ProviderTool[];
+        meta?: unknown;
+    }>;
+    execute(input: Record<string, unknown>): Promise<Record<string, unknown>>;
+    executeBatch(input: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+export declare class StacklinkSessionMemoryClient {
+    private readonly memoryClient;
+    private readonly sessionId;
+    constructor(memoryClient: StacklinkMemoryClient, sessionId: string);
+    add(input: {
+        subjects?: MemorySubjectRef[] | undefined;
+        kind?: 'fact' | 'episode' | 'profile_item' | 'block' | undefined;
+        content: string;
+        title?: string | undefined;
+        memoryType?: 'preference' | 'decision' | 'commitment' | 'goal' | 'constraint' | 'relationship' | 'durable_fact' | undefined;
+        sensitivityClass?: 'standard' | 'personal' | 'restricted' | undefined;
+        restrictedDataClasses?: Array<'health' | 'biometric' | 'government_identity' | 'precise_location' | 'protected_trait' | 'minor' | 'detailed_personal_financial'> | undefined;
+        topicTags?: string[] | undefined;
+        language?: string | undefined;
+        source?: MemoryIngestInput['source'] | undefined;
+        idempotencyKey?: string | undefined;
+        policyKey?: string | undefined;
+        consent?: MemoryIngestInput['consent'] | undefined;
+        metadata?: JsonRecord | undefined;
+        occurredAt?: string | undefined;
+        validFrom?: string | undefined;
+        validTo?: string | undefined;
+    }): Promise<JsonRecord>;
+    ingest(input: Omit<MemoryIngestInput, 'tenantId' | 'externalTenantId' | 'sessionId'>): Promise<JsonRecord>;
+    ingestRich(input: Omit<MemoryRichIngestInput, 'tenantId' | 'externalTenantId' | 'sessionId'>): Promise<JsonRecord>;
+    getRichIngest(jobId: string): Promise<JsonRecord>;
+    recordConversationTurn(input: Omit<MemoryConversationTurnInput, 'sessionId'>): Promise<JsonRecord>;
+    search(input: Omit<MemorySearchInput, 'tenantId' | 'externalTenantId' | 'sessionId'>): Promise<JsonRecord>;
+    context(input: Omit<MemoryContextInput, 'tenantId' | 'externalTenantId' | 'sessionId'>): Promise<JsonRecord>;
+    recall(input: Omit<MemoryContextInput, 'tenantId' | 'externalTenantId' | 'sessionId'>): Promise<JsonRecord>;
+    profile(): Promise<JsonRecord>;
+    get(memoryId: string): Promise<JsonRecord>;
+    history(memoryId: string): Promise<JsonRecord>;
+    update(memoryId: string, patch: Parameters<StacklinkMemoryClient['update']>[1]['patch']): Promise<JsonRecord>;
+    forget(memoryId: string, reason?: string): Promise<JsonRecord>;
+    restore(memoryId: string, reason?: string): Promise<JsonRecord>;
+}
+export declare class StacklinkWorkbenchRun {
+    private readonly client;
+    private readonly platformSessionId;
+    readonly response: WorkbenchExecutionResponse;
+    readonly executionId: string;
+    readonly executionKind: 'workbench_code' | 'workbench_bash';
+    constructor(client: Stacklink, platformSessionId: string, response: WorkbenchExecutionResponse);
+    events(input?: {
+        pollIntervalMs?: number | undefined;
+        limit?: number | undefined;
+    }): AsyncGenerator<unknown, void, unknown>;
+    wait(input?: {
+        waitTimeoutMs?: number | undefined;
+        pollIntervalMs?: number | undefined;
+    }): Promise<Record<string, unknown>>;
+    cancel(reason?: string): Promise<Record<string, unknown>>;
+}
+export declare class StacklinkWorkbenchFiles {
+    private readonly client;
+    private readonly platformSessionId;
+    private readonly workbenchSessionId;
+    constructor(client: Stacklink, platformSessionId: string, workbenchSessionId: () => Promise<string>);
+    list(): Promise<{
+        workbenchSession: WorkbenchSession;
+        files: WorkbenchFile[];
+    }>;
+    read(path: string): Promise<{
+        workbenchSession: WorkbenchSession;
+        file: WorkbenchFile;
+    }>;
+    upload(input: {
+        path: string;
+        content: string | Uint8Array;
+        contentType?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }): Promise<{
+        workbenchSession: WorkbenchSession;
+        file: WorkbenchFile;
+    }>;
+    uploadLarge(input: {
+        path: string;
+        content: string | Uint8Array;
+        contentType?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }): Promise<{
+        file: WorkbenchFile;
+    }>;
+    download(path: string): Promise<Response>;
+    delete(path: string): Promise<{
+        workbenchSession: WorkbenchSession;
+        file: WorkbenchFile;
+        deleted: true;
+    }>;
+}
+export declare class StacklinkWorkbenchRuns {
+    private readonly client;
+    private readonly platformSessionId;
+    private readonly workbenchSessionId;
+    constructor(client: Stacklink, platformSessionId: string, workbenchSessionId: () => Promise<string>);
+    list(seriesId?: string, cursor?: string, limit?: number): Promise<{
+        runDefinitions: WorkbenchRunDefinition[];
+        limit: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    }>;
+    get(runDefinitionId: string): Promise<{
+        runDefinition: WorkbenchRunDefinition;
+    }>;
+    update(runDefinitionId: string, input: {
+        name?: string | undefined;
+        description?: string | null | undefined;
+        versionReason?: string | null | undefined;
+    }): Promise<{
+        runDefinition: WorkbenchRunDefinition;
+    }>;
+    save(input: {
+        executionId: string;
+        seriesId?: string | undefined;
+        name: string;
+        description?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }): Promise<{
+        runDefinition: WorkbenchRunDefinition;
+    }>;
+    replay(runDefinitionId: string, input: {
+        background?: boolean | undefined;
+        timeoutMs?: number | undefined;
+        environmentMode?: WorkbenchReplayEnvironmentMode | undefined;
+        idempotencyKey: string;
+    }): Promise<WorkbenchRunReplayResponse>;
+    publish(runDefinitionId: string, expectedPublishedVersion: number | null): Promise<{
+        runDefinition: WorkbenchRunDefinition;
+    }>;
+    rollback(runDefinitionId: string, expectedPublishedVersion: number | null): Promise<{
+        runDefinition: WorkbenchRunDefinition;
+    }>;
+}
+export declare class StacklinkWorkbenchArtifacts {
+    private readonly client;
+    private readonly platformSessionId;
+    private readonly workbenchSessionId;
+    constructor(client: Stacklink, platformSessionId: string, workbenchSessionId: () => Promise<string>);
+    list(): Promise<{
+        artifacts: WorkbenchArtifact[];
+    }>;
+    promote(input: {
+        path: string;
+        label?: string | undefined;
+        contentType?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }): Promise<{
+        workbenchSession: WorkbenchSession;
+        artifact: WorkbenchArtifact;
+    }>;
+    downloadUrl(artifactId: string): Promise<unknown>;
+    download(artifactId: string): Promise<Response>;
+    delete(artifactId: string, path?: string): Promise<{
+        workbenchSession: WorkbenchSession;
+        artifact: WorkbenchArtifact;
+        deleted: boolean;
+    }>;
+}
+export declare class StacklinkSessionSandbox {
+    private readonly client;
+    private readonly platformSessionId;
+    readonly files: StacklinkWorkbenchFiles;
+    readonly runs: StacklinkWorkbenchRuns;
+    readonly artifacts: StacklinkWorkbenchArtifacts;
+    private activeWorkbenchSessionId;
+    constructor(client: Stacklink, platformSessionId: string);
+    use(workbenchSessionId?: string, input?: {
+        createNew?: boolean | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }): Promise<{
+        workbenchSession: WorkbenchSession;
+        reused: boolean;
+    }>;
+    run(input: WorkbenchRunCodeInput, options?: StacklinkRequestOptions): Promise<StacklinkWorkbenchRun>;
+    bash(input: WorkbenchRunBashInput, options?: StacklinkRequestOptions): Promise<StacklinkWorkbenchRun>;
+    destroy(): Promise<Record<string, unknown>>;
+    delete(): Promise<WorkbenchSessionDeleteReceipt>;
+    private ensureWorkbenchSession;
+}
+export declare class ToolRouterSession {
+    private readonly client;
+    readonly id: string;
+    readonly tenantId: string;
+    readonly mcp?: StacklinkSessionMcpDescriptor | undefined;
+    readonly memory: StacklinkSessionMemoryClient;
+    readonly sandbox: StacklinkSessionSandbox;
+    private contractVersion;
+    private toolDefinitions;
+    constructor(client: Stacklink, id: string, tenantId: string, mcp?: StacklinkSessionMcpDescriptor | undefined, contractVersion?: string, toolDefinitions?: StacklinkSessionMetaToolDefinition[]);
+    get(): Promise<{
+        session: StacklinkSessionData;
+    }>;
+    mcpRequest(input: Record<string, unknown> | Array<Record<string, unknown>>, options?: StacklinkRequestOptions): Promise<unknown>;
+    mcpRequestStream(input: Record<string, unknown>, options?: StacklinkMcpStreamOptions): Promise<unknown>;
+    callMcpTool(name: StacklinkToolSurfaceName, args: Record<string, unknown>): Promise<unknown>;
+    mcpConnection(): StacklinkSessionMcpConnection;
+    update(patch: UpdateStacklinkSessionInput): Promise<{
+        session: StacklinkSessionData;
+    }>;
+    toolContractVersion(): string;
+    toolRegistry(): StacklinkSessionMetaToolDefinition[];
+    close(): Promise<{
+        session: StacklinkSessionData;
+    }>;
+    routerFacts(query?: {
+        kind?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        entries: unknown[];
+        nextCursor?: string | null;
+        kinds?: {
+            kind: string;
+            count: number;
+        }[];
+    }>;
+    connectionEvents(): Promise<{
+        events: unknown[];
+    }>;
+    trace(query?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<{
+        sessionId: string;
+        selectedConnectedAccountIds: string[];
+        entries: unknown[];
+        nextCursor: string | null;
+    }>;
+    configHistory(query?: {
+        beforeVersion?: number;
+        limit?: number;
+    }): Promise<{
+        sessionId: string;
+        currentVersion: number | null;
+        versions: {
+            version: number;
+            config: Record<string, unknown>;
+            changeMetadata: Record<string, unknown>;
+            createdAt: string;
+        }[];
+        nextBeforeVersion: number | null;
+    }>;
+    workbenchActivity(): Promise<{
+        workbenchSessions: WorkbenchSession[];
+        artifacts: WorkbenchArtifact[];
+        usage: unknown[];
+        cost: unknown[];
+    }>;
+    toolkits(): Promise<ProjectProvider[]>;
+    authorize(providerKey: string, input?: {
+        callbackUrl?: string;
+        authConfigId?: string;
+        authMode?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StacklinkConnectionRequest>;
+    waitForConnections(connectionRequestIds: string[], timeoutMs?: number, intervalMs?: number): Promise<{
+        status: "completed";
+        connectionRequests: ConnectionRequestResponse[];
+    }>;
+    connectedAccounts(): Promise<ConnectedAccount[]>;
+    getConnectedAccount(accountId: string): Promise<ConnectedAccount>;
+    updateConnectedAccount(accountId: string, patch: Record<string, unknown>): Promise<ConnectedAccount>;
+    enableConnectedAccount(accountId: string): Promise<ConnectedAccount>;
+    disableConnectedAccount(accountId: string): Promise<ConnectedAccount>;
+    refreshConnectedAccount(accountId: string): Promise<ConnectedAccount>;
+    validateConnectedAccount(accountId: string): Promise<unknown>;
+    deleteConnectedAccount(accountId: string): Promise<ConnectedAccount>;
+    connectedAccountSecrets(accountId: string): Promise<unknown[]>;
+    connectedAccountResources(accountId: string): Promise<ConnectedAccountResourcesResponse>;
+    refreshConnectedAccountResources(accountId: string): Promise<ConnectedAccountResourcesResponse>;
+    searchTools(input?: Omit<Record<string, unknown>, 'sessionId'> & StacklinkDiscoveryCacheControl): Promise<{
+        tools: ProviderTool[];
+        queries?: unknown[];
+        meta?: unknown;
+    }>;
+    getToolSchemas(toolKeys: string[], input?: {
+        includePlanned?: boolean | undefined;
+    } & StacklinkDiscoveryCacheControl): Promise<{
+        tools: ProviderTool[];
+    }>;
+    prepareRuntimeTools(input?: {
+        toolkitKeys?: string[] | undefined;
+        toolKeys?: string[] | undefined;
+        includePlanned?: boolean | undefined;
+    }): Promise<{
+        contract: string;
+        sessionId: string;
+        tools: ProviderTool[];
+        meta?: unknown;
+    }>;
+    prepareTools(input: StacklinkPrepareToolsInput): Promise<StacklinkPreparedTools>;
+    searchKnowledge(input?: Omit<KnowledgeSearchInput, 'sessionId'>): Promise<KnowledgeSearchResponse>;
+    getKnowledgeCapabilities(input?: {
+        packKey?: string | undefined;
+    }): Promise<KnowledgeCapabilityResponse>;
+    lookupKnowledgeCitation(input?: Omit<KnowledgeCitationLookupInput, 'sessionId'>): Promise<KnowledgeCitationLookupResponse>;
+    getKnowledgeAmendmentTrail(input?: Omit<KnowledgeAmendmentTrailInput, 'sessionId'>): Promise<KnowledgeAmendmentTrailResult>;
+    verifyKnowledgeEvidence(input?: Omit<KnowledgeEvidenceVerifyInput, 'sessionId'>): Promise<KnowledgeEvidenceVerifyResult>;
+    verifyKnowledgeAnswer(input: Omit<KnowledgeAnswerVerifyInput, 'sessionId'>): Promise<KnowledgeAnswerVerifyResult>;
+    getGstComplianceRule(input?: Omit<GstComplianceRuleQueryInput, 'sessionId'>): Promise<GstRuleQueryResponse>;
+    getGstDueDateRule(input: Omit<GstFormRuleInput, 'sessionId'>): Promise<GstSingleRuleResponse>;
+    calculateGstDueDate(input: Omit<GstDueDateCalculationInput, 'sessionId'>): Promise<GstCalculationResponse>;
+    getGstLateFeeRule(input: Omit<GstLateFeeRuleInput, 'sessionId'>): Promise<GstSingleRuleResponse>;
+    calculateGstLateFee(input: Omit<GstLateFeeCalculationInput, 'sessionId'>): Promise<GstCalculationResponse>;
+    getGstInterestRule(input?: Omit<GstInterestRuleInput, 'sessionId'>): Promise<GstSingleRuleResponse>;
+    calculateGstInterest(input: Omit<GstInterestCalculationInput, 'sessionId'>): Promise<GstCalculationResponse>;
+    lookupGstHsnSacRate(input: Omit<GstRateLookupInput, 'sessionId'>): Promise<GstRateLookupResponse>;
+    checkGstRcm(input: Omit<GstRcmCheckInput, 'sessionId'>): Promise<GstRcmCheckResponse>;
+    getGstNoticeRule(input: Omit<GstNoticeRuleInput, 'sessionId'>): Promise<GstNoticeRuleResponse>;
+    getGstAppealStageRule(input: Omit<GstAppealStageRuleInput, 'sessionId'>): Promise<GstAppealStageRuleResponse>;
+    executeTool(input: Omit<Record<string, unknown>, 'sessionId'>, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    executeToolsBatch(input: Omit<Record<string, unknown>, 'sessionId'>, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    runWorkbench(input: Omit<Record<string, unknown>, 'sessionId'>, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    destroyWorkbenchSession(input: {
+        workbenchSessionId: string;
+    }, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    deleteWorkbenchSession(input: {
+        workbenchSessionId: string;
+    }): Promise<WorkbenchSessionDeleteReceipt>;
+    runWorkbenchBash(input: Omit<Record<string, unknown>, 'sessionId'>, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    listExecutions(input?: {
+        executionKind?: StacklinkExecutionKind | undefined;
+        workbenchSessionId?: string | undefined;
+        status?: string | undefined;
+        cursor?: string | undefined;
+        limit?: number | undefined;
+    }, options?: StacklinkRequestOptions): Promise<{
+        executions: unknown[];
+        limit: number;
+        nextCursor: string | null;
+        liveCount: number;
+    }>;
+    getExecution(input: {
+        executionKind: StacklinkExecutionKind;
+        executionId: string;
+        includeEvents?: boolean | undefined;
+        eventLimit?: number | undefined;
+    }, options?: StacklinkRequestOptions): Promise<{
+        execution: unknown;
+        events?: unknown[] | undefined;
+        limit?: number | undefined;
+        hasMore?: boolean | undefined;
+        nextCursor?: string | null | undefined;
+    }>;
+    readExecutionEvents(input: {
+        executionKind: StacklinkExecutionKind;
+        executionId: string;
+        afterSequence?: string | number | bigint | undefined;
+        limit?: number | undefined;
+    }, options?: StacklinkRequestOptions): Promise<{
+        events: unknown[];
+        limit: number;
+        hasMore: boolean;
+        nextCursor: string | null;
+    }>;
+    waitForExecution(input: {
+        executionKind: StacklinkExecutionKind;
+        executionId: string;
+        waitTimeoutMs?: number | undefined;
+        pollIntervalMs?: number | undefined;
+    }, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    cancelExecution(input: {
+        executionKind: StacklinkExecutionKind;
+        executionId: string;
+        reason?: string | undefined;
+    }, options?: StacklinkRequestOptions): Promise<Record<string, unknown>>;
+    streamEvents(input?: {
+        after?: string;
+        eventTypes?: string[];
+        limit?: number;
+        pollIntervalMs?: number;
+    }): Promise<Response>;
+    tools(): StacklinkTools;
+}
+export { ToolRouterSession as StacklinkSession };
+export declare class StacklinkConnectionRequest {
+    private readonly client;
+    readonly id: string;
+    readonly providerKey: string;
+    readonly status: string;
+    readonly phase: ConnectionRequestPhase | undefined;
+    readonly nextAction: ConnectionRequestNextAction | undefined;
+    readonly redirectUrl: string;
+    readonly expiresAt: string;
+    readonly authModes: string[];
+    readonly authRequirements: AuthRequirement[];
+    constructor(client: Stacklink, input: ConnectionAuthorizationResponse);
+    getStatus(): Promise<ConnectionRequestResponse>;
+    toJSON(): {
+        id: string;
+        providerKey: string;
+        status: string;
+        phase: ConnectionRequestPhase | undefined;
+        nextAction: ConnectionRequestNextAction | undefined;
+        redirectUrl: string;
+        expiresAt: string;
+        authModes: string[];
+        authRequirements: AuthRequirement[];
+    };
+    waitForConnection(timeoutMs?: number, intervalMs?: number): Promise<ConnectedAccount | undefined>;
+}
+//# sourceMappingURL=index.d.ts.map