@slates/provider 1.0.0-rc.2 → 1.0.0-rc.20

package/dist/index.d.cts

@@ -0,0 +1,1019 @@
+import z, { z as z$1 } from 'zod';
+import { AxiosResponse, AxiosError, CreateAxiosDefaults, AxiosInstance } from 'axios';
+import { ServiceError, ErrorRecord, ErrorData } from '@lowerdeck/error';
+
+interface SlateAttachmentUrlContent {
+    type: 'url';
+    url: string;
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+    refreshReference?: unknown;
+    refreshAt?: string;
+}
+interface SlateAttachmentInlineContent {
+    type: 'content';
+    encoding: 'base64' | 'utf-8';
+    content: string;
+}
+interface SlateAttachmentUploadReferenceContent {
+    type: 'upload_reference';
+    referenceId: string;
+}
+interface SlateAttachment {
+    mimeType?: string;
+    attachmentHash?: string;
+    content: SlateAttachmentUrlContent | SlateAttachmentInlineContent | SlateAttachmentUploadReferenceContent;
+}
+declare let createUrlAttachment: (url: string, opts?: {
+    mimeType?: string;
+    attachmentHash?: string;
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+    refreshReference?: unknown;
+    refreshAt?: string;
+}) => SlateAttachment;
+declare let createBase64Attachment: (content: string, mimeType?: string, attachmentHash?: string) => SlateAttachment;
+declare let createTextAttachment: (content: string, mimeType?: string, attachmentHash?: string) => SlateAttachment;
+
+/**
+ * Placeholder prefix used to mark a redacted auth-config secret. Must match the hub's
+ * AuthConfigSecretSerializer (oss/src/slates/apps/hub/src/lib/secretSerializer.ts) exactly --
+ * the hub resolves these placeholders back to live secret values when it proxies an attachment.
+ */
+declare let AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX: string;
+/**
+ * Walks an auth config object and replaces any string value that exactly matches one of its
+ * leaf values with a `$$MT$secret$authConfig$<path>` placeholder. Literal, whole-value
+ * substitution only -- not a substring scan, and not a heuristic key-name/value-shape guess
+ * like the http trace redactor in '../axios/trace'.
+ */
+declare class AuthConfigSecretRedactor {
+    private readonly secretToPlaceholder;
+    constructor(authConfig: Record<string, unknown> | undefined);
+    redact<T>(value: T): T;
+    private buildSecretMap;
+    private transform;
+    private isPlainObject;
+}
+/**
+ * Applied to every finalized attachment list right before it's sent over
+ * `slates/action.tool.invoke` (see @slates/provider-handler). Only `type: 'url'` attachments
+ * carry headers/query -- content/upload_reference attachments pass through untouched.
+ */
+declare let redactUrlAttachmentSecrets: (attachments: SlateAttachment[] | undefined, authConfig: Record<string, unknown> | undefined) => SlateAttachment[] | undefined;
+
+interface SlateHttpTraceTextBody {
+    contentType?: string;
+    text: string;
+    truncated?: boolean;
+}
+interface SlateHttpTrace {
+    startedAt: string;
+    durationMs: number;
+    request: {
+        method: string;
+        url: string;
+        headers?: Record<string, string>;
+        body?: SlateHttpTraceTextBody;
+    };
+    response?: {
+        status: number;
+        statusText?: string;
+        headers?: Record<string, string>;
+        body?: SlateHttpTraceTextBody;
+    };
+    error?: {
+        code?: string;
+        message: string;
+    };
+}
+
+interface SlateLiveInvocationInfo {
+    token: string;
+    baseUrl: string;
+    maxAttachmentSizeBytes: number;
+}
+interface SlateDirectUploadInput {
+    live: SlateLiveInvocationInfo;
+    mimeType?: string;
+    filename?: string;
+    body: ReadableStream<Uint8Array> | Uint8Array;
+}
+declare let uploadAttachmentDirect: (d: SlateDirectUploadInput) => Promise<SlateAttachment>;
+
+type SlateLogType = 'info' | 'warn' | 'error' | 'progress';
+type SlateLogFields = Record<string, unknown>;
+type SlateLogMessageInput = string | Error | boolean | number | null | undefined | object | SlateLogMessageInput[];
+interface SlateLogEntry {
+    type: SlateLogType;
+    message: string;
+    timestamp: Date;
+    data?: SlateLogFields;
+}
+type SlateLogListener = (entries: SlateLogEntry[]) => void;
+declare class SlateLogger {
+    #private;
+    constructor(listeners?: SlateLogListener[]);
+    private flush;
+    private scheduleFlush;
+    log(type: SlateLogType, message: SlateLogMessageInput): void;
+    info(...message: SlateLogMessageInput[]): void;
+    warn(...message: SlateLogMessageInput[]): void;
+    error(...message: SlateLogMessageInput[]): void;
+    progress(...message: SlateLogMessageInput[]): void;
+}
+
+interface SlateDocsReference {
+    name: string;
+    url: string;
+}
+interface SlateTypedDocsReference<Type extends string> extends SlateDocsReference {
+    type?: Type;
+}
+type SlateProviderDocsReference = SlateDocsReference;
+type SlateConfigDocsReference = SlateTypedDocsReference<'docs.config.general'>;
+type SlateActionDocsReference = SlateTypedDocsReference<'docs.action.general'>;
+type SlateAuthDocsReference = SlateTypedDocsReference<'docs.auth.oauth' | 'docs.auth.oauth_scopes' | 'docs.auth.token' | 'docs.auth.service_account' | 'docs.auth.custom'>;
+
+type SlateAuthCallbackConfig = Record<string, any>;
+type SlateAuthWithOauth<InputType extends {}, OutputType extends {
+    token: string;
+    refreshToken?: string;
+    expiresAt?: number | string | Date;
+}> = {
+    type: 'auth.oauth';
+    name: string;
+    key: string;
+    scopes: {
+        title: string;
+        description?: string;
+        scope: string;
+    }[];
+    docs?: SlateAuthDocsReference[];
+    inputSchema?: z.ZodType<InputType>;
+    onInputChanged?: (params: {
+        previousInput: InputType | null;
+        newInput: InputType;
+    }) => Promise<{
+        input?: InputType;
+    } | undefined>;
+    getDefaultInput?: () => Promise<InputType>;
+    getAuthorizationUrl: (ctx: {
+        redirectUri: string;
+        state: string;
+        input: InputType;
+        clientId: string;
+        clientSecret: string;
+        scopes: string[];
+        config?: SlateAuthCallbackConfig;
+    }) => Promise<{
+        url: string;
+        input?: InputType;
+        callbackState?: Record<string, any>;
+    }>;
+    handleCallback: (ctx: {
+        code: string;
+        state: string;
+        redirectUri: string;
+        input: InputType;
+        clientId: string;
+        clientSecret: string;
+        scopes: string[];
+        callbackParams?: Record<string, string>;
+        callbackState: Record<string, any>;
+        config?: SlateAuthCallbackConfig;
+    }) => Promise<{
+        output: OutputType;
+        input?: InputType;
+        scopes?: string[];
+    }>;
+    handleTokenRefresh?: (ctx: {
+        output: OutputType;
+        input: InputType;
+        clientId: string;
+        clientSecret: string;
+        scopes: string[];
+        config?: SlateAuthCallbackConfig;
+    }) => Promise<{
+        output: OutputType;
+        input?: InputType;
+    }>;
+    getProfile?: (ctx: {
+        output: OutputType;
+        input: InputType;
+        scopes: string[];
+        config?: SlateAuthCallbackConfig;
+    }) => Promise<{
+        profile: Record<string, any>;
+    }>;
+};
+type SlateAuthWithToken<InputType extends {}, OutputType extends {
+    token?: string;
+}> = {
+    type: 'auth.token';
+    name: string;
+    key: string;
+    inputSchema?: z.ZodType<InputType>;
+    docs?: SlateAuthDocsReference[];
+    getOutput: (ctx: {
+        input: InputType;
+        config?: SlateAuthCallbackConfig;
+    }) => Promise<{
+        output: OutputType;
+        scopes?: string[];
+    }>;
+    onInputChanged?: (params: {
+        previousInput: InputType;
+        newInput: InputType;
+    }) => Promise<{
+        input?: InputType;
+    } | undefined>;
+    getDefaultInput?: () => Promise<InputType>;
+    getProfile?: (ctx: {
+        output: OutputType;
+        input: InputType;
+        scopes: string[];
+        config?: SlateAuthCallbackConfig;
+    }) => Promise<{
+        profile: Record<string, any>;
+    }>;
+};
+type SlateAuthWithServiceAccount<InputType extends {}, OutputType extends {}> = {
+    type: 'auth.service_account';
+    name: string;
+    key: string;
+    inputSchema?: z.ZodType<InputType>;
+    docs?: SlateAuthDocsReference[];
+    getOutput: (ctx: {
+        input: InputType;
+        config?: SlateAuthCallbackConfig;
+    }) => Promise<{
+        output: OutputType;
+        scopes?: string[];
+    }>;
+    onInputChanged?: (params: {
+        previousInput: InputType;
+        newInput: InputType;
+    }) => Promise<{
+        input?: InputType;
+    } | undefined>;
+    getDefaultInput?: () => Promise<InputType>;
+    getProfile?: (ctx: {
+        output: OutputType;
+        input: InputType;
+        scopes: string[];
+        config?: SlateAuthCallbackConfig;
+    }) => Promise<{
+        profile: Record<string, any>;
+    }>;
+};
+type SlateAuthWithCustomData<InputType extends {}, OutputType extends {}> = {
+    type: 'auth.custom';
+    name: string;
+    key: string;
+    inputSchema?: z.ZodType<InputType>;
+    docs?: SlateAuthDocsReference[];
+    getOutput: (ctx: {
+        input: InputType;
+        config?: SlateAuthCallbackConfig;
+    }) => Promise<{
+        output: OutputType;
+        scopes?: string[];
+    }>;
+    handleTokenRefresh?: (ctx: {
+        output: OutputType;
+        input: InputType;
+        clientId: string;
+        clientSecret: string;
+        scopes: string[];
+        config?: SlateAuthCallbackConfig;
+    }) => Promise<{
+        output: OutputType;
+        input?: InputType;
+    }>;
+    onInputChanged?: (params: {
+        previousInput: InputType;
+        newInput: InputType;
+    }) => Promise<{
+        input?: InputType;
+    } | undefined>;
+    getDefaultInput?: () => Promise<InputType>;
+    getProfile?: (ctx: {
+        output: OutputType;
+        input: InputType;
+        scopes: string[];
+        config?: SlateAuthCallbackConfig;
+    }) => Promise<{
+        profile: Record<string, any>;
+    }>;
+};
+type SlateAuthWithNone<_InputType extends {}, _OutputType extends {}> = {
+    type: 'auth.none';
+    name: string;
+    key: string;
+};
+type SlateAuthType<InputType extends {}, OutputType extends {}> = SlateAuthWithOauth<InputType, OutputType & {
+    token: string;
+}> | SlateAuthWithToken<InputType, OutputType & {
+    token?: string;
+}> | SlateAuthWithServiceAccount<InputType, OutputType> | SlateAuthWithCustomData<InputType, OutputType> | SlateAuthWithNone<InputType, OutputType>;
+
+declare class SlateAuth<OutputType extends {} = {}> {
+    #private;
+    private constructor();
+    static create<OutputType extends {}>(): SlateAuth<OutputType>;
+    output<NewOutputType extends {}>(schema: z.ZodType<NewOutputType>): SlateAuth<NewOutputType>;
+    private addAuth;
+    addOauth<InputType extends {}>(auth: SlateAuthType<InputType, OutputType> & {
+        type: 'auth.oauth';
+    }): SlateAuth<OutputType>;
+    addTokenAuth<InputType extends {}>(auth: SlateAuthType<InputType, OutputType> & {
+        type: 'auth.token';
+    }): SlateAuth<OutputType>;
+    addServiceAccountAuth<InputType extends {}>(auth: SlateAuthType<InputType, OutputType> & {
+        type: 'auth.service_account';
+    }): SlateAuth<OutputType>;
+    addCustomAuth<InputType extends {}>(auth: SlateAuthType<InputType, OutputType> & {
+        type: 'auth.custom';
+    }): SlateAuth<OutputType>;
+    addNone(): SlateAuth<OutputType>;
+    get authStack(): (SlateAuthWithOauth<any, OutputType & {
+        token: string;
+    }> | SlateAuthWithToken<any, OutputType & {
+        token?: string;
+    }> | SlateAuthWithServiceAccount<any, OutputType> | SlateAuthWithCustomData<any, OutputType>)[];
+    get outputSchema(): z.ZodType<OutputType, unknown, z.core.$ZodTypeInternals<OutputType, unknown>>;
+}
+declare let auth: <OutputType extends {} = {}>() => SlateAuth<OutputType>;
+
+type OAuthTokenResponse = {
+    access_token?: unknown;
+    refresh_token?: unknown;
+    expires_in?: unknown;
+    [key: string]: unknown;
+};
+type OAuthRefreshTokenFallbackMode = 'nullish' | 'falsy';
+type OAuthExpiresAtOptions = {
+    nowMs?: number;
+    providerLabel?: string;
+    operation?: string;
+    required?: boolean;
+    expiresInType?: 'number' | 'numberLike';
+    message?: string;
+};
+type NormalizeOAuthTokenResponseOptions = OAuthExpiresAtOptions & {
+    previousRefreshToken?: string;
+    refreshTokenFallbackMode?: OAuthRefreshTokenFallbackMode;
+    accessTokenMessage?: string;
+    expiresInMessage?: string;
+};
+declare let getOAuthExpiresAtFromExpiresIn: (expiresIn: unknown, options?: OAuthExpiresAtOptions) => string | undefined;
+declare let normalizeOAuthTokenResponse: (data: unknown, options?: NormalizeOAuthTokenResponseOptions) => {
+    token: string;
+    refreshToken: string | undefined;
+    expiresAt: string | undefined;
+};
+
+declare class SlateConfig<ConfigType extends {}> {
+    #private;
+    private constructor();
+    static create<ConfigType extends {}>(schema: z.ZodType<ConfigType>): SlateConfig<ConfigType>;
+    config<NewConfigType extends {}>(schema: z.ZodType<NewConfigType>): SlateConfig<NewConfigType>;
+    docs(docs: SlateConfigDocsReference[]): SlateConfig<ConfigType>;
+    onConfigChanged(handler: (params: {
+        previousConfig: ConfigType | null;
+        newConfig: ConfigType;
+    }) => {
+        config: ConfigType | undefined;
+    } | undefined): SlateConfig<ConfigType>;
+    getDefaultConfig(getter: () => ConfigType): SlateConfig<ConfigType>;
+    get configSchema(): z.ZodType<ConfigType, unknown, z.core.$ZodTypeInternals<ConfigType, unknown>>;
+    get docsReferences(): SlateConfigDocsReference[] | undefined;
+    get handlers(): {
+        configChanged: ((params: {
+            previousConfig: ConfigType | null;
+            newConfig: ConfigType;
+        }) => {
+            config: ConfigType | undefined;
+        } | undefined) | null;
+        getDefaultConfig: (() => ConfigType) | null;
+    };
+}
+declare let config: <ConfigType extends {}>(schema: z.ZodType<ConfigType>) => SlateConfig<ConfigType>;
+
+interface SlateSpecificationParameters {
+    key: string;
+    name: string;
+    description?: string;
+    docs?: SlateProviderDocsReference[];
+    metadata?: Record<string, any>;
+}
+interface SlateSpecificationCreateParameters<ConfigType extends {}, AuthType extends {}> extends SlateSpecificationParameters {
+    config: SlateConfig<ConfigType>;
+    auth: SlateAuth<AuthType>;
+}
+declare class SlateSpecification<ConfigType extends {}, AuthType extends {}> {
+    private readonly _config;
+    private readonly _auth;
+    private readonly _params;
+    private constructor();
+    static create<ConfigType extends {}, AuthType extends {}>(params: SlateSpecificationCreateParameters<ConfigType, AuthType>): SlateSpecification<ConfigType, AuthType>;
+    get configSchema(): z.ZodType<ConfigType, unknown, z.core.$ZodTypeInternals<ConfigType, unknown>>;
+    get authSchema(): z.ZodType<AuthType>;
+    get config(): SlateConfig<ConfigType>;
+    get auth(): SlateAuth<AuthType>;
+    get parameters(): SlateSpecificationParameters;
+    get key(): string;
+    get name(): string;
+    get description(): string | undefined;
+    get docs(): SlateDocsReference[] | undefined;
+}
+declare let spec: <ConfigType extends {}, AuthType extends {}>(params: SlateSpecificationCreateParameters<ConfigType, AuthType>) => SlateSpecification<ConfigType, AuthType>;
+
+type SlateAddAttachmentContent = Buffer | Uint8Array | ArrayBuffer | ReadableStream<Uint8Array> | NodeJS.ReadableStream | Response;
+type SlateAddAttachmentInput = {
+    type: 'url';
+    url: string | URL;
+    mimeType?: string;
+    filename?: string;
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+    refreshReference?: unknown;
+    refreshAt?: string;
+} | {
+    type: 'content';
+    content: SlateAddAttachmentContent;
+    mimeType?: string;
+    filename?: string;
+};
+declare class SlatePublicContext<InputType extends {}> {
+    #private;
+    private readonly spec;
+    private readonly logger;
+    constructor(input: InputType, spec: SlateSpecification<any, any>, logger: SlateLogger, liveInvocation?: SlateLiveInvocationInfo | null);
+    get specification(): SlateSpecification<any, any>;
+    get input(): Readonly<InputType>;
+    get event(): Readonly<InputType>;
+    get state(): "state" extends keyof InputType ? InputType["state"] : never;
+    get request(): "request" extends keyof InputType ? InputType["request"] : never;
+    get registrationDetails(): "registrationDetails" extends keyof InputType ? InputType["registrationDetails"] : never;
+    recordHttpTrace(trace: SlateHttpTrace): void;
+    getHttpTraces(): {
+        error?: {
+            code?: string;
+            message: string;
+        };
+        response?: {
+            status: number;
+            statusText?: string;
+            headers?: Record<string, string>;
+            body?: SlateHttpTraceTextBody;
+        };
+        request: {
+            body?: SlateHttpTraceTextBody;
+            headers?: Record<string, string>;
+            method: string;
+            url: string;
+        };
+        startedAt: string;
+        durationMs: number;
+    }[];
+    info(message: SlateLogMessageInput): void;
+    warn(message: SlateLogMessageInput): void;
+    error(message: SlateLogMessageInput): void;
+    progress(message: SlateLogMessageInput): void;
+    addAttachment(input: SlateAddAttachmentInput): Promise<void>;
+    _finalizeAttachments(): Promise<SlateAttachment[]>;
+    _getAuthConfigForRedaction(): Record<string, unknown> | undefined;
+}
+declare class SlateContext<ConfigType extends {}, AuthType extends {}, InputType extends {}> extends SlatePublicContext<InputType> {
+    #private;
+    constructor(config: ConfigType, input: InputType, auth: AuthType, spec: SlateSpecification<ConfigType, AuthType>, logger: SlateLogger, liveInvocation?: SlateLiveInvocationInfo | null);
+    get config(): Readonly<ConfigType>;
+    get auth(): Readonly<AuthType>;
+    _getAuthConfigForRedaction(): Record<string, unknown> | undefined;
+}
+
+declare let runWithContext: <InputType extends {}, RV>(context: SlatePublicContext<InputType>, fn: () => Promise<RV>) => Promise<RV>;
+declare let getCurrentContext: <ConfigType extends {}, AuthType extends {}, InputType extends {}>() => SlateContext<ConfigType, AuthType, InputType>;
+
+type SlateActionType = 'tool' | 'trigger';
+interface SlateActionScopeClause {
+    OR: string[];
+}
+interface SlateActionScopes {
+    AND: SlateActionScopeClause[];
+}
+interface SlateActionParameters {
+    key: string;
+    name: string;
+    description?: string;
+    instructions?: string[];
+    constraints?: string[];
+    tags?: {
+        destructive?: boolean;
+        readOnly?: boolean;
+        [key: string]: boolean | undefined;
+    };
+    metadata?: Record<string, any>;
+    scopes?: SlateActionScopes;
+    authMethods?: string[];
+    docs?: SlateActionDocsReference[];
+    adapter?: string | null;
+    isPublic?: boolean;
+}
+type SlateToolInvocationHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = (context: SlateContext<ConfigType, AuthType, InputType>) => Promise<{
+    output: OutputType;
+    message: string;
+    attachments?: SlateAttachment[];
+}>;
+type SlatePublicToolInvocationHandler<InputType extends {}, OutputType extends {}> = (context: SlatePublicContext<InputType>) => Promise<{
+    output: OutputType;
+    message: string;
+    attachments?: SlateAttachment[];
+}>;
+type SlateTriggerMappingHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = (context: SlateContext<ConfigType, AuthType, InputType>) => Promise<{
+    type: string;
+    id: string;
+    output: OutputType;
+}>;
+type SlateTriggerPollingHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}> = (context: SlateContext<ConfigType, AuthType, {
+    state: any | null;
+}>) => Promise<{
+    inputs: InputType[];
+    updatedState?: any;
+}>;
+interface SlateWebhookHttpResponseInit {
+    status?: number;
+    headers?: Record<string, string>;
+    body?: string | Uint8Array | null;
+}
+type SlateWebhookHttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+interface SlateWebhookRequestMatcher {
+    method?: string;
+    hasQueryParam?: string;
+    hasHeader?: string;
+    jsonBodyField?: {
+        path: string;
+        equals?: string;
+    };
+    formBodyField?: {
+        path: string;
+        equals?: string;
+    };
+}
+interface SlateWebhookHttpOptions {
+    methods?: SlateWebhookHttpMethod[];
+    sync?: {
+        mode: 'never' | 'match' | 'always';
+        match?: SlateWebhookRequestMatcher[];
+        timeoutMs?: number;
+    };
+}
+type SlateTriggerWebhookRequestHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}> = (context: SlateContext<ConfigType, AuthType, {
+    request: Request;
+    state: any | null;
+    registrationDetails: any | null;
+}>) => Promise<{
+    inputs: InputType[];
+    updatedState?: any;
+    response?: Response | SlateWebhookHttpResponseInit;
+}>;
+type SlateTriggerWebhookAutoRegistrationHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
+    webhookBaseUrl: string;
+}>) => Promise<{
+    registrationDetails: any;
+    state?: any;
+}>;
+type SlateTriggerWebhookAutoUnregistrationHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
+    webhookBaseUrl: string;
+    registrationDetails: any;
+    state: any | null;
+}>) => Promise<unknown>;
+interface SlateActionParametersTool<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> {
+    type: 'tool';
+    handleInvocation: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>;
+}
+interface SlatePollingOptions {
+    intervalInSeconds?: number;
+}
+interface SlateActionParametersTrigger<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> {
+    type: 'trigger';
+    source: 'polling' | 'webhook';
+    polling?: SlatePollingOptions;
+    handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+    handleRequest?: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
+    http?: SlateWebhookHttpOptions;
+    pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
+    autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
+    autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
+}
+type SlateActionParametersAny<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = SlateActionParametersTool<ConfigType, AuthType, InputType, OutputType> | SlateActionParametersTrigger<ConfigType, AuthType, InputType, OutputType>;
+type SlateActionCreateParameters<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = SlateActionParametersAny<ConfigType, AuthType, InputType, OutputType> & SlateActionParameters & {
+    configSchema: z$1.ZodType<ConfigType>;
+    authSchema: z$1.ZodType<AuthType>;
+    inputSchema: z$1.ZodType<InputType>;
+    outputSchema: z$1.ZodType<OutputType>;
+};
+declare abstract class SlateAction<Type extends SlateActionType, ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> {
+    readonly type: Type;
+    protected readonly _spec: SlateSpecification<ConfigType, AuthType>;
+    protected readonly _inputSchema: z$1.ZodType<InputType>;
+    protected readonly _outputSchema: z$1.ZodType<OutputType>;
+    protected readonly _params: SlateActionParameters;
+    constructor(type: Type, _spec: SlateSpecification<ConfigType, AuthType>, _inputSchema: z$1.ZodType<InputType>, _outputSchema: z$1.ZodType<OutputType>, _params: SlateActionParameters);
+    get configSchema(): z$1.ZodType<ConfigType, unknown, z$1.core.$ZodTypeInternals<ConfigType, unknown>>;
+    get inputSchema(): z$1.ZodType<InputType, unknown, z$1.core.$ZodTypeInternals<InputType, unknown>>;
+    get outputSchema(): z$1.ZodType<OutputType, unknown, z$1.core.$ZodTypeInternals<OutputType, unknown>>;
+    get parameters(): SlateActionParameters;
+    get key(): string;
+    get name(): string;
+    get description(): string | undefined;
+    get tags(): {
+        [key: string]: boolean | undefined;
+        destructive?: boolean;
+        readOnly?: boolean;
+    } | undefined;
+    get instructions(): string[] | undefined;
+    get constraints(): string[] | undefined;
+    get metadata(): Record<string, any> | undefined;
+    get scopes(): SlateActionScopes | undefined;
+    get authMethods(): string[] | undefined;
+    get docs(): SlateActionDocsReference[] | undefined;
+    get adapter(): string | null;
+    get isPublic(): boolean;
+}
+
+declare class SlateActionBuilder<Type extends SlateActionType, ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}, Result extends SlateAction<Type, ConfigType, AuthType, any, any>, IsPublic extends boolean = false> {
+    #private;
+    private readonly type;
+    readonly spec: SlateSpecification<ConfigType, AuthType>;
+    private readonly params;
+    private readonly factory;
+    private readonly isPublicTool;
+    constructor(type: Type, spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters, factory: (params: SlateActionCreateParameters<any, any, any, any>) => Result, isPublicTool?: IsPublic);
+    input<NewInputType extends {}>(schema: z.ZodType<NewInputType>): SlateActionBuilder<Type, ConfigType, AuthType, NewInputType, OutputType, Result, IsPublic>;
+    output<NewOutputType extends {}>(schema: z.ZodType<NewOutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, NewOutputType, Result, IsPublic>;
+    lockInterface(): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic>;
+    scopes(scopes: SlateActionScopes): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic>;
+    authMethods(authMethods: string[]): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic>;
+    private validateAuthMethods;
+    handleInvocation(handler: IsPublic extends true ? SlatePublicToolInvocationHandler<InputType, OutputType> : SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic>;
+    webhook(props: {
+        handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+        handleRequest: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
+        autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
+        autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
+        http?: SlateWebhookHttpOptions;
+    }): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic>;
+    polling(props: {
+        options?: SlatePollingOptions;
+        pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
+        handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+    }): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic>;
+    build(): Result;
+}
+
+interface SlateToolParameters<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> extends SlateActionParameters {
+    handleInvocation: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>;
+}
+declare class SlateTool<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> extends SlateAction<'tool', ConfigType, AuthType, InputType, OutputType> {
+    #private;
+    protected constructor(spec: SlateSpecification<ConfigType, AuthType>, inputSchema: z.ZodType<InputType>, outputSchema: z.ZodType<OutputType>, params: SlateToolParameters<ConfigType, AuthType, InputType, OutputType>);
+    static create<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters): SlateActionBuilder<"tool", ConfigType, AuthType, {}, {}, SlateTool<ConfigType, AuthType, any, any>, false>;
+    static fromCreateParameters<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: {
+        type: string;
+        inputSchema: z.ZodType<any>;
+        outputSchema: z.ZodType<any>;
+        handleInvocation?: SlateToolInvocationHandler<ConfigType, AuthType, any, any>;
+    } & SlateActionParameters): SlateTool<ConfigType, AuthType, any, any>;
+    get handleInvocation(): SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>;
+}
+declare let tool: <ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters) => SlateActionBuilder<"tool", ConfigType, AuthType, {}, {}, SlateTool<ConfigType, AuthType, any, any>, false>;
+
+declare let GET_FILE_URL_TOOL_ID: string;
+declare let getFileUrlToolInputSchema: z$1.ZodObject<{
+    url: z$1.ZodString;
+    reference: z$1.ZodNullable<z$1.ZodAny>;
+}, z$1.core.$strip>;
+type GetFileUrlToolInput = z$1.infer<typeof getFileUrlToolInputSchema>;
+declare let getFileUrlToolOutputSchema: z$1.ZodObject<{
+    url: z$1.ZodString;
+    expiresAt: z$1.ZodString;
+    headers: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+    query: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+}, z$1.core.$strip>;
+type GetFileUrlToolOutput = z$1.infer<typeof getFileUrlToolOutputSchema>;
+type GetFileUrlHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, GetFileUrlToolInput>) => Promise<GetFileUrlToolOutput>;
+declare let getFileUrlTool: <ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, handleGetFileUrl: GetFileUrlHandler<ConfigType, AuthType>) => SlateTool<ConfigType, AuthType, any, any>;
+
+interface SlatePublicToolParameters<InputType extends {}, OutputType extends {}> extends SlateActionParameters {
+    handleInvocation: SlatePublicToolInvocationHandler<InputType, OutputType>;
+}
+declare class SlatePublicTool {
+    private constructor();
+    static create<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters): SlateActionBuilder<"tool", ConfigType, AuthType, {}, {}, SlateTool<ConfigType, AuthType, any, any>, true>;
+}
+declare let publicTool: <ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters) => SlateActionBuilder<"tool", ConfigType, AuthType, {}, {}, SlateTool<ConfigType, AuthType, any, any>, true>;
+
+type SlateActionScopeValue = string;
+type SlateActionScopeClauseInput = SlateActionScopeValue | readonly SlateActionScopeValue[] | SlateActionScopeClause;
+type SlateActionScopesInput = SlateActionScopeClauseInput | SlateActionScopes;
+declare let scopeClause: (...scopes: SlateActionScopeValue[]) => SlateActionScopeClause;
+declare let anyOf: (...scopes: SlateActionScopeValue[]) => SlateActionScopes;
+declare let allOf: (...inputs: SlateActionScopesInput[]) => SlateActionScopes;
+declare let mergeScopes: (...inputs: Array<SlateActionScopes | null | undefined | false>) => SlateActionScopes | undefined;
+declare let validateScopes: (scopes: SlateActionScopes) => SlateActionScopes;
+
+declare let SlateDefaultPollingIntervalSeconds: number;
+interface SlateTriggerParameters<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {
+    type: string;
+}> extends SlateActionParameters {
+    type: 'trigger';
+    source: 'polling' | 'webhook';
+    polling?: SlatePollingOptions;
+    handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+    handleRequest?: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
+    http?: SlateWebhookHttpOptions;
+    pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
+    autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
+    autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
+}
+declare class SlateTrigger<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {
+    type: string;
+}> extends SlateAction<'trigger', ConfigType, AuthType, InputType, OutputType> {
+    #private;
+    private constructor();
+    static create<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters): SlateActionBuilder<"trigger", ConfigType, AuthType, {}, {}, SlateTrigger<ConfigType, AuthType, any, any>, false>;
+    get polling(): SlatePollingOptions;
+    get source(): "polling" | "webhook";
+    get handleEvent(): SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+    get handleRequest(): SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType> | undefined;
+    get http(): SlateWebhookHttpOptions | undefined;
+    get pollEvents(): SlateTriggerPollingHandler<ConfigType, AuthType, InputType> | undefined;
+    get autoRegisterWebhook(): SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType> | undefined;
+    get autoUnregisterWebhook(): SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType> | undefined;
+}
+declare let trigger: <ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters) => SlateActionBuilder<"trigger", ConfigType, AuthType, {}, {}, SlateTrigger<ConfigType, AuthType, any, any>, false>;
+
+interface SlateAdapterCapability {
+    id: string;
+    value: any;
+}
+interface SlateAdapterSpecParameters {
+    id: string;
+    name: string;
+    capabilities?: SlateAdapterCapability[];
+}
+declare class SlateAdapterSpec {
+    private readonly _params;
+    private constructor();
+    static create(params: SlateAdapterSpecParameters): SlateAdapterSpec;
+    get id(): string;
+    get name(): string;
+    get capabilities(): SlateAdapterCapability[];
+    get parameters(): {
+        id: string;
+        name: string;
+        capabilities: SlateAdapterCapability[];
+    };
+    tool<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters): SlateActionBuilder<"tool", ConfigType, AuthType, {}, {}, SlateTool<ConfigType, AuthType, any, any>, false>;
+    publicTool<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters): SlateActionBuilder<"tool", ConfigType, AuthType, {}, {}, SlateTool<ConfigType, AuthType, any, any>, true>;
+    trigger<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters): SlateActionBuilder<"trigger", ConfigType, AuthType, {}, {}, SlateTrigger<ConfigType, AuthType, any, any>, false>;
+    register<ConfigType extends {}, AuthType extends {}>(params: {
+        tools: SlateTool<ConfigType, AuthType, any, any>[];
+        triggers: SlateTrigger<ConfigType, AuthType, any, any>[];
+    }): SlateAdapter<ConfigType, AuthType>;
+    private linkAction;
+}
+declare let adapterSpec: (params: SlateAdapterSpecParameters) => SlateAdapterSpec;
+
+declare class SlateAdapter<ConfigType extends {}, AuthType extends {}> {
+    private readonly _spec;
+    private readonly _tools;
+    private readonly _triggers;
+    constructor(_spec: SlateAdapterSpec, _tools: SlateTool<ConfigType, AuthType, any, any>[], _triggers: SlateTrigger<ConfigType, AuthType, any, any>[]);
+    get spec(): SlateAdapterSpec;
+    get id(): string;
+    get name(): string;
+    get capabilities(): SlateAdapterCapability[];
+    get tools(): SlateTool<ConfigType, AuthType, any, any>[];
+    get triggers(): SlateTrigger<ConfigType, AuthType, any, any>[];
+    get actions(): (SlateTrigger<ConfigType, AuthType, any, any> | SlateTool<ConfigType, AuthType, any, any>)[];
+}
+
+type ApiErrorStatus = number | string;
+type ApiServiceError = ServiceError<ErrorRecord<any, any>>;
+type ApiErrorResponse = {
+    status?: ApiErrorStatus;
+    statusText?: string;
+    data?: unknown;
+};
+type ApiErrorDetailOptions = {
+    detailKeys?: readonly string[];
+    nestedKeys?: readonly string[];
+    includeNumbers?: boolean;
+    separator?: string;
+    fallbackMessage?: string;
+};
+type ApiErrorBuildHelpers = {
+    collectDetails: (value: unknown, details: string[], options?: ApiErrorDetailOptions) => void;
+    extractMessage: (error: unknown, options?: ApiErrorDetailOptions) => string;
+    getResponse: (error: unknown) => ApiErrorResponse | undefined;
+    getStatus: (error: unknown) => ApiErrorStatus | undefined;
+    isRecord: (value: unknown) => value is Record<string, unknown>;
+    statusLabelFor: (status?: ApiErrorStatus, statusText?: string) => string;
+};
+type BuildApiServiceErrorOptions = ApiErrorDetailOptions & {
+    providerLabel: string;
+    reason: string;
+    operation?: string;
+    extractMessage?: (error: unknown, helpers: ApiErrorBuildHelpers) => string | undefined;
+    extractResponse?: (error: unknown, helpers: ApiErrorBuildHelpers) => ApiErrorResponse | undefined;
+    extractStatus?: (error: unknown, response: ApiErrorResponse | undefined, helpers: ApiErrorBuildHelpers) => ApiErrorStatus | undefined;
+    extractUpstreamCode?: (error: unknown, response: ApiErrorResponse | undefined, helpers: ApiErrorBuildHelpers) => string | undefined;
+    formatMessage?: (parts: {
+        providerLabel: string;
+        operation: string;
+        statusLabel: string;
+        message: string;
+        response?: ApiErrorResponse;
+        status?: ApiErrorStatus;
+    }) => string;
+    parent?: unknown;
+};
+declare let isApiErrorRecord: (value: unknown) => value is Record<string, unknown>;
+declare let collectApiErrorDetails: (value: unknown, details: string[], options?: ApiErrorDetailOptions) => void;
+declare let getApiErrorResponse: (error: unknown) => ApiErrorResponse | undefined;
+declare let getApiErrorStatus: (error: unknown) => ApiErrorStatus | undefined;
+declare let statusLabelForApiError: (status?: ApiErrorStatus, statusText?: string) => string;
+declare let extractApiErrorMessage: (error: unknown, options?: ApiErrorDetailOptions & {
+    response?: ApiErrorResponse;
+}) => string;
+declare let createApiServiceError: (message: string, options?: {
+    reason?: string;
+    upstreamStatus?: ApiErrorStatus;
+    upstreamCode?: string;
+    parent?: unknown;
+}) => ServiceError<ErrorRecord<"bad_request", 400>>;
+declare let buildApiServiceError: (error: unknown, options: BuildApiServiceErrorOptions) => ServiceError<ErrorRecord<"bad_request", 400>>;
+
+declare class SlateError extends Error {
+    cause?: unknown;
+    data: SlateErrorResponse;
+    constructor(input: SlateErrorInput);
+    get code(): string;
+    get kind(): SlateErrorKind;
+    get status(): number | undefined;
+    get retryable(): boolean | undefined;
+    toResponse(): SlateErrorResponse;
+    toJSON(): SlateErrorResponse;
+    static is(error: unknown): error is SlateError;
+    static fromUnknown(error: unknown, defaults?: Partial<SlateErrorResponse>): SlateError;
+    static fromServiceError(error: unknown, defaults?: Partial<SlateErrorInput>): SlateError;
+    static fromAxios(error: unknown, options?: SlateAxiosErrorOptions): SlateError;
+}
+declare let createSlateError: (input: SlateErrorInput) => SlateError;
+
+type SlateErrorKind = 'declaration' | 'validation' | 'request' | 'auth' | 'config' | 'resource' | 'payment' | 'upstream' | 'transport' | 'internal';
+interface SlateErrorIssue {
+    path?: string[];
+    code?: string;
+    message: string;
+    [key: string]: unknown;
+}
+interface SlateErrorProviderInfo {
+    key?: string;
+    service?: string;
+    operation?: string;
+}
+interface SlateErrorUpstreamInfo {
+    status?: number;
+    code?: string;
+    type?: string;
+    requestId?: string;
+    method?: string;
+    url?: string;
+}
+interface SlateErrorResponse {
+    code: string;
+    message: string;
+    kind: SlateErrorKind;
+    retryable?: boolean;
+    status?: number;
+    issues?: SlateErrorIssue[];
+    provider?: SlateErrorProviderInfo;
+    upstream?: SlateErrorUpstreamInfo;
+    baggage?: Record<string, unknown>;
+    requestTraces?: SlateHttpTrace[];
+}
+interface SlateErrorInput extends Omit<SlateErrorResponse, 'kind'> {
+    kind?: SlateErrorKind;
+    cause?: unknown;
+}
+interface SlateAxiosErrorOptions {
+    defaults?: Partial<SlateErrorResponse>;
+    extractResponseData?: (response: AxiosResponse) => unknown;
+    mapAxiosError?: (error: AxiosError, inferred: SlateErrorResponse) => SlateError | Partial<SlateErrorResponse> | undefined;
+}
+interface SlateServiceErrorData {
+    status: number;
+    code: string;
+    message: string;
+    hint?: string;
+    description?: string;
+    reason?: string;
+    errors?: unknown;
+    [key: string]: unknown;
+}
+
+declare let isAxiosErrorLike: (error: unknown) => error is AxiosError;
+declare let inferSlateErrorFromAxios: (error: AxiosError, options?: SlateAxiosErrorOptions) => SlateErrorResponse;
+
+declare class SlateDeclarationError extends SlateError {
+    constructor(message: string, input?: Partial<SlateError['data']>);
+    static is(error: unknown): error is SlateDeclarationError;
+}
+
+declare let mapServiceErrorCode: (code: string, status?: number) => string;
+declare let isServiceErrorData: (value: unknown) => value is SlateServiceErrorData;
+declare let getServiceErrorData: (error: unknown) => SlateServiceErrorData | null;
+declare let mapServiceErrorToSlateErrorInput: (error: ServiceError<ErrorRecord<any, any>> | ErrorRecord<any, any> | ErrorData<any, any> | SlateServiceErrorData, defaults?: Partial<SlateErrorInput>) => SlateErrorInput;
+
+interface SlateAxiosDefaults extends CreateAxiosDefaults {
+    errorMapping?: SlateAxiosErrorOptions;
+}
+type SlateAxiosErrorAdapter = (error: unknown, operation: string) => unknown;
+interface SlateAuthenticatedAxiosDefaults extends SlateAxiosDefaults {
+    authHeader?: {
+        name?: string;
+        value: string;
+    };
+    contentType?: string | false;
+    errorAdapter?: (error: unknown) => unknown;
+}
+declare let createAxios: (config?: SlateAxiosDefaults) => AxiosInstance;
+declare let createAuthenticatedAxios: (config: SlateAuthenticatedAxiosDefaults) => AxiosInstance;
+declare let requestAxios: <T = unknown>(operation: string, request: () => Promise<AxiosResponse<T>>, errorAdapter: SlateAxiosErrorAdapter) => Promise<AxiosResponse<T, any, {}>>;
+declare let requestAxiosData: <T = unknown>(operation: string, request: () => Promise<AxiosResponse<T>>, errorAdapter: SlateAxiosErrorAdapter) => Promise<T>;
+declare let axios: AxiosInstance;
+
+interface CreateHmacSignatureOptions {
+    secret: string | Uint8Array;
+    payload: string | Uint8Array;
+    algorithm?: string;
+    digest: 'hex' | 'base64';
+    prefix?: string;
+}
+interface VerifyHmacSignatureOptions extends CreateHmacSignatureOptions {
+    signature: string;
+}
+declare let createHmacSignature: ({ secret, payload, algorithm, digest, prefix }: CreateHmacSignatureOptions) => string;
+declare let verifyHmacSignature: (options: VerifyHmacSignatureOptions) => boolean;
+
+declare let getResponseHeaderValue: (headers: unknown, name: string) => string | undefined;
+declare let getBase64ByteLength: (contentBase64: string) => number;
+
+declare let pickDefined: <T extends object>(value: T) => Partial<T> & Record<string, unknown>;
+declare let setIfDefined: (target: Record<string, unknown>, key: string, value: unknown) => Record<string, unknown>;
+
+declare class Slate<ConfigType extends {}, AuthType extends {}> {
+    private readonly _spec;
+    private readonly _actions;
+    private readonly _adapters;
+    private constructor();
+    static create<ConfigType extends {}, AuthType extends {}>(params: {
+        spec: SlateSpecification<ConfigType, AuthType>;
+        triggers: SlateTrigger<ConfigType, AuthType, any, any>[];
+        tools: SlateTool<ConfigType, AuthType, any, any>[];
+        adapters?: SlateAdapter<ConfigType, AuthType>[];
+    }): Slate<ConfigType, AuthType>;
+    get spec(): SlateSpecification<ConfigType, AuthType>;
+    get actions(): (SlateTrigger<ConfigType, AuthType, any, any> | SlateTool<ConfigType, AuthType, any, any>)[];
+    get adapters(): SlateAdapter<ConfigType, AuthType>[];
+}
+
+declare const graphWebhookHttp: {
+    methods: "POST"[];
+    sync: {
+        mode: "match";
+        match: {
+            hasQueryParam: string;
+        }[];
+    };
+};
+declare let getGraphWebhookValidationResponse: (request: Request) => SlateWebhookHttpResponseInit | null;
+
+declare const metaWebhookHttp: {
+    methods: ("POST" | "GET")[];
+    sync: {
+        mode: "match";
+        match: {
+            method: string;
+            hasQueryParam: string;
+        }[];
+    };
+};
+declare let getMetaWebhookVerificationResponse: (request: Request, expectedVerifyToken: string | undefined) => SlateWebhookHttpResponseInit | null;
+
+export { AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX, type ApiErrorBuildHelpers, type ApiErrorDetailOptions, type ApiErrorResponse, type ApiErrorStatus, type ApiServiceError, AuthConfigSecretRedactor, type BuildApiServiceErrorOptions, type CreateHmacSignatureOptions, GET_FILE_URL_TOOL_ID, type GetFileUrlHandler, type GetFileUrlToolInput, type GetFileUrlToolOutput, type NormalizeOAuthTokenResponseOptions, type OAuthExpiresAtOptions, type OAuthRefreshTokenFallbackMode, type OAuthTokenResponse, Slate, SlateAction, SlateActionBuilder, type SlateActionCreateParameters, type SlateActionDocsReference, type SlateActionParameters, type SlateActionParametersAny, type SlateActionParametersTool, type SlateActionParametersTrigger, type SlateActionScopeClause, type SlateActionScopeClauseInput, type SlateActionScopeValue, type SlateActionScopes, type SlateActionScopesInput, type SlateActionType, SlateAdapter, type SlateAdapterCapability, SlateAdapterSpec, type SlateAdapterSpecParameters, type SlateAddAttachmentContent, type SlateAddAttachmentInput, type SlateAttachment, type SlateAttachmentInlineContent, type SlateAttachmentUploadReferenceContent, type SlateAttachmentUrlContent, SlateAuth, type SlateAuthDocsReference, type SlateAuthType, type SlateAuthWithCustomData, type SlateAuthWithNone, type SlateAuthWithOauth, type SlateAuthWithServiceAccount, type SlateAuthWithToken, type SlateAuthenticatedAxiosDefaults, type SlateAxiosDefaults, type SlateAxiosErrorAdapter, type SlateAxiosErrorOptions, SlateConfig, type SlateConfigDocsReference, SlateContext, SlateDeclarationError, SlateDefaultPollingIntervalSeconds, type SlateDirectUploadInput, type SlateDocsReference, SlateError, type SlateErrorInput, type SlateErrorIssue, type SlateErrorKind, type SlateErrorProviderInfo, type SlateErrorResponse, type SlateErrorUpstreamInfo, type SlateLiveInvocationInfo, type SlateLogEntry, type SlateLogFields, type SlateLogListener, type SlateLogMessageInput, type SlateLogType, SlateLogger, type SlatePollingOptions, type SlateProviderDocsReference, SlatePublicContext, SlatePublicTool, type SlatePublicToolInvocationHandler, type SlatePublicToolParameters, type SlateServiceErrorData, SlateSpecification, type SlateSpecificationCreateParameters, type SlateSpecificationParameters, SlateTool, type SlateToolInvocationHandler, type SlateToolParameters, SlateTrigger, type SlateTriggerMappingHandler, type SlateTriggerParameters, type SlateTriggerPollingHandler, type SlateTriggerWebhookAutoRegistrationHandler, type SlateTriggerWebhookAutoUnregistrationHandler, type SlateTriggerWebhookRequestHandler, type SlateTypedDocsReference, type SlateWebhookHttpMethod, type SlateWebhookHttpOptions, type SlateWebhookHttpResponseInit, type SlateWebhookRequestMatcher, type VerifyHmacSignatureOptions, adapterSpec, allOf, anyOf, auth, axios, buildApiServiceError, collectApiErrorDetails, config, createApiServiceError, createAuthenticatedAxios, createAxios, createBase64Attachment, createHmacSignature, createSlateError, createTextAttachment, createUrlAttachment, extractApiErrorMessage, getApiErrorResponse, getApiErrorStatus, getBase64ByteLength, getCurrentContext, getFileUrlTool, getFileUrlToolInputSchema, getFileUrlToolOutputSchema, getGraphWebhookValidationResponse, getMetaWebhookVerificationResponse, getOAuthExpiresAtFromExpiresIn, getResponseHeaderValue, getServiceErrorData, graphWebhookHttp, inferSlateErrorFromAxios, isApiErrorRecord, isAxiosErrorLike, isServiceErrorData, mapServiceErrorCode, mapServiceErrorToSlateErrorInput, mergeScopes, metaWebhookHttp, normalizeOAuthTokenResponse, pickDefined, publicTool, redactUrlAttachmentSecrets, requestAxios, requestAxiosData, runWithContext, scopeClause, setIfDefined, spec, statusLabelForApiError, tool, trigger, uploadAttachmentDirect, validateScopes, verifyHmacSignature };