import 'reflect-metadata';
import { type ConcurrencyConfigInput, type RateLimitConfigInput, type TimeoutConfigInput } from '@frontmcp/guard';
import type z from '@frontmcp/lazy-zod';
import { type ToolContext } from '../interfaces';
import { type AudioOutputSchema, type ImageOutputSchema, type ResourceLinkOutputSchema, type ResourceOutputSchema, type ToolInputType, type ToolMetadata, type ToolOutputType } from '../metadata';
import { type ToolUIConfig } from '../metadata/tool-ui.metadata';
export type FrontMcpToolExecuteHandler<InSchema extends ToolInputType, OutSchema extends ToolOutputType, In = ToolInputOf<{
    inputSchema: InSchema;
}>, Out = ToolOutputOf<{
    outputSchema: OutSchema;
}>> = (input: In, ctx: ToolContext<InSchema, OutSchema>) => Out | Promise<Out>;
/**
 * Decorator that marks a class as a McpTool module and provides metadata
 */
declare function frontMcpTool<T extends ToolMetadata, InSchema extends ToolInputType = T['inputSchema'], OutSchema extends ToolOutputType = T['outputSchema']>(providedMetadata: T): (handler: FrontMcpToolExecuteHandler<InSchema, OutSchema>) => () => void;
export { FrontMcpTool, FrontMcpTool as Tool, frontMcpTool, frontMcpTool as tool };
/**
 * This is a modified version of the original decorator, with the following changes:
 * - Added support for ZodRawShape as inputSchema
 * - Added support for outputSchema: any of the allowed forms
 * - Added rich error messages for input/output type mismatches
 *
 * Don't move below code outside the decorator file, it will break the module augmentation.
 */
type __Shape = z.ZodRawShape;
type __AsZodObj<T> = T extends z.ZodRawShape ? z.ZodObject<T> : never;
export type ToolInputOf<Opt> = Opt extends {
    inputSchema: infer I;
} ? z.output<__AsZodObj<I>> : never;
/**
 * Helper to infer the return type from any Zod schema,
 * including ZodRawShape.
 */
type __InferZod<S> = S extends z.ZodType ? z.infer<S> : S extends z.ZodRawShape ? z.infer<z.ZodObject<S>> : never;
/**
 * Infers the *output type* from a *single schema definition*
 * based on the new ToolSingleOutputType.
 */
type __InferFromSingleSchema<S> = S extends 'image' ? z.infer<typeof ImageOutputSchema> : S extends 'audio' ? z.infer<typeof AudioOutputSchema> : S extends 'resource' ? z.infer<typeof ResourceOutputSchema> : S extends 'resource_link' ? z.infer<typeof ResourceLinkOutputSchema> : S extends 'string' ? string : S extends 'number' ? number : S extends 'boolean' ? boolean : S extends 'date' ? Date : S extends z.ZodType | z.ZodRawShape ? __InferZod<S> : any;
/**
 * Infers a tuple/array of output types from an array of schemas
 */
type __InferFromArraySchema<A> = A extends readonly any[] ? {
    [K in keyof A]: __InferFromSingleSchema<A[K]>;
} : never;
/**
 * Main output type inference.
 * Handles single schemas, arrays of schemas, or no schema.
 */
export type ToolOutputOf<Opt> = Opt extends {
    outputSchema: infer O;
} ? O extends readonly any[] ? __InferFromArraySchema<O> : __InferFromSingleSchema<O> : any;
type __PrimitiveOutputType = 'string' | 'number' | 'date' | 'boolean' | z.ZodString | z.ZodNumber | z.ZodBoolean | z.ZodBigInt | z.ZodDate;
type __ImageOutputType = 'image';
type __AudioOutputType = 'audio';
type __ResourceOutputType = 'resource';
type __ResourceLinkOutputType = '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 __ToolSingleOutputType = __PrimitiveOutputType | __ImageOutputType | __AudioOutputType | __ResourceOutputType | __ResourceLinkOutputType | __StructuredOutputType;
type __OutputSchema = __ToolSingleOutputType | __ToolSingleOutputType[];
/**
 * Base tool metadata options without UI field.
 */
type __ToolMetadataBase<I extends __Shape, O extends __OutputSchema> = ToolMetadata<I, // inputSchema: ZodRawShape only
O>;
/**
 * Tool metadata options with optional UI configuration.
 *
 * The `ui` property accepts a `ToolUIConfig` from `@frontmcp/ui/types`
 * for configuring interactive widget rendering.
 */
/**
 * Tool metadata options with permissive guard config types for IDE IntelliSense.
 *
 * Guard fields (concurrency, rateLimit, timeout) use auto-generated Input types
 * where all fields are optional. Required fields are validated at runtime by Zod.
 * @see schemas.generated.ts in @frontmcp/guard
 *
 * These four fields are `Omit`-ed from {@link ToolMetadata} and re-declared with
 * the permissive `*Input` types. The re-declarations carry their own JSDoc so
 * editor hover docs work on them (the base field docs do not survive `Omit`) —
 * #452.
 */
export type ToolMetadataOptions<I extends __Shape, O extends __OutputSchema> = Omit<__ToolMetadataBase<I, O>, 'concurrency' | 'rateLimit' | 'timeout' | 'ui'> & {
    /**
     * Concurrency control for this tool — caps the number of simultaneous executions.
     *
     * @example
     * ```typescript
     * @Tool({ name: 'deploy', inputSchema: { env: z.string() }, concurrency: { maxConcurrent: 1 } })
     * ```
     */
    concurrency?: ConcurrencyConfigInput;
    /**
     * Rate limiting for this tool — how many requests are allowed within a time window.
     *
     * @example
     * ```typescript
     * @Tool({
     *   name: 'search',
     *   inputSchema: { query: z.string() },
     *   rateLimit: { maxRequests: 100, windowMs: 60_000, partitionBy: 'userId' },
     * })
     * ```
     */
    rateLimit?: RateLimitConfigInput;
    /**
     * Timeout for this tool's execution — wraps the execute stage with a deadline.
     *
     * @example
     * ```typescript
     * @Tool({ name: 'long-task', inputSchema: { query: z.string() }, timeout: { executeMs: 30_000 } })
     * ```
     */
    timeout?: TimeoutConfigInput;
    /**
     * Interactive widget UI for this tool's result (MCP-UI / ext-apps).
     *
     * Prefer the file-based form — point at a `.tsx`/`.html` widget and the build
     * bundles it; the input/output types are inferred from this tool's schemas.
     *
     * @example
     * ```typescript
     * @Tool({ name: 'chart', inputSchema: { points: z.array(z.number()) }, ui: { file: './chart.widget.tsx' } })
     * ```
     */
    ui?: ToolUIConfig<ToolInputOf<{
        inputSchema: I;
    }>, ToolOutputOf<{
        outputSchema: O;
    }>>;
};
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 ToolContext ? unknown : {
    'Tool class error': 'Class must extend ToolContext';
};
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>) => ToolContext<any, any, In, Out> & __R<C>) : C extends new (...a: __A<C>) => __R<C> ? C & (new (...a: __A<C>) => ToolContext<any, any, In, Out> & __R<C>) : never;
declare module '@frontmcp/sdk' {
    function Tool<I extends __Shape, O extends __OutputSchema>(opts: ToolMetadataOptions<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;
    }>>;
    function Tool<I extends __Shape>(opts: ToolMetadataOptions<I, any> & {
        outputSchema?: never;
    }): <C extends __Ctor>(cls: C & __MustExtendCtx<C> & __MustParam<C, ToolInputOf<{
        inputSchema: I;
    }>> & __MustReturn<C, ToolOutputOf<{}>>) => __Rewrap<C, ToolInputOf<{
        inputSchema: I;
    }>, ToolOutputOf<{}>>;
}
//# sourceMappingURL=tool.decorator.d.ts.map