import { type SQL } from 'drizzle-orm';
import { type H3Event } from 'h3';
import { z } from 'zod';
import { type DatabaseType, type SqlExecutionResult, type TransactionOptions, type TransactionRunner } from './db.js';
export declare const processorConfigSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
    processor: z.ZodString;
    param: z.ZodOptional<z.ZodUnknown>;
}, "strict", z.ZodTypeAny, {
    processor: string;
    param?: unknown;
}, {
    processor: string;
    param?: unknown;
}>]>;
export declare const processorsSchema: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
    processor: z.ZodString;
    param: z.ZodOptional<z.ZodUnknown>;
}, "strict", z.ZodTypeAny, {
    processor: string;
    param?: unknown;
}, {
    processor: string;
    param?: unknown;
}>]>, "many">;
export declare const processableKeySchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
    key: z.ZodString;
    processors: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
        processor: z.ZodString;
        param: z.ZodOptional<z.ZodUnknown>;
    }, "strict", z.ZodTypeAny, {
        processor: string;
        param?: unknown;
    }, {
        processor: string;
        param?: unknown;
    }>]>, "many">>>;
}, "strict", z.ZodTypeAny, {
    key: string;
    processors: (string | {
        processor: string;
        param?: unknown;
    })[];
}, {
    key: string;
    processors?: (string | {
        processor: string;
        param?: unknown;
    })[] | undefined;
}>]>;
export declare const calculateTemplateSchema: z.ZodObject<{
    template: z.ZodString;
    processors: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
        processor: z.ZodString;
        param: z.ZodOptional<z.ZodUnknown>;
    }, "strict", z.ZodTypeAny, {
        processor: string;
        param?: unknown;
    }, {
        processor: string;
        param?: unknown;
    }>]>, "many">>>;
}, "strict", z.ZodTypeAny, {
    processors: (string | {
        processor: string;
        param?: unknown;
    })[];
    template: string;
}, {
    template: string;
    processors?: (string | {
        processor: string;
        param?: unknown;
    })[] | undefined;
}>;
declare const conditionTypeSchema: z.ZodEnum<["GE", "GT", "LE", "LT", "NEQ", "EQ", "NOTIN", "IN", "LIKE"]>;
declare const groupTypeSchema: z.ZodEnum<["AND", "OR"]>;
export type CalculateTemplate = z.infer<typeof calculateTemplateSchema>;
export type ProcessorConfig = z.infer<typeof processorConfigSchema>;
export type ProcessableKey = z.infer<typeof processableKeySchema>;
export type NextBlockUuid = string | null;
type LeafCondition = {
    group: false;
    fieldName: string;
    fieldValue?: unknown;
    conditionType: z.infer<typeof conditionTypeSchema>;
    optional?: boolean;
};
type GroupCondition = {
    group: true;
    groupType: z.infer<typeof groupTypeSchema>;
    groups: OrchestrationCondition[];
};
export type OrchestrationCondition = LeafCondition | GroupCondition;
export declare const conditionSchema: z.ZodType<OrchestrationCondition>;
export type Block = {
    uuid: string;
    alias?: string;
    functionName: string;
    type?: string;
    inputs: Record<string, unknown>;
    outputs?: ProcessableKey[] | null;
    nextBlock: NextBlockUuid;
    errorNextBlock?: NextBlockUuid;
};
export type ExecuteFragmentBlock = Block & {
    functionName: 'executeFragment';
    inputs: {
        fragmentUuid: string;
        params: Record<string, unknown>;
    };
    outputs: ['result'];
};
export type StarterBlock = {
    uuid: 'starter';
    nextBlock: NextBlockUuid;
};
export type ControllerNode = {
    uuid: string;
    alias?: string;
    type?: 'DEFAULT';
    value?: string | number | boolean;
    nextBlock: NextBlockUuid;
};
export type Controller = {
    uuid: string;
    alias?: string;
    functionName: string;
    type: 'controller';
    inputs: Record<string, unknown>;
    nodes: ControllerNode[];
};
export type OrchestrationBlock = StarterBlock | Block | ExecuteFragmentBlock | Controller;
export type ResponseConfig = Record<string, unknown> | null;
export declare const controllerNodeSchema: z.ZodType<ControllerNode, z.ZodTypeDef, unknown>;
export declare const controllerSchema: z.ZodType<Controller, z.ZodTypeDef, unknown>;
export declare const blockSchema: z.ZodType<OrchestrationBlock, z.ZodTypeDef, unknown>;
declare const endpointApiJsonSchema: z.ZodObject<{
    fragment: z.ZodDefault<z.ZodOptional<z.ZodLiteral<false>>>;
    method: z.ZodEffects<z.ZodString, string, string>;
    request: z.ZodDefault<z.ZodOptional<z.ZodObject<{
        header: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
            key: z.ZodString;
            processors: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
                processor: z.ZodString;
                param: z.ZodOptional<z.ZodUnknown>;
            }, "strict", z.ZodTypeAny, {
                processor: string;
                param?: unknown;
            }, {
                processor: string;
                param?: unknown;
            }>]>, "many">>>;
        }, "strict", z.ZodTypeAny, {
            key: string;
            processors: (string | {
                processor: string;
                param?: unknown;
            })[];
        }, {
            key: string;
            processors?: (string | {
                processor: string;
                param?: unknown;
            })[] | undefined;
        }>]>, "many">>>;
        query: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
            key: z.ZodString;
            processors: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
                processor: z.ZodString;
                param: z.ZodOptional<z.ZodUnknown>;
            }, "strict", z.ZodTypeAny, {
                processor: string;
                param?: unknown;
            }, {
                processor: string;
                param?: unknown;
            }>]>, "many">>>;
        }, "strict", z.ZodTypeAny, {
            key: string;
            processors: (string | {
                processor: string;
                param?: unknown;
            })[];
        }, {
            key: string;
            processors?: (string | {
                processor: string;
                param?: unknown;
            })[] | undefined;
        }>]>, "many">>>;
        body: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
            key: z.ZodString;
            processors: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
                processor: z.ZodString;
                param: z.ZodOptional<z.ZodUnknown>;
            }, "strict", z.ZodTypeAny, {
                processor: string;
                param?: unknown;
            }, {
                processor: string;
                param?: unknown;
            }>]>, "many">>>;
        }, "strict", z.ZodTypeAny, {
            key: string;
            processors: (string | {
                processor: string;
                param?: unknown;
            })[];
        }, {
            key: string;
            processors?: (string | {
                processor: string;
                param?: unknown;
            })[] | undefined;
        }>]>, "many">>>;
    }, "strict", z.ZodTypeAny, {
        header: (string | {
            key: string;
            processors: (string | {
                processor: string;
                param?: unknown;
            })[];
        })[];
        query: (string | {
            key: string;
            processors: (string | {
                processor: string;
                param?: unknown;
            })[];
        })[];
        body: (string | {
            key: string;
            processors: (string | {
                processor: string;
                param?: unknown;
            })[];
        })[];
    }, {
        header?: (string | {
            key: string;
            processors?: (string | {
                processor: string;
                param?: unknown;
            })[] | undefined;
        })[] | undefined;
        query?: (string | {
            key: string;
            processors?: (string | {
                processor: string;
                param?: unknown;
            })[] | undefined;
        })[] | undefined;
        body?: (string | {
            key: string;
            processors?: (string | {
                processor: string;
                param?: unknown;
            })[] | undefined;
        })[] | undefined;
    }>>>;
    uuid: z.ZodString;
    alias: z.ZodOptional<z.ZodString>;
    blocks: z.ZodDefault<z.ZodArray<z.ZodType<OrchestrationBlock, z.ZodTypeDef, unknown>, "many">>;
    response: z.ZodOptional<z.ZodType<ResponseConfig, z.ZodTypeDef, unknown>>;
    responses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<ResponseConfig, z.ZodTypeDef, unknown>>>;
}, "strict", z.ZodTypeAny, {
    uuid: string;
    fragment: false;
    method: string;
    request: {
        header: (string | {
            key: string;
            processors: (string | {
                processor: string;
                param?: unknown;
            })[];
        })[];
        query: (string | {
            key: string;
            processors: (string | {
                processor: string;
                param?: unknown;
            })[];
        })[];
        body: (string | {
            key: string;
            processors: (string | {
                processor: string;
                param?: unknown;
            })[];
        })[];
    };
    blocks: OrchestrationBlock[];
    alias?: string | undefined;
    response?: ResponseConfig | undefined;
    responses?: Record<string, ResponseConfig> | undefined;
}, {
    uuid: string;
    method: string;
    alias?: string | undefined;
    fragment?: false | undefined;
    request?: {
        header?: (string | {
            key: string;
            processors?: (string | {
                processor: string;
                param?: unknown;
            })[] | undefined;
        })[] | undefined;
        query?: (string | {
            key: string;
            processors?: (string | {
                processor: string;
                param?: unknown;
            })[] | undefined;
        })[] | undefined;
        body?: (string | {
            key: string;
            processors?: (string | {
                processor: string;
                param?: unknown;
            })[] | undefined;
        })[] | undefined;
    } | undefined;
    blocks?: unknown[] | undefined;
    response?: unknown;
    responses?: Record<string, unknown> | undefined;
}>;
declare const fragmentApiJsonSchema: z.ZodObject<{
    fragment: z.ZodLiteral<true>;
    params: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
        key: z.ZodString;
        processors: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
            processor: z.ZodString;
            param: z.ZodOptional<z.ZodUnknown>;
        }, "strict", z.ZodTypeAny, {
            processor: string;
            param?: unknown;
        }, {
            processor: string;
            param?: unknown;
        }>]>, "many">>>;
    }, "strict", z.ZodTypeAny, {
        key: string;
        processors: (string | {
            processor: string;
            param?: unknown;
        })[];
    }, {
        key: string;
        processors?: (string | {
            processor: string;
            param?: unknown;
        })[] | undefined;
    }>]>, "many">>>;
    response: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    responses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
    uuid: z.ZodString;
    alias: z.ZodOptional<z.ZodString>;
    blocks: z.ZodDefault<z.ZodArray<z.ZodType<OrchestrationBlock, z.ZodTypeDef, unknown>, "many">>;
}, "strict", z.ZodTypeAny, {
    params: (string | {
        key: string;
        processors: (string | {
            processor: string;
            param?: unknown;
        })[];
    })[];
    uuid: string;
    fragment: true;
    blocks: OrchestrationBlock[];
    alias?: string | undefined;
    response?: Record<string, unknown> | undefined;
    responses?: Record<string, Record<string, unknown>> | undefined;
}, {
    uuid: string;
    fragment: true;
    params?: (string | {
        key: string;
        processors?: (string | {
            processor: string;
            param?: unknown;
        })[] | undefined;
    })[] | undefined;
    alias?: string | undefined;
    blocks?: unknown[] | undefined;
    response?: Record<string, unknown> | undefined;
    responses?: Record<string, Record<string, unknown>> | undefined;
}>;
export type EndpointApiJson = z.infer<typeof endpointApiJsonSchema>;
export type FragmentApiJson = z.infer<typeof fragmentApiJsonSchema>;
export type ApiJson = EndpointApiJson | FragmentApiJson;
export type RequestContext = {
    header: Record<string, string>;
    query: Record<string, unknown>;
    body: Record<string, unknown>;
};
type BaseBlockExecutionContext = {
    now: string;
    blocks: Record<string, {
        inputs: Record<string, unknown>;
        outputs: Record<string, unknown>;
    }>;
};
export type EndpointBlockExecutionContext = BaseBlockExecutionContext & {
    request: RequestContext;
    header: Record<string, string>;
    query: Record<string, unknown>;
    body: Record<string, unknown>;
};
export type FragmentBlockExecutionContext = BaseBlockExecutionContext & {
    params: Record<string, unknown>;
};
export type BlockExecutionContext = EndpointBlockExecutionContext | FragmentBlockExecutionContext;
export type MokelayDebugError = {
    code: string;
    message: string;
};
export type MokelayDebugBlockStep = {
    uuid: string;
    type: 'block';
    inputs: Record<string, unknown>;
    outputs: Record<string, unknown>;
    nextBlock: MokelayDebugStep | null;
    error?: MokelayDebugError;
    fragment?: MokelayDebugResponse;
};
export type MokelayDebugControllerNode = {
    uuid: string;
    nextBlock: MokelayDebugStep | null;
};
export type MokelayDebugControllerStep = {
    uuid: string;
    type: 'controller';
    inputs: Record<string, unknown>;
    node?: MokelayDebugControllerNode;
    error?: MokelayDebugError;
};
export type MokelayDebugStep = MokelayDebugBlockStep | MokelayDebugControllerStep;
export type MokelayDebugResponse = {
    uuid: 'starter';
    nextBlock: MokelayDebugStep | null;
};
export type SqlExecutor = <T extends Record<string, unknown> = Record<string, unknown>>(query: SQL) => Promise<SqlExecutionResult<T>>;
export type DatasourceSqlExecutor = <T extends Record<string, unknown> = Record<string, unknown>>(query: SQL, datasource: string, databaseType: DatabaseType) => Promise<SqlExecutionResult<T>>;
export type DatasourceTransactionRunner = <T>(datasource: string, callback: (executeSql: SqlExecutor) => Promise<T>, options?: TransactionOptions) => Promise<T>;
export type FragmentInvocation = {
    fragmentUuid: string;
    params: Record<string, unknown>;
};
export type FragmentInvoker = (input: FragmentInvocation) => Promise<Record<string, unknown>>;
export type ProcessValue = (value: unknown, processors: ProcessorConfig[], label: string) => Promise<unknown>;
export type BlockExecutorInput = {
    event: H3Event;
    block: Block;
    inputs: Record<string, unknown>;
    executeSql: SqlExecutor;
    databaseType?: DatabaseType;
    /** Available for datasource-backed blocks; all statements use one connection. */
    withTransaction?: TransactionRunner;
    /** Runs a value through the orchestration Processor pipeline in the current template context. */
    processValue: ProcessValue;
    /** Reserved for the built-in executeFragment Block; other Blocks are rejected at runtime. */
    invokeFragment: FragmentInvoker;
};
export type BlockExecutor = (input: BlockExecutorInput) => Promise<Record<string, unknown>>;
export type BlockDefinition = {
    executor: BlockExecutor;
    allowedOutputs: readonly string[];
    requiresDatasource?: boolean;
};
export type ApiJsonSource = 'system' | 'user';
export type OrchestrationHandlerOptions = {
    loadApiJson?: (apiJsonUuid: string) => Promise<unknown>;
    /**
     * Ownership domain for raw DSL passed directly to executeApiJson. The default
     * handler detects this automatically and custom loaders remain self-contained.
     */
    apiJsonSource?: ApiJsonSource;
    executeSql?: DatasourceSqlExecutor;
    executeTransaction?: DatasourceTransactionRunner;
    blockDefinitions?: Readonly<Record<string, BlockDefinition>>;
};
export type MokelaySuccessResponse = {
    ok: true;
    data: unknown;
    debug?: MokelayDebugResponse;
};
export declare function assertApiJsonUuid(value: string | undefined): string;
export declare function parseApiJson(apiJsonUuid: string, value: unknown): ApiJson;
export declare function isFragmentApiJson(apiJson: ApiJson): apiJson is FragmentApiJson;
export {};