import 'reflect-metadata';
import type z from '@frontmcp/lazy-zod';
import { type JobContext } from '../interfaces';
import { type EsmOptions, type RemoteOptions, type ToolInputType, type ToolOutputType } from '../metadata';
import { type JobMetadata } from '../metadata/job.metadata';
import { type JobEsmTargetRecord, type JobRemoteRecord } from '../records/job.record';
import { type ToolInputOf, type ToolOutputOf } from './tool.decorator';
export type FrontMcpJobExecuteHandler<InSchema extends ToolInputType, OutSchema extends ToolOutputType, In = ToolInputOf<{
    inputSchema: InSchema;
}>, Out = ToolOutputOf<{
    outputSchema: OutSchema;
}>> = (input: In, ctx: JobContext<InSchema, OutSchema>) => Out | Promise<Out>;
/**
 * Function builder for creating jobs without classes.
 */
declare function frontMcpJob<T extends JobMetadata, InSchema extends ToolInputType = T['inputSchema'], OutSchema extends ToolOutputType = NonNullable<T['outputSchema']>>(providedMetadata: T): (handler: FrontMcpJobExecuteHandler<InSchema, OutSchema>) => () => FrontMcpJobExecuteHandler<InSchema, OutSchema>;
declare function jobEsm(specifier: string, targetName: string, options?: EsmOptions<JobMetadata>): JobEsmTargetRecord;
declare function jobRemote(url: string, targetName: string, options?: RemoteOptions<JobMetadata>): JobRemoteRecord;
type __Shape = z.ZodRawShape;
type __PrimitiveOutputType = 'string' | 'number' | 'date' | 'boolean' | z.ZodString | z.ZodNumber | z.ZodBoolean | z.ZodBigInt | z.ZodDate;
type __MediaOutputType = 'image' | 'audio' | 'resource' | 'resource_link';
type __StructuredOutputType = z.ZodRawShape | z.ZodObject<any> | z.ZodArray<z.ZodType> | z.ZodUnion<[z.ZodObject<any>, ...z.ZodObject<any>[]]> | z.ZodDiscriminatedUnion<[z.ZodObject<any>, ...z.ZodObject<any>[]]>;
type __JobSingleOutputType = __PrimitiveOutputType | __MediaOutputType | __StructuredOutputType;
type __OutputSchema = __JobSingleOutputType | __JobSingleOutputType[];
type __Ctor = (new (...a: any[]) => any) | (abstract new (...a: any[]) => any);
type __A<C extends __Ctor> = C extends new (...a: infer A) => any ? A : C extends abstract new (...a: infer A) => any ? A : never;
type __R<C extends __Ctor> = C extends new (...a: any[]) => infer R ? R : C extends abstract new (...a: any[]) => infer R ? R : never;
type __ExecParams<C extends __Ctor> = __R<C> extends {
    execute: (...args: infer P) => unknown;
} ? P : never;
type __HasNoParam<C extends __Ctor> = [__ExecParams<C>] extends [readonly []] ? true : false;
type __Param<C extends __Ctor> = __ExecParams<C> extends readonly [infer P, ...unknown[]] ? P : never;
type __Return<C extends __Ctor> = __R<C> extends {
    execute: (...a: any) => infer R;
} ? R : never;
type __Unwrap<T> = T extends Promise<infer U> ? U : T;
type __IsAny<T> = 0 extends 1 & T ? true : false;
type __MustExtendCtx<C extends __Ctor> = __R<C> extends JobContext ? unknown : {
    'Job class error': 'Class must extend JobContext';
};
type __MustParam<C extends __Ctor, In> = __IsAny<In> extends true ? unknown : __IsAny<__Param<C>> extends true ? {
    'execute() parameter error': "Parameter type must not be 'any'.";
    expected_input_type: In;
} : __HasNoParam<C> extends true ? In extends Record<string, never> ? unknown : {
    'execute() parameter error': 'execute() requires a parameter matching the input schema.';
    expected_input_type: In;
} : __Param<C> extends In ? In extends __Param<C> ? unknown : {
    'execute() parameter error': 'Parameter type is too wide. It must exactly match the input schema.';
    expected_input_type: In;
    actual_parameter_type: __Param<C>;
} : {
    'execute() parameter error': 'Parameter type does not match the input schema.';
    expected_input_type: In;
    actual_parameter_type: __Param<C>;
};
type __MustReturn<C extends __Ctor, Out> = __IsAny<Out> extends true ? unknown : __IsAny<__Unwrap<__Return<C>>> extends true ? {
    'execute() return type error': "Return type must not be 'any'.";
    expected_output_type: Out;
} : __Unwrap<__Return<C>> extends Out ? unknown : {
    'execute() return type error': "The method's return type is not assignable to the expected output schema type.";
    expected_output_type: Out;
    'actual_return_type (unwrapped)': __Unwrap<__Return<C>>;
};
type __Rewrap<C extends __Ctor, In, Out> = C extends abstract new (...a: __A<C>) => __R<C> ? C & (abstract new (...a: __A<C>) => JobContext<any, any, In, Out> & __R<C>) : C extends new (...a: __A<C>) => __R<C> ? C & (new (...a: __A<C>) => JobContext<any, any, In, Out> & __R<C>) : never;
interface JobDecorator {
    <I extends __Shape, O extends __OutputSchema>(opts: JobMetadata<I, O> & {
        outputSchema: O;
    }): <C extends __Ctor>(cls: C & __MustExtendCtx<C> & __MustParam<C, ToolInputOf<{
        inputSchema: I;
    }>> & __MustReturn<C, ToolOutputOf<{
        outputSchema: O;
    }>>) => __Rewrap<C, ToolInputOf<{
        inputSchema: I;
    }>, ToolOutputOf<{
        outputSchema: O;
    }>>;
    esm: typeof jobEsm;
    remote: typeof jobRemote;
}
declare const FrontMcpJob: JobDecorator;
declare const Job: JobDecorator;
export { FrontMcpJob, Job, frontMcpJob, frontMcpJob as job };
//# sourceMappingURL=job.decorator.d.ts.map