/**
 * AI Module
 *
 * Ready-to-use tool definitions for AI frameworks (OpenAI, Anthropic, Vercel AI SDK).
 *
 * @module ai
 *
 * @example
 * ```typescript
 * // With Vercel AI SDK
 * import { createManifestBuilder, aiTools } from 'archetype-engine/ai'
 * import { generateText } from 'ai'
 * import { openai } from '@ai-sdk/openai'
 *
 * const builder = createManifestBuilder()
 *
 * const result = await generateText({
 *   model: openai('gpt-4o'),
 *   tools: aiTools.vercel(builder),
 *   system: 'You are an app builder. Use the tools to build the app.',
 *   prompt: 'Create a blog with users and posts',
 *   maxSteps: 10
 * })
 *
 * // After AI finishes calling tools, generate the app
 * const { files, success } = await builder.generate()
 * ```
 */
export type { ToolDefinition, ToolParameter, ToolResult, ManifestBuilder, AddEntityParams, UpdateEntityParams, RemoveEntityParams, SetDatabaseParams, SetAuthParams, OpenAITool, AnthropicTool, VercelAITool, } from './types';
export { createManifestBuilder } from './state';
export { toolDefinitions } from './tools';
export { getOpenAITools, executeOpenAITool, createOpenAIHandler } from './adapters/openai';
export { getAnthropicTools, executeAnthropicTool, createAnthropicHandler } from './adapters/anthropic';
export { getVercelAITools } from './adapters/vercel';
export type { VercelAITools } from './adapters/vercel';
import type { ManifestBuilder } from './types';
/**
 * Convenience object for getting tools in different formats
 */
export declare const aiTools: {
    /**
     * Get tools for OpenAI function calling
     */
    openai: () => import("./types").OpenAITool[];
    /**
     * Get tools for Anthropic tool use
     */
    anthropic: () => import("./types").AnthropicTool[];
    /**
     * Get tools for Vercel AI SDK (requires builder instance)
     */
    vercel: (builder: ManifestBuilder) => {
        add_entity: {
            description: string;
            parameters: import("zod").ZodObject<{
                name: import("zod").ZodString;
                fields: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
                    type: import("zod").ZodEnum<["text", "number", "boolean", "date"]>;
                    required: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    unique: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    email: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    url: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    min: import("zod").ZodOptional<import("zod").ZodNumber>;
                    max: import("zod").ZodOptional<import("zod").ZodNumber>;
                    oneOf: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
                    integer: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    positive: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    default: import("zod").ZodOptional<import("zod").ZodUnknown>;
                    label: import("zod").ZodOptional<import("zod").ZodString>;
                }, "strip", import("zod").ZodTypeAny, {
                    type: "number" | "boolean" | "text" | "date";
                    email?: boolean | undefined;
                    url?: boolean | undefined;
                    oneOf?: string[] | undefined;
                    min?: number | undefined;
                    max?: number | undefined;
                    integer?: boolean | undefined;
                    positive?: boolean | undefined;
                    required?: boolean | undefined;
                    unique?: boolean | undefined;
                    default?: unknown;
                    label?: string | undefined;
                }, {
                    type: "number" | "boolean" | "text" | "date";
                    email?: boolean | undefined;
                    url?: boolean | undefined;
                    oneOf?: string[] | undefined;
                    min?: number | undefined;
                    max?: number | undefined;
                    integer?: boolean | undefined;
                    positive?: boolean | undefined;
                    required?: boolean | undefined;
                    unique?: boolean | undefined;
                    default?: unknown;
                    label?: string | undefined;
                }>>;
                relations: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
                    type: import("zod").ZodEnum<["hasOne", "hasMany", "belongsToMany"]>;
                    entity: import("zod").ZodString;
                }, "strip", import("zod").ZodTypeAny, {
                    type: "hasOne" | "hasMany" | "belongsToMany";
                    entity: string;
                }, {
                    type: "hasOne" | "hasMany" | "belongsToMany";
                    entity: string;
                }>>>;
                behaviors: import("zod").ZodOptional<import("zod").ZodObject<{
                    timestamps: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    softDelete: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    audit: import("zod").ZodOptional<import("zod").ZodBoolean>;
                }, "strip", import("zod").ZodTypeAny, {
                    timestamps?: boolean | undefined;
                    softDelete?: boolean | undefined;
                    audit?: boolean | undefined;
                }, {
                    timestamps?: boolean | undefined;
                    softDelete?: boolean | undefined;
                    audit?: boolean | undefined;
                }>>;
                protected: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodBoolean, import("zod").ZodEnum<["write", "all"]>]>>;
            }, "strip", import("zod").ZodTypeAny, {
                fields: Record<string, {
                    type: "number" | "boolean" | "text" | "date";
                    email?: boolean | undefined;
                    url?: boolean | undefined;
                    oneOf?: string[] | undefined;
                    min?: number | undefined;
                    max?: number | undefined;
                    integer?: boolean | undefined;
                    positive?: boolean | undefined;
                    required?: boolean | undefined;
                    unique?: boolean | undefined;
                    default?: unknown;
                    label?: string | undefined;
                }>;
                name: string;
                protected?: boolean | "write" | "all" | undefined;
                relations?: Record<string, {
                    type: "hasOne" | "hasMany" | "belongsToMany";
                    entity: string;
                }> | undefined;
                behaviors?: {
                    timestamps?: boolean | undefined;
                    softDelete?: boolean | undefined;
                    audit?: boolean | undefined;
                } | undefined;
            }, {
                fields: Record<string, {
                    type: "number" | "boolean" | "text" | "date";
                    email?: boolean | undefined;
                    url?: boolean | undefined;
                    oneOf?: string[] | undefined;
                    min?: number | undefined;
                    max?: number | undefined;
                    integer?: boolean | undefined;
                    positive?: boolean | undefined;
                    required?: boolean | undefined;
                    unique?: boolean | undefined;
                    default?: unknown;
                    label?: string | undefined;
                }>;
                name: string;
                protected?: boolean | "write" | "all" | undefined;
                relations?: Record<string, {
                    type: "hasOne" | "hasMany" | "belongsToMany";
                    entity: string;
                }> | undefined;
                behaviors?: {
                    timestamps?: boolean | undefined;
                    softDelete?: boolean | undefined;
                    audit?: boolean | undefined;
                } | undefined;
            }>;
            execute: (params: {
                name: string;
                fields: Record<string, import("zod").TypeOf<import("zod").ZodObject<{
                    type: import("zod").ZodEnum<["text", "number", "boolean", "date"]>;
                    required: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    unique: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    email: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    url: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    min: import("zod").ZodOptional<import("zod").ZodNumber>;
                    max: import("zod").ZodOptional<import("zod").ZodNumber>;
                    oneOf: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
                    integer: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    positive: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    default: import("zod").ZodOptional<import("zod").ZodUnknown>;
                    label: import("zod").ZodOptional<import("zod").ZodString>;
                }, "strip", import("zod").ZodTypeAny, {
                    type: "number" | "boolean" | "text" | "date";
                    email?: boolean | undefined;
                    url?: boolean | undefined;
                    oneOf?: string[] | undefined;
                    min?: number | undefined;
                    max?: number | undefined;
                    integer?: boolean | undefined;
                    positive?: boolean | undefined;
                    required?: boolean | undefined;
                    unique?: boolean | undefined;
                    default?: unknown;
                    label?: string | undefined;
                }, {
                    type: "number" | "boolean" | "text" | "date";
                    email?: boolean | undefined;
                    url?: boolean | undefined;
                    oneOf?: string[] | undefined;
                    min?: number | undefined;
                    max?: number | undefined;
                    integer?: boolean | undefined;
                    positive?: boolean | undefined;
                    required?: boolean | undefined;
                    unique?: boolean | undefined;
                    default?: unknown;
                    label?: string | undefined;
                }>>>;
                relations?: Record<string, import("zod").TypeOf<import("zod").ZodObject<{
                    type: import("zod").ZodEnum<["hasOne", "hasMany", "belongsToMany"]>;
                    entity: import("zod").ZodString;
                }, "strip", import("zod").ZodTypeAny, {
                    type: "hasOne" | "hasMany" | "belongsToMany";
                    entity: string;
                }, {
                    type: "hasOne" | "hasMany" | "belongsToMany";
                    entity: string;
                }>>>;
                behaviors?: {
                    timestamps?: boolean;
                    softDelete?: boolean;
                    audit?: boolean;
                };
                protected?: boolean | "write" | "all";
            }) => Promise<import("./types").ToolResult>;
        };
        update_entity: {
            description: string;
            parameters: import("zod").ZodObject<{
                name: import("zod").ZodString;
                fields: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
                    type: import("zod").ZodOptional<import("zod").ZodEnum<["text", "number", "boolean", "date"]>>;
                    required: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodBoolean>>;
                    unique: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodBoolean>>;
                    email: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodBoolean>>;
                    url: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodBoolean>>;
                    min: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNumber>>;
                    max: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNumber>>;
                    oneOf: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>>;
                    integer: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodBoolean>>;
                    positive: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodBoolean>>;
                    default: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodUnknown>>;
                    label: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodString>>;
                }, "strip", import("zod").ZodTypeAny, {
                    email?: boolean | undefined;
                    url?: boolean | undefined;
                    oneOf?: string[] | undefined;
                    min?: number | undefined;
                    max?: number | undefined;
                    integer?: boolean | undefined;
                    positive?: boolean | undefined;
                    type?: "number" | "boolean" | "text" | "date" | undefined;
                    required?: boolean | undefined;
                    unique?: boolean | undefined;
                    default?: unknown;
                    label?: string | undefined;
                }, {
                    email?: boolean | undefined;
                    url?: boolean | undefined;
                    oneOf?: string[] | undefined;
                    min?: number | undefined;
                    max?: number | undefined;
                    integer?: boolean | undefined;
                    positive?: boolean | undefined;
                    type?: "number" | "boolean" | "text" | "date" | undefined;
                    required?: boolean | undefined;
                    unique?: boolean | undefined;
                    default?: unknown;
                    label?: string | undefined;
                }>>>;
                relations: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
                    type: import("zod").ZodEnum<["hasOne", "hasMany", "belongsToMany"]>;
                    entity: import("zod").ZodString;
                }, "strip", import("zod").ZodTypeAny, {
                    type: "hasOne" | "hasMany" | "belongsToMany";
                    entity: string;
                }, {
                    type: "hasOne" | "hasMany" | "belongsToMany";
                    entity: string;
                }>>>;
                behaviors: import("zod").ZodOptional<import("zod").ZodObject<{
                    timestamps: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    softDelete: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    audit: import("zod").ZodOptional<import("zod").ZodBoolean>;
                }, "strip", import("zod").ZodTypeAny, {
                    timestamps?: boolean | undefined;
                    softDelete?: boolean | undefined;
                    audit?: boolean | undefined;
                }, {
                    timestamps?: boolean | undefined;
                    softDelete?: boolean | undefined;
                    audit?: boolean | undefined;
                }>>;
                protected: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodBoolean, import("zod").ZodEnum<["write", "all"]>]>>;
            }, "strip", import("zod").ZodTypeAny, {
                name: string;
                fields?: Record<string, {
                    email?: boolean | undefined;
                    url?: boolean | undefined;
                    oneOf?: string[] | undefined;
                    min?: number | undefined;
                    max?: number | undefined;
                    integer?: boolean | undefined;
                    positive?: boolean | undefined;
                    type?: "number" | "boolean" | "text" | "date" | undefined;
                    required?: boolean | undefined;
                    unique?: boolean | undefined;
                    default?: unknown;
                    label?: string | undefined;
                }> | undefined;
                protected?: boolean | "write" | "all" | undefined;
                relations?: Record<string, {
                    type: "hasOne" | "hasMany" | "belongsToMany";
                    entity: string;
                }> | undefined;
                behaviors?: {
                    timestamps?: boolean | undefined;
                    softDelete?: boolean | undefined;
                    audit?: boolean | undefined;
                } | undefined;
            }, {
                name: string;
                fields?: Record<string, {
                    email?: boolean | undefined;
                    url?: boolean | undefined;
                    oneOf?: string[] | undefined;
                    min?: number | undefined;
                    max?: number | undefined;
                    integer?: boolean | undefined;
                    positive?: boolean | undefined;
                    type?: "number" | "boolean" | "text" | "date" | undefined;
                    required?: boolean | undefined;
                    unique?: boolean | undefined;
                    default?: unknown;
                    label?: string | undefined;
                }> | undefined;
                protected?: boolean | "write" | "all" | undefined;
                relations?: Record<string, {
                    type: "hasOne" | "hasMany" | "belongsToMany";
                    entity: string;
                }> | undefined;
                behaviors?: {
                    timestamps?: boolean | undefined;
                    softDelete?: boolean | undefined;
                    audit?: boolean | undefined;
                } | undefined;
            }>;
            execute: (params: {
                name: string;
                fields?: Record<string, Partial<import("zod").TypeOf<import("zod").ZodObject<{
                    type: import("zod").ZodEnum<["text", "number", "boolean", "date"]>;
                    required: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    unique: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    email: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    url: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    min: import("zod").ZodOptional<import("zod").ZodNumber>;
                    max: import("zod").ZodOptional<import("zod").ZodNumber>;
                    oneOf: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
                    integer: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    positive: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    default: import("zod").ZodOptional<import("zod").ZodUnknown>;
                    label: import("zod").ZodOptional<import("zod").ZodString>;
                }, "strip", import("zod").ZodTypeAny, {
                    type: "number" | "boolean" | "text" | "date";
                    email?: boolean | undefined;
                    url?: boolean | undefined;
                    oneOf?: string[] | undefined;
                    min?: number | undefined;
                    max?: number | undefined;
                    integer?: boolean | undefined;
                    positive?: boolean | undefined;
                    required?: boolean | undefined;
                    unique?: boolean | undefined;
                    default?: unknown;
                    label?: string | undefined;
                }, {
                    type: "number" | "boolean" | "text" | "date";
                    email?: boolean | undefined;
                    url?: boolean | undefined;
                    oneOf?: string[] | undefined;
                    min?: number | undefined;
                    max?: number | undefined;
                    integer?: boolean | undefined;
                    positive?: boolean | undefined;
                    required?: boolean | undefined;
                    unique?: boolean | undefined;
                    default?: unknown;
                    label?: string | undefined;
                }>>>>;
                relations?: Record<string, import("zod").TypeOf<import("zod").ZodObject<{
                    type: import("zod").ZodEnum<["hasOne", "hasMany", "belongsToMany"]>;
                    entity: import("zod").ZodString;
                }, "strip", import("zod").ZodTypeAny, {
                    type: "hasOne" | "hasMany" | "belongsToMany";
                    entity: string;
                }, {
                    type: "hasOne" | "hasMany" | "belongsToMany";
                    entity: string;
                }>>>;
                behaviors?: {
                    timestamps?: boolean;
                    softDelete?: boolean;
                    audit?: boolean;
                };
                protected?: boolean | "write" | "all";
            }) => Promise<import("./types").ToolResult>;
        };
        remove_entity: {
            description: string;
            parameters: import("zod").ZodObject<{
                name: import("zod").ZodString;
            }, "strip", import("zod").ZodTypeAny, {
                name: string;
            }, {
                name: string;
            }>;
            execute: (params: {
                name: string;
            }) => Promise<import("./types").ToolResult>;
        };
        set_database: {
            description: string;
            parameters: import("zod").ZodObject<{
                type: import("zod").ZodEnum<["sqlite", "postgres", "mysql"]>;
                file: import("zod").ZodOptional<import("zod").ZodString>;
                url: import("zod").ZodOptional<import("zod").ZodString>;
            }, "strip", import("zod").ZodTypeAny, {
                type: "sqlite" | "postgres" | "mysql";
                url?: string | undefined;
                file?: string | undefined;
            }, {
                type: "sqlite" | "postgres" | "mysql";
                url?: string | undefined;
                file?: string | undefined;
            }>;
            execute: (params: {
                type: "sqlite" | "postgres" | "mysql";
                file?: string;
                url?: string;
            }) => Promise<import("./types").ToolResult>;
        };
        set_auth: {
            description: string;
            parameters: import("zod").ZodObject<{
                enabled: import("zod").ZodBoolean;
                providers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<["credentials", "google", "github", "discord"]>, "many">>;
                sessionStrategy: import("zod").ZodOptional<import("zod").ZodEnum<["jwt", "database"]>>;
            }, "strip", import("zod").ZodTypeAny, {
                enabled: boolean;
                providers?: ("credentials" | "google" | "github" | "discord")[] | undefined;
                sessionStrategy?: "database" | "jwt" | undefined;
            }, {
                enabled: boolean;
                providers?: ("credentials" | "google" | "github" | "discord")[] | undefined;
                sessionStrategy?: "database" | "jwt" | undefined;
            }>;
            execute: (params: {
                enabled: boolean;
                providers?: ("credentials" | "google" | "github" | "discord")[];
                sessionStrategy?: "jwt" | "database";
            }) => Promise<import("./types").ToolResult>;
        };
        validate: {
            description: string;
            parameters: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
            execute: () => Promise<{
                success: boolean;
                message: string;
                errors: import("..").ValidationError[];
                warnings: import("..").ValidationError[];
            }>;
        };
        generate: {
            description: string;
            parameters: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
            execute: () => Promise<{
                success: boolean;
                message: string;
                files: string[];
                errors: string[] | undefined;
            }>;
        };
    };
};
//# sourceMappingURL=index.d.ts.map