import type { z } from "zod";
import type { AppRef } from "./apps";
export interface ZapierClient {
    fetch(url: string, options: {
        connection?: string;
        method?: string;
        headers?: Record<string, string>;
        body?: string | Record<string, unknown> | null;
        timeout?: number;
    }): Promise<Response>;
}
export interface DefineContext {
    zapier: ZapierClient;
}
export interface StepOptions<T> {
    name: string;
    run: () => Promise<T>;
    maxAttempts?: number;
    retryDelaySeconds?: number;
    outputSchema?: z.ZodSchema<T>;
}
export interface WaitOptions {
    name: string;
    seconds: number;
}
export interface CallbackOptions<T = unknown> {
    name: string;
    timeoutSeconds?: number;
    payloadSchema?: z.ZodSchema<T>;
}
export type ToolContext = DefineContext;
export interface SingleConnectionToolContext extends DefineContext {
    connection: string;
}
export interface MultiConnectionToolContext<TConn extends Record<string, AppRef>> extends DefineContext {
    connections: {
        [K in keyof TConn]: string;
    };
}
export 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]>;
}
export type ComponentCtx = DefineContext;
declare const CONNECTION_BRAND: unique symbol;
export type ConnectionId<TApp extends AppRef> = string & {
    readonly [CONNECTION_BRAND]: TApp;
};
export interface SingleConnExecuteOptions<TApp extends AppRef> {
    connection: ConnectionId<TApp>;
}
export interface MultiConnExecuteOptions<TConn extends Record<string, AppRef>> {
    connections: {
        [K in keyof TConn]: ConnectionId<TConn[K]>;
    };
}
export type RefProxy<K extends string> = {
    [P in K]: {
        $ref: P;
    };
};
export type ResolveDirective = {
    kind: "options";
    tool: unknown;
    binds?: Record<string, {
        $ref: string;
    }>;
} | {
    kind: "schema";
    tool: unknown;
    binds?: Record<string, {
        $ref: string;
    }>;
};
export interface WithInputDependencies<TInput extends z.ZodType> {
    inputDependencies?: ($: RefProxy<keyof z.infer<TInput> & string>) => Record<string, ResolveDirective>;
}
export interface WithResultProcessors {
    options?: (result: unknown) => Array<{
        label: string;
        value: string;
    }>;
    schema?: (result: unknown) => z.ZodType;
    digest?: (result: unknown) => unknown;
}
export interface DescribeResult {
    kind: "tool" | "durable" | "component";
    name: string;
    description?: string;
    inputSchema?: Record<string, unknown>;
    connection?: AppRef;
    connections?: Record<string, AppRef>;
}
export 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>;
}
export 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>;
}
export 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;
}
export 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>;
export type ConnectionlessToolFn<TInput extends z.ZodType> = ((input: z.infer<TInput>) => Promise<unknown>) & ToolFnMeta<TInput, undefined>;
export 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>;
}
export 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>;
}
export 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>;
}
export 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;
}
export type ConnectionlessDurableFn<TInput extends z.ZodType> = ((input: z.infer<TInput>) => Promise<DurableResult>) & DurableFnMeta<TInput, undefined>;
export 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>;
export interface ReservedComponentProps {
    connection?: never;
    connections?: never;
    zapier?: never;
}
export type AssertNoReservedComponentProps<TProps> = Extract<keyof TProps, keyof ReservedComponentProps> extends never ? TProps : never;
export interface SingleConnectionCtx<TApp extends AppRef> {
    connection: ConnectionId<TApp>;
    connections?: never;
}
export interface MultiConnectionCtx<TConn extends Record<string, AppRef>> {
    connection?: never;
    connections: {
        [K in keyof TConn]: ConnectionId<TConn[K]>;
    };
}
export interface ConnectionlessComponentConfig<TProps> {
    name: string;
    description?: string;
    connection?: never;
    connections?: never;
    render: (props: AssertNoReservedComponentProps<TProps> & ComponentCtx) => unknown;
}
export interface SingleConnComponentConfig<TProps, TApp extends AppRef> {
    name: string;
    description?: string;
    connection: TApp;
    connections?: never;
    render: (props: AssertNoReservedComponentProps<TProps> & SingleConnectionCtx<TApp> & ComponentCtx) => unknown;
}
export interface MultiConnComponentConfig<TProps, TConn extends Record<string, AppRef>> {
    name: string;
    description?: string;
    connection?: never;
    connections: TConn;
    render: (props: AssertNoReservedComponentProps<TProps> & MultiConnectionCtx<TConn> & ComponentCtx) => unknown;
}
export type ComponentConfig<TProps> = ConnectionlessComponentConfig<TProps> | SingleConnComponentConfig<TProps, AppRef> | MultiConnComponentConfig<TProps, Record<string, AppRef>>;
export type ComponentFn<TProps> = ((props: TProps) => unknown) & {
    kind: "component";
    name: string;
    description?: string;
    connection?: AppRef;
    connections?: Record<string, AppRef>;
    describe(): DescribeResult;
};
export {};
//# sourceMappingURL=types.d.ts.map