@slates/provider 1.0.0-rc.7 → 1.0.0-rc.9

package/dist/index.d.ts

@@ -1,9 +1,620 @@
-export * from './action';
-export * from './auth';
-export * from './axios';
-export * from './config';
-export * from './context';
-export * from './error';
-export * from './logger';
-export * from './specification';
-//# sourceMappingURL=index.d.ts.map
+import z, { z as z$1 } from 'zod';
+import { AxiosResponse, AxiosError, CreateAxiosDefaults, AxiosInstance } from 'axios';
+import { ServiceError, ErrorRecord, ErrorData } from '@lowerdeck/error';
+
+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;
+    };
+}
+
+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;
+}
+
+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;
+    }[];
+    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[];
+    }) => 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[];
+        callbackState: Record<string, any>;
+    }) => Promise<{
+        output: OutputType;
+        input?: InputType;
+        scopes?: string[];
+    }>;
+    handleTokenRefresh?: (ctx: {
+        output: OutputType;
+        input: InputType;
+        clientId: string;
+        clientSecret: string;
+        scopes: string[];
+    }) => Promise<{
+        output: OutputType;
+        input?: InputType;
+    }>;
+    getProfile?: (ctx: {
+        output: OutputType;
+        input: InputType;
+        scopes: string[];
+    }) => Promise<{
+        profile: Record<string, any>;
+    }>;
+};
+type SlateAuthWithToken<InputType extends {}, OutputType extends {
+    token?: string;
+}> = {
+    type: 'auth.token';
+    name: string;
+    key: string;
+    inputSchema?: z.ZodType<InputType>;
+    getOutput: (ctx: {
+        input: InputType;
+    }) => Promise<{
+        output: OutputType;
+    }>;
+    onInputChanged?: (params: {
+        previousInput: InputType;
+        newInput: InputType;
+    }) => Promise<{
+        input?: InputType;
+    } | undefined>;
+    getDefaultInput?: () => Promise<InputType>;
+    getProfile?: (ctx: {
+        output: OutputType;
+        input: InputType;
+    }) => Promise<{
+        profile: Record<string, any>;
+    }>;
+};
+type SlateAuthWithServiceAccount<InputType extends {}, OutputType extends {}> = {
+    type: 'auth.service_account';
+    name: string;
+    key: string;
+    inputSchema?: z.ZodType<InputType>;
+    getOutput: (ctx: {
+        input: InputType;
+    }) => Promise<{
+        output: OutputType;
+    }>;
+    onInputChanged?: (params: {
+        previousInput: InputType;
+        newInput: InputType;
+    }) => Promise<{
+        input?: InputType;
+    } | undefined>;
+    getDefaultInput?: () => Promise<InputType>;
+    getProfile?: (ctx: {
+        output: OutputType;
+        input: InputType;
+    }) => Promise<{
+        profile: Record<string, any>;
+    }>;
+};
+type SlateAuthWithCustomData<InputType extends {}, OutputType extends {}> = {
+    type: 'auth.custom';
+    name: string;
+    key: string;
+    inputSchema?: z.ZodType<InputType>;
+    getOutput: (ctx: {
+        input: InputType;
+    }) => Promise<{
+        output: OutputType;
+    }>;
+    onInputChanged?: (params: {
+        previousInput: InputType;
+        newInput: InputType;
+    }) => Promise<{
+        input?: InputType;
+    } | undefined>;
+    getDefaultInput?: () => Promise<InputType>;
+    getProfile?: (ctx: {
+        output: OutputType;
+        input: InputType;
+    }) => 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>;
+
+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>;
+    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 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;
+    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;
+}
+declare let spec: <ConfigType extends {}, AuthType extends {}>(params: SlateSpecificationCreateParameters<ConfigType, AuthType>) => SlateSpecification<ConfigType, AuthType>;
+
+declare class SlateContext<ConfigType extends {}, AuthType extends {}, InputType extends {}> {
+    #private;
+    private readonly spec;
+    private readonly logger;
+    constructor(config: ConfigType, input: InputType, auth: AuthType, spec: SlateSpecification<ConfigType, AuthType>, logger: SlateLogger);
+    get specification(): SlateSpecification<ConfigType, AuthType>;
+    get config(): Readonly<ConfigType>;
+    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 auth(): Readonly<AuthType>;
+    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;
+}
+
+declare let runWithContext: <ConfigType extends {}, AuthType extends {}, InputType extends {}, RV>(context: SlateContext<ConfigType, AuthType, InputType>, fn: () => Promise<RV>) => Promise<RV>;
+declare let getCurrentContext: <ConfigType extends {}, AuthType extends {}, InputType extends {}>() => SlateContext<ConfigType, AuthType, InputType>;
+
+interface SlateAttachmentUrlContent {
+    type: 'url';
+    url: string;
+}
+interface SlateAttachmentInlineContent {
+    type: 'content';
+    encoding: 'base64' | 'utf-8';
+    content: string;
+}
+interface SlateAttachment {
+    mimeType?: string;
+    content: SlateAttachmentUrlContent | SlateAttachmentInlineContent;
+}
+declare let createUrlAttachment: (url: string, mimeType?: string) => SlateAttachment;
+declare let createBase64Attachment: (content: string, mimeType?: string) => SlateAttachment;
+declare let createTextAttachment: (content: string, mimeType?: string) => SlateAttachment;
+
+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;
+}
+type SlateToolInvocationHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = (context: SlateContext<ConfigType, AuthType, 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;
+}>;
+type SlateTriggerWebhookRequestHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}> = (context: SlateContext<ConfigType, AuthType, {
+    request: Request;
+    state: any | null;
+}>) => Promise<{
+    inputs: InputType[];
+    updatedState?: any;
+}>;
+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>;
+    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;
+}
+
+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 class SlateActionBuilder<Type extends SlateActionType, ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}, Result extends SlateAction<Type, ConfigType, AuthType, any, any>> {
+    #private;
+    private readonly type;
+    readonly spec: SlateSpecification<ConfigType, AuthType>;
+    private readonly params;
+    private readonly factory;
+    constructor(type: Type, spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters, factory: (params: SlateActionCreateParameters<any, any, any, any>) => Result);
+    input<NewInputType extends {}>(schema: z.ZodType<NewInputType>): SlateActionBuilder<Type, ConfigType, AuthType, NewInputType, OutputType, Result>;
+    output<NewOutputType extends {}>(schema: z.ZodType<NewOutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, NewOutputType, Result>;
+    scopes(scopes: SlateActionScopes): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
+    handleInvocation(handler: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
+    webhook(props: {
+        handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+        handleRequest: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
+        autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
+        autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
+    }): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
+    polling(props: {
+        options?: SlatePollingOptions;
+        pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
+        handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+    }): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
+    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;
+    private constructor();
+    static create<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters): SlateActionBuilder<"tool", ConfigType, AuthType, {}, {}, SlateTool<any, any, 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<any, any, any, any>>;
+
+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>;
+    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<any, any, any, any>>;
+    get polling(): SlatePollingOptions;
+    get source(): "polling" | "webhook";
+    get handleEvent(): SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+    get handleRequest(): SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType> | 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<any, any, any, any>>;
+
+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>;
+}
+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> | void;
+}
+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;
+}
+declare let createAxios: (config?: SlateAxiosDefaults) => AxiosInstance;
+declare let axios: AxiosInstance;
+
+declare class Slate<ConfigType extends {}, AuthType extends {}> {
+    private readonly _spec;
+    private readonly _actions;
+    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>[];
+    }): Slate<ConfigType, AuthType>;
+    get spec(): SlateSpecification<ConfigType, AuthType>;
+    get actions(): (SlateTrigger<ConfigType, AuthType, any, any> | SlateTool<ConfigType, AuthType, any, any>)[];
+}
+
+export { Slate, SlateAction, SlateActionBuilder, type SlateActionCreateParameters, type SlateActionParameters, type SlateActionParametersAny, type SlateActionParametersTool, type SlateActionParametersTrigger, type SlateActionScopeClause, type SlateActionScopeClauseInput, type SlateActionScopeValue, type SlateActionScopes, type SlateActionScopesInput, type SlateActionType, type SlateAttachment, type SlateAttachmentInlineContent, type SlateAttachmentUrlContent, SlateAuth, type SlateAuthType, type SlateAuthWithCustomData, type SlateAuthWithNone, type SlateAuthWithOauth, type SlateAuthWithServiceAccount, type SlateAuthWithToken, type SlateAxiosDefaults, type SlateAxiosErrorOptions, SlateConfig, SlateContext, SlateDeclarationError, SlateDefaultPollingIntervalSeconds, SlateError, type SlateErrorInput, type SlateErrorIssue, type SlateErrorKind, type SlateErrorProviderInfo, type SlateErrorResponse, type SlateErrorUpstreamInfo, type SlateLogEntry, type SlateLogFields, type SlateLogListener, type SlateLogMessageInput, type SlateLogType, SlateLogger, type SlatePollingOptions, 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, allOf, anyOf, auth, axios, config, createAxios, createBase64Attachment, createSlateError, createTextAttachment, createUrlAttachment, getCurrentContext, getServiceErrorData, inferSlateErrorFromAxios, isAxiosErrorLike, isServiceErrorData, mapServiceErrorCode, mapServiceErrorToSlateErrorInput, mergeScopes, runWithContext, scopeClause, spec, tool, trigger, validateScopes };