import { AppRef } from './apps.js';
export { BuiltinApp } from './apps.js';
import { z } from 'zod';

interface ZapierClient {
    fetch(url: string, options: {
        connection?: string;
        method?: string;
        headers?: Record<string, string>;
        body?: string | Record<string, unknown> | null;
        timeout?: number;
    }): Promise<Response>;
}
interface DefineContext {
    zapier: ZapierClient;
}
interface StepOptions<T> {
    name: string;
    run: () => Promise<T>;
    maxAttempts?: number;
    retryDelaySeconds?: number;
    outputSchema?: z.ZodSchema<T>;
}
interface WaitOptions {
    name: string;
    seconds: number;
}
interface CallbackOptions<T = unknown> {
    name: string;
    timeoutSeconds?: number;
    payloadSchema?: z.ZodSchema<T>;
}
type ToolContext = DefineContext;
interface SingleConnectionToolContext extends DefineContext {
    connection: string;
}
interface MultiConnectionToolContext<TConn extends Record<string, AppRef>> extends DefineContext {
    connections: {
        [K in keyof TConn]: string;
    };
}
interface DurableContext extends DefineContext {
    step<T>(name: string, fn: () => Promise<T>): Promise<T>;
    step<T>(options: StepOptions<T>): Promise<T>;
    wait(name: string, seconds: number): Promise<void>;
    wait(options: WaitOptions): Promise<void>;
    createCallback(name: string): Promise<[Promise<unknown>, string]>;
    createCallback<T>(options: CallbackOptions<T>): Promise<[Promise<T>, string]>;
}
type ComponentCtx = DefineContext;
declare const CONNECTION_BRAND: unique symbol;
type ConnectionId<TApp extends AppRef> = string & {
    readonly [CONNECTION_BRAND]: TApp;
};
interface SingleConnExecuteOptions<TApp extends AppRef> {
    connection: ConnectionId<TApp>;
}
interface MultiConnExecuteOptions<TConn extends Record<string, AppRef>> {
    connections: {
        [K in keyof TConn]: ConnectionId<TConn[K]>;
    };
}
type RefProxy<K extends string> = {
    [P in K]: {
        $ref: P;
    };
};
type ResolveDirective = {
    kind: "options";
    tool: unknown;
    binds?: Record<string, {
        $ref: string;
    }>;
} | {
    kind: "schema";
    tool: unknown;
    binds?: Record<string, {
        $ref: string;
    }>;
};
interface WithInputDependencies<TInput extends z.ZodType> {
    inputDependencies?: ($: RefProxy<keyof z.infer<TInput> & string>) => Record<string, ResolveDirective>;
}
interface WithResultProcessors {
    options?: (result: unknown) => Array<{
        label: string;
        value: string;
    }>;
    schema?: (result: unknown) => z.ZodType;
    digest?: (result: unknown) => unknown;
}
interface DescribeResult {
    kind: "tool" | "durable" | "component";
    name: string;
    description?: string;
    inputSchema?: Record<string, unknown>;
    connection?: AppRef;
    connections?: Record<string, AppRef>;
}
interface ConnectionlessToolConfig<TInput extends z.ZodType> extends WithInputDependencies<TInput>, WithResultProcessors {
    name: string;
    description: string;
    connection?: never;
    connections?: never;
    inputSchema: TInput;
    run: (ctx: ToolContext, input: z.infer<TInput>) => Promise<unknown>;
}
interface SingleConnToolConfig<TInput extends z.ZodType, TApp extends AppRef = AppRef> extends WithInputDependencies<TInput>, WithResultProcessors {
    name: string;
    description: string;
    connection: TApp;
    connections?: never;
    inputSchema: TInput;
    run: (ctx: SingleConnectionToolContext, input: z.infer<TInput>) => Promise<unknown>;
}
interface MultiConnToolConfig<TInput extends z.ZodType, TConn extends Record<string, AppRef>> extends WithInputDependencies<TInput>, WithResultProcessors {
    name: string;
    description: string;
    connection?: never;
    connections: TConn;
    inputSchema: TInput;
    run: (ctx: MultiConnectionToolContext<TConn>, input: z.infer<TInput>) => Promise<unknown>;
}
interface ToolFnMeta<TInput extends z.ZodType, TConn extends AppRef | Record<string, AppRef> | undefined> extends WithInputDependencies<TInput>, WithResultProcessors {
    kind: "tool";
    name: string;
    description: string;
    connection: TConn extends AppRef ? TConn : undefined;
    connections: TConn extends Record<string, AppRef> ? TConn : undefined;
    inputSchema: TInput;
    run: TConn extends Record<string, AppRef> ? (ctx: MultiConnectionToolContext<TConn>, input: z.infer<TInput>) => Promise<unknown> : TConn extends AppRef ? (ctx: SingleConnectionToolContext, input: z.infer<TInput>) => Promise<unknown> : (ctx: ToolContext, input: z.infer<TInput>) => Promise<unknown>;
    describe(): DescribeResult;
}
type ToolFn<TInput extends z.ZodType, TConn extends AppRef | Record<string, AppRef>> = (TConn extends AppRef ? (input: z.infer<TInput>, opts: SingleConnExecuteOptions<TConn>) => Promise<unknown> : TConn extends Record<string, AppRef> ? (input: z.infer<TInput>, opts: MultiConnExecuteOptions<TConn>) => Promise<unknown> : never) & ToolFnMeta<TInput, TConn>;
type ConnectionlessToolFn<TInput extends z.ZodType> = ((input: z.infer<TInput>) => Promise<unknown>) & ToolFnMeta<TInput, undefined>;
interface ConnectionlessDurableConfig<TInput extends z.ZodType> extends WithInputDependencies<TInput> {
    name: string;
    description: string;
    connection?: never;
    connections?: never;
    inputSchema: TInput;
    run: (ctx: DurableContext, input: z.infer<TInput>) => Promise<unknown>;
}
interface SingleConnDurableConfig<TInput extends z.ZodType, TApp extends AppRef = AppRef> extends WithInputDependencies<TInput> {
    name: string;
    description: string;
    connection: TApp;
    connections?: never;
    inputSchema: TInput;
    run: (ctx: DurableContext & {
        connection: string;
    }, input: z.infer<TInput>) => Promise<unknown>;
}
interface MultiConnDurableConfig<TInput extends z.ZodType, TConn extends Record<string, AppRef>> extends WithInputDependencies<TInput> {
    name: string;
    description: string;
    connection?: never;
    connections: TConn;
    inputSchema: TInput;
    run: (ctx: DurableContext & {
        connections: {
            [K in keyof TConn]: string;
        };
    }, input: z.infer<TInput>) => Promise<unknown>;
}
interface DurableResult<T = unknown> {
    done: boolean;
    result?: T;
    error?: Error;
    executionId?: string;
}
interface DurableFnMeta<TInput extends z.ZodType, TConn extends AppRef | Record<string, AppRef> | undefined> extends WithInputDependencies<TInput> {
    kind: "durable";
    name: string;
    description: string;
    connection: TConn extends AppRef ? TConn : undefined;
    connections: TConn extends Record<string, AppRef> ? TConn : undefined;
    inputSchema: TInput;
    run: TConn extends Record<string, AppRef> ? (ctx: DurableContext & {
        connections: {
            [K in keyof TConn]: string;
        };
    }, input: z.infer<TInput>) => Promise<unknown> : TConn extends AppRef ? (ctx: DurableContext & {
        connection: string;
    }, input: z.infer<TInput>) => Promise<unknown> : (ctx: DurableContext, input: z.infer<TInput>) => Promise<unknown>;
    describe(): DescribeResult;
}
type ConnectionlessDurableFn<TInput extends z.ZodType> = ((input: z.infer<TInput>) => Promise<DurableResult>) & DurableFnMeta<TInput, undefined>;
type DurableFn<TInput extends z.ZodType, TConn extends AppRef | Record<string, AppRef>> = (TConn extends AppRef ? (input: z.infer<TInput>, opts: SingleConnExecuteOptions<TConn>) => Promise<DurableResult> : TConn extends Record<string, AppRef> ? (input: z.infer<TInput>, opts: MultiConnExecuteOptions<TConn>) => Promise<DurableResult> : never) & DurableFnMeta<TInput, TConn>;
interface ReservedComponentProps {
    connection?: never;
    connections?: never;
    zapier?: never;
}
type AssertNoReservedComponentProps<TProps> = Extract<keyof TProps, keyof ReservedComponentProps> extends never ? TProps : never;
interface SingleConnectionCtx<TApp extends AppRef> {
    connection: ConnectionId<TApp>;
    connections?: never;
}
interface MultiConnectionCtx<TConn extends Record<string, AppRef>> {
    connection?: never;
    connections: {
        [K in keyof TConn]: ConnectionId<TConn[K]>;
    };
}
interface ConnectionlessComponentConfig<TProps> {
    name: string;
    description?: string;
    connection?: never;
    connections?: never;
    render: (props: AssertNoReservedComponentProps<TProps> & ComponentCtx) => unknown;
}
interface SingleConnComponentConfig<TProps, TApp extends AppRef> {
    name: string;
    description?: string;
    connection: TApp;
    connections?: never;
    render: (props: AssertNoReservedComponentProps<TProps> & SingleConnectionCtx<TApp> & ComponentCtx) => unknown;
}
interface MultiConnComponentConfig<TProps, TConn extends Record<string, AppRef>> {
    name: string;
    description?: string;
    connection?: never;
    connections: TConn;
    render: (props: AssertNoReservedComponentProps<TProps> & MultiConnectionCtx<TConn> & ComponentCtx) => unknown;
}
type ComponentConfig<TProps> = ConnectionlessComponentConfig<TProps> | SingleConnComponentConfig<TProps, AppRef> | MultiConnComponentConfig<TProps, Record<string, AppRef>>;
type ComponentFn<TProps> = ((props: TProps) => unknown) & {
    kind: "component";
    name: string;
    description?: string;
    connection?: AppRef;
    connections?: Record<string, AppRef>;
    describe(): DescribeResult;
};

declare function defineTool<TInput extends z.ZodType>(config: ConnectionlessToolConfig<TInput>): ConnectionlessToolFn<TInput>;
declare function defineTool<TInput extends z.ZodType, TApp extends AppRef>(config: SingleConnToolConfig<TInput, TApp>): ToolFn<TInput, TApp>;
declare function defineTool<TInput extends z.ZodType, TConn extends Record<string, AppRef>>(config: MultiConnToolConfig<TInput, TConn>): ToolFn<TInput, TConn>;
declare function defineDurable<TInput extends z.ZodType>(config: ConnectionlessDurableConfig<TInput>): ConnectionlessDurableFn<TInput>;
declare function defineDurable<TInput extends z.ZodType, TApp extends AppRef>(config: SingleConnDurableConfig<TInput, TApp>): DurableFn<TInput, TApp>;
declare function defineDurable<TInput extends z.ZodType, TConn extends Record<string, AppRef>>(config: MultiConnDurableConfig<TInput, TConn>): DurableFn<TInput, TConn>;
declare function defineComponent<TProps>(config: ConnectionlessComponentConfig<TProps>): ComponentFn<TProps>;
declare function defineComponent<TProps, TApp extends AppRef>(config: SingleConnComponentConfig<TProps, TApp>): ComponentFn<TProps & SingleConnectionCtx<TApp>>;
declare function defineComponent<TProps, TConn extends Record<string, AppRef>>(config: MultiConnComponentConfig<TProps, TConn>): ComponentFn<TProps & MultiConnectionCtx<TConn>>;

declare function optionsFrom(tool: unknown, binds?: Record<string, {
    $ref: string;
}>): ResolveDirective;
declare function schemaFrom(tool: unknown, binds?: Record<string, {
    $ref: string;
}>): ResolveDirective;

export { AppRef, type AssertNoReservedComponentProps, type CallbackOptions, type ComponentConfig, type ComponentCtx, type ComponentFn, type ConnectionId, type ConnectionlessComponentConfig, type ConnectionlessDurableConfig, type ConnectionlessDurableFn, type ConnectionlessToolConfig, type ConnectionlessToolFn, type DefineContext, type DescribeResult, type DurableContext, type DurableFn, type DurableResult, type MultiConnComponentConfig, type MultiConnDurableConfig, type MultiConnExecuteOptions, type MultiConnToolConfig, type MultiConnectionCtx, type MultiConnectionToolContext, type RefProxy, type ReservedComponentProps, type ResolveDirective, type SingleConnComponentConfig, type SingleConnDurableConfig, type SingleConnExecuteOptions, type SingleConnToolConfig, type SingleConnectionCtx, type SingleConnectionToolContext, type StepOptions, type ToolContext, type ToolFn, type WaitOptions, type WithInputDependencies, type WithResultProcessors, type ZapierClient, defineComponent, defineDurable, defineTool, optionsFrom, schemaFrom };