import { type AiTypes } from "@cargo-ai/types";
import type { JsonSchema } from "@cargo-ai/utils";
import { z } from "zod";
import type { ApiType, DateToString } from "../types.js";
export declare namespace Ai {
    type Agent = ApiType<AiTypes.Agent>;
    type AgentIcon = ApiType<AiTypes.AgentIcon>;
    type AgentTrigger = ApiType<AiTypes.AgentTrigger>;
    type AgentTriggerConnector = ApiType<AiTypes.AgentTriggerConnector>;
    type AgentTriggerCron = ApiType<AiTypes.AgentTriggerCron>;
    type AgentTriggerNative = ApiType<AiTypes.AgentTriggerNative>;
    type Template = ApiType<AiTypes.Template>;
    type TemplateCategory = ApiType<AiTypes.TemplateCategory>;
    type TemplateKind = ApiType<AiTypes.TemplateKind>;
    type TemplateAgent = ApiType<AiTypes.TemplateAgent>;
    type TemplateMcpServer = ApiType<AiTypes.TemplateMcpServer>;
    type SuggestedAction = ApiType<AiTypes.SuggestedAction>;
    type Release = ApiType<AiTypes.Release>;
    type McpServer = ApiType<AiTypes.McpServer>;
    type McpClient = ApiType<AiTypes.McpClient>;
    type McpClientAuthentication = ApiType<AiTypes.McpClientAuthentication>;
    type Action = ApiType<AiTypes.Action>;
    type TemplateAction = ApiType<AiTypes.TemplateAction>;
    type Resource = ApiType<AiTypes.Resource>;
    type ModelResource = ApiType<AiTypes.ModelResource>;
    type FileResource = ApiType<AiTypes.FileResource>;
    type FileOrFolder = ApiType<AiTypes.FileOrFolder>;
    type ModelResourceTemplate = ApiType<AiTypes.ModelResourceTemplate>;
    type FileResourceTemplate = ApiType<AiTypes.FileResourceTemplate>;
    type ResourceTemplate = ApiType<AiTypes.ResourceTemplate>;
    type Capability = ApiType<AiTypes.Capability>;
    type Chat = ApiType<AiTypes.Chat>;
    type ChatTrigger = ApiType<AiTypes.ChatTrigger>;
    type Message = ApiType<AiTypes.Message>;
    type Output = ApiType<AiTypes.Output>;
    type Heartbeat = ApiType<AiTypes.Heartbeat>;
    type Evaluator = ApiType<AiTypes.Evaluator>;
    type HarnessSlug = ApiType<AiTypes.HarnessSlug>;
    type Repository = ApiType<AiTypes.Repository>;
    type Evaluation = ApiType<AiTypes.Evaluation>;
    type EvaluatedTool = ApiType<AiTypes.EvaluatedTool>;
    type EvaluatedToolInvocationOutput<T> = ApiType<AiTypes.EvaluatedToolInvocationOutput<T>>;
    type MessageMetadata = ApiType<AiTypes.MessageMetadata>;
    type Vote = ApiType<AiTypes.Vote>;
    type Document = ApiType<AiTypes.Document>;
    type DocumentKind = ApiType<AiTypes.DocumentKind>;
    type DocumentSuggestion = ApiType<AiTypes.DocumentSuggestion>;
    type Memory = ApiType<AiTypes.Memory>;
    const agentConfig: {
        jsonSchema: JsonSchema;
        uiSchema: Record<string, unknown>;
        flatJsonSchema: JsonSchema;
    };
    namespace Api {
        type ListTemplatesPayload = {
            hasDocumentation?: boolean;
            isPreset?: boolean;
            kinds?: TemplateKind[];
        };
        type ListTemplatesResult = {
            templates: Template[];
        };
        type GetAgentResult = {
            agent: Agent;
        };
        type CreateAgentPayload = DateToString<{
            name: string;
            description?: string;
            icon: AiTypes.AgentIcon;
            triggers?: (Omit<AiTypes.AgentTriggerCron, "temporalScheduleWorkflowId"> | AiTypes.AgentTriggerConnector | AiTypes.AgentTriggerNative)[];
            folderUuid?: string;
        }>;
        type CreateAgentResult = {
            agent: Agent;
        };
        const zodCreateAgentErrorReason: z.ZodEnum<{
            folderNotFound: "folderNotFound";
        }>;
        type AllAgentsResult = {
            agents: Agent[];
        };
        type UpdateAgentPayload = DateToString<{
            uuid: string;
            name?: string;
            icon?: AiTypes.AgentIcon;
            description?: string | null;
            triggers?: (Omit<AiTypes.AgentTriggerCron, "temporalScheduleWorkflowId"> | AiTypes.AgentTriggerConnector | AiTypes.AgentTriggerNative)[];
            folderUuid?: string | null;
            template?: {
                isAvailable: boolean;
                scope: "public" | "private";
            };
        }>;
        const zodUpdateAgentErrorReason: z.ZodEnum<{
            folderNotFound: "folderNotFound";
            agentNotFound: "agentNotFound";
        }>;
        type UpdateAgentResult = {
            agent: Agent;
        };
        const zodRemoveAgentErrorReason: z.ZodEnum<{
            agentNotFound: "agentNotFound";
        }>;
        type GetReleaseResult = {
            release: Release;
        };
        type ListReleasesPayload = DateToString<{
            agentUuid?: string;
            userUuid?: string;
            statuses?: AiTypes.ReleaseStatus[];
            limit?: number;
            offset?: number;
        }>;
        type ListReleasesResult = {
            releases: Release[];
        };
        type GetDraftReleasePayload = DateToString<{
            agentUuid: string;
        }>;
        type GetDraftReleaseResult = {
            release: Release;
        };
        type GetDeployedReleasePayload = DateToString<{
            agentUuid: string;
        }>;
        type GetDeployedReleaseResult = {
            release: Release;
        };
        const zodGetDeployedReleaseErrorReason: z.ZodEnum<{
            releaseNotFound: "releaseNotFound";
        }>;
        type UpdateDraftReleasePayload = DateToString<{
            agentUuid: string;
            parentUuid?: string;
            actions?: AiTypes.Action[];
            mcpClients?: AiTypes.McpClient[];
            resources?: AiTypes.Resource[];
            capabilities?: AiTypes.Capability[];
            suggestedActions?: AiTypes.SuggestedAction[];
            systemPrompt?: string;
            withReasoning?: boolean;
            temperature?: number;
            maxSteps?: number;
            integrationSlug?: string;
            connectorUuid?: string;
            languageModelSlug?: string;
            output?: AiTypes.Output | null;
            heartbeat?: AiTypes.Heartbeat | null;
            evaluator?: AiTypes.Evaluator | null;
            harnessSlug?: AiTypes.HarnessSlug | null;
            repository?: AiTypes.Repository | null;
            options?: {
                connectorUuidsByIntegrationSlug?: Record<string, string>;
                modelUuidsByIntegrationSlug?: Record<string, string>;
            };
        }>;
        const zodUpdateDraftReleaseErrorReason: z.ZodEnum<{
            agentNotFound: "agentNotFound";
            draftReleaseNotFound: "draftReleaseNotFound";
            invalidParent: "invalidParent";
            invalidConnector: "invalidConnector";
            failedToReconciliateAgentAiTools: "failedToReconciliateAgentAiTools";
        }>;
        type UpdateDraftReleaseResult = {
            release: Release;
        };
        type DeployDraftReleasePayload = DateToString<{
            agentUuid: string;
            actions: AiTypes.Action[];
            mcpClients: AiTypes.McpClient[];
            resources: AiTypes.Resource[];
            capabilities: AiTypes.Capability[];
            suggestedActions: AiTypes.SuggestedAction[];
            systemPrompt?: string;
            withReasoning?: boolean;
            temperature?: number;
            maxSteps?: number;
            integrationSlug?: string;
            connectorUuid?: string;
            languageModelSlug?: string;
            output?: AiTypes.Output | null;
            heartbeat?: AiTypes.Heartbeat | null;
            evaluator?: AiTypes.Evaluator | null;
            harnessSlug?: AiTypes.HarnessSlug | null;
            repository?: AiTypes.Repository | null;
            version?: string;
            description?: string;
            options?: {
                connectorUuidsByIntegrationSlug?: Record<string, string>;
                modelUuidsByIntegrationSlug?: Record<string, string>;
            };
        }>;
        const zodDeployDraftReleaseErrorReason: z.ZodEnum<{
            agentNotFound: "agentNotFound";
            draftReleaseNotFound: "draftReleaseNotFound";
            failedToReconciliateAgentAiTools: "failedToReconciliateAgentAiTools";
            invalidReleaseVersion: "invalidReleaseVersion";
            missingLanguageModel: "missingLanguageModel";
        }>;
        type DeployDraftReleaseResult = {
            release: Release;
        };
        type CreateChatPayload = DateToString<{
            uuid?: string;
            name?: string;
            agentUuid?: string;
            releaseUuid?: string;
            trigger: AiTypes.ChatTrigger;
            heartbeat?: AiTypes.Heartbeat;
            evaluator?: AiTypes.Evaluator;
            harnessSlug?: AiTypes.HarnessSlug;
            repository?: AiTypes.Repository;
        }>;
        type CreateChatResult = {
            chat: Chat;
        };
        type GetChatResult = {
            chat: Chat;
        };
        const zodGetChatErrorReason: z.ZodEnum<{
            chatNotFound: "chatNotFound";
        }>;
        type UpdateChatPayload = DateToString<{
            uuid: string;
            name?: string | null;
        }>;
        type UpdateChatResult = {
            chat: Chat;
        };
        const zodUpdateChatErrorReason: z.ZodEnum<{
            chatNotFound: "chatNotFound";
        }>;
        type RemoveChatPayload = DateToString<{
            uuid: string;
        }>;
        type RemoveChatResult = {
            outcome: "removed";
        };
        const zodRemoveChatErrorReason: z.ZodEnum<{
            chatNotFound: "chatNotFound";
        }>;
        type CloseChatResult = {
            chat: Chat;
        };
        const zodCloseChatErrorReason: z.ZodEnum<{
            chatNotFound: "chatNotFound";
        }>;
        type ListChatsPayload = DateToString<{
            agentUuid?: string;
            releaseUuid?: string;
            userUuid?: string;
            triggerType?: AiTypes.ChatTrigger["type"];
            messageStatuses?: AiTypes.MessageStatus[];
            name?: string;
            search?: string;
            createdAfter?: Date;
            createdBefore?: Date;
            limit?: number;
            offset?: number;
        }>;
        type ListChatsResult = {
            chats: Chat[];
        };
        type ListMessagesPayload = DateToString<{
            chatUuid: string;
            limit?: number;
            offset?: number;
        }>;
        type ListMessagesResult = {
            messages: Message[];
        };
        type CreateMessagePayload = DateToString<{
            chatUuid?: string;
            agentUuid?: string;
            releaseUuid?: string;
            parts: AiTypes.MessagePart[];
            actions?: AiTypes.Action[];
            resources?: AiTypes.Resource[];
            capabilities?: AiTypes.Capability[];
            mcpClients?: AiTypes.McpClient[];
            systemPrompt?: string;
            withReasoning?: boolean;
            temperature?: number;
            maxSteps?: number;
            integrationSlug?: string;
            connectorUuid?: string;
            languageModelSlug?: string;
            output?: AiTypes.Output;
            harnessSlug?: AiTypes.HarnessSlug;
            repository?: AiTypes.Repository;
        }>;
        type CreateMessageResult = {
            userMessage: Message;
            assistantMessage: Message;
        };
        const zodCreateMessageErrorReason: z.ZodEnum<{
            chatNotFound: "chatNotFound";
            lastMessageNotFinished: "lastMessageNotFinished";
            chatClosed: "chatClosed";
        }>;
        /**
         * What a client-run harness turn reports it spent. It states a cost, not a
         * credit count: credits are priced on the server, so a caller cannot set
         * its own bill.
         */
        type IngestMessagesUsage = {
            costUsd?: number;
            totalTokens?: number;
            inputTokens?: number;
            outputTokens?: number;
            cacheReadTokens?: number;
            cacheWriteTokens?: number;
            reasoningTokens?: number;
        };
        type IngestMessagesPayload = DateToString<{
            chatUuid: string;
            agentUuid?: string;
            connectorUuid: string;
            integrationSlug: string;
            languageModelSlug: string;
            userParts: AiTypes.MessagePart[];
            assistantParts: AiTypes.MessagePart[];
            usage?: IngestMessagesUsage;
            cancelled?: boolean;
            turnOwnerId?: string;
        }>;
        type IngestMessagesResult = {
            userMessage: Message;
            assistantMessage: Message;
        };
        const zodIngestMessagesErrorReason: z.ZodEnum<{
            chatNotFound: "chatNotFound";
            harnessNotFound: "harnessNotFound";
        }>;
        type MintProxyTokenResult = {
            token: string;
            expiresInSeconds: number;
            connectorUuid: string;
            integrationSlug: string;
            languageModelSlug: string;
        };
        const zodMintProxyTokenErrorReason: z.ZodEnum<{
            chatNotFound: "chatNotFound";
            lastMessageNotFinished: "lastMessageNotFinished";
            harnessNotFound: "harnessNotFound";
            notEnoughCredits: "notEnoughCredits";
            connectorNotFound: "connectorNotFound";
            languageModelNotFound: "languageModelNotFound";
        }>;
        type ClaimChatTurnPayload = {
            ownerId: string;
        };
        type ClaimChatTurnResult = {
            claimed: true;
        };
        const zodClaimChatTurnErrorReason: z.ZodEnum<{
            turnInFlight: "turnInFlight";
        }>;
        type ReleaseChatTurnPayload = {
            ownerId: string;
        };
        type ReleaseChatTurnResult = {
            released: true;
        };
        type GetMessageResult = {
            message: Message;
        };
        const zodGetMessageErrorReason: z.ZodEnum<{
            messageNotFound: "messageNotFound";
        }>;
        const zodRemoveMessageErrorReason: z.ZodEnum<{
            messageNotFound: "messageNotFound";
            messageNotUser: "messageNotUser";
        }>;
        type CancelMessagesPayload = {
            uuids: string[];
        };
        type UpsertVotePayload = DateToString<{
            chatUuid: string;
            messageUuid: string;
            isUpvoted: boolean;
        }>;
        type UpsertVoteResult = {
            vote: Vote;
        };
        type ListVotesPayload = DateToString<{
            chatUuid: string;
        }>;
        type ListVotesResult = {
            votes: Vote[];
        };
        type GetDocumentResult = {
            document: Document;
        };
        type ListDocumentsPayload = DateToString<{
            uuid: string;
            limit?: number;
            offset?: number;
        }>;
        type ListDocumentsResult = {
            documents: Document[];
        };
        type CreateDocumentPayload = DateToString<{
            uuid: string;
            kind: AiTypes.DocumentKind;
            title: string;
            content: string;
        }>;
        type CreateDocumentResult = {
            document: Document;
        };
        type ResetDocumentPayload = DateToString<{
            uuid: string;
            createdAt: Date;
        }>;
        type ResetDocumentResult = {
            document: Document;
        };
        type GetMcpServerResult = {
            mcpServer: McpServer;
        };
        type CreateMcpServerPayload = DateToString<{
            name: string;
            description?: string;
            actions: AiTypes.Action[];
            resources: AiTypes.Resource[];
            capabilities?: AiTypes.Capability[];
            folderUuid?: string;
        }>;
        type CreateMcpServerResult = {
            mcpServer: McpServer;
        };
        type AllMcpServersResult = {
            mcpServers: McpServer[];
        };
        type UpdateMcpServerPayload = DateToString<{
            uuid: string;
            name?: string;
            description?: string | null;
            actions?: AiTypes.Action[];
            resources?: AiTypes.Resource[];
            capabilities?: AiTypes.Capability[];
            folderUuid?: string | null;
        }>;
        const zodUpdateMcpServerErrorReason: z.ZodEnum<{
            folderNotFound: "folderNotFound";
            mcpServerNotFound: "mcpServerNotFound";
            mcpServerIsReadOnly: "mcpServerIsReadOnly";
        }>;
        type UpdateMcpServerResult = {
            mcpServer: McpServer;
        };
        type ConnectMcpClientPayload = DateToString<{
            mcpClient: AiTypes.McpClient;
        }>;
        type ConnectMcpClientResult = {
            tools: {
                slug: string;
                description?: string;
                config: {
                    jsonSchema: JsonSchema;
                };
            }[];
        };
        const zodRemoveMcpServerErrorReason: z.ZodEnum<{
            mcpServerNotFound: "mcpServerNotFound";
            mcpServerIsReadOnly: "mcpServerIsReadOnly";
        }>;
        type OptimizePromptPayload = DateToString<{
            prompt: string;
        }>;
        type OptimizePromptResult = {
            prompt: string;
        };
        type EvaluatePromptPayload = DateToString<{
            prompt: string;
            actions: AiTypes.Action[];
            resources: AiTypes.Resource[];
            capabilities: AiTypes.Capability[];
        }>;
        type EvaluatePromptResult = {
            prompt?: string;
            errorMessage?: string;
        };
        type GenerateJsonSchemaFromPromptPayload = DateToString<{
            prompt: string;
            systemPrompt?: string;
        }>;
        type GenerateJsonSchemaFromPromptResult = {
            jsonSchema: Record<string, unknown>;
        };
        type ListMemoriesPayload = {
            scope: "user";
        } | {
            scope: "agent";
            agentUuid: string;
        };
        type ListMemoriesResult = {
            memories: Memory[];
        };
        type RemoveMemoryPayload = DateToString<{
            mem0Id: string;
        } & ({
            scope: "user";
        } | {
            scope: "agent";
            agentUuid: string;
        })>;
        const zodRemoveMemoryErrorReason: z.ZodEnum<{
            memoryNotFound: "memoryNotFound";
        }>;
        type UpdateMemoryPayload = DateToString<{
            mem0Id: string;
            content: string;
        } & ({
            scope: "user";
        } | {
            scope: "agent";
            agentUuid: string;
        })>;
        const zodUpdateMemoryErrorReason: z.ZodEnum<{
            memoryNotFound: "memoryNotFound";
        }>;
        type GenerateSuggestedActionsPayload = DateToString<{
            messageUuid?: string;
            systemPrompt?: string;
            contextPrompt?: string;
            agentUuid?: string;
            actions?: AiTypes.Action[];
            resources?: AiTypes.Resource[];
            capabilities?: AiTypes.Capability[];
            cacheKey?: string;
        }>;
        type GenerateSuggestedActionsResult = {
            suggestedActions: AiTypes.SuggestedAction[];
        };
        type GetTemplatePayload = {
            slug: string;
        };
        type GetTemplateResult = {
            template: Template;
        };
        const zodGetTemplateErrorReason: z.ZodEnum<{
            templateNotFound: "templateNotFound";
        }>;
    }
    const templateKeys: {
        all: () => readonly ["templates"];
        get: (slug: string) => readonly ["templates", string];
        list: (payload: Api.ListTemplatesPayload) => readonly ["templates", Api.ListTemplatesPayload];
    };
    const mcpServerKeys: {
        all: (workspaceUuid: string) => readonly ["batches", string];
    };
    const agentKeys: {
        all: (workspaceUuid: string) => readonly ["agents", string];
    };
    const chatKeys: {
        all: (workspaceUuid: string) => readonly ["chats", string];
        get: (workspaceUuid: string, uuid: string) => readonly ["chats", string, string];
        list: (workspaceUuid: string, payload: Api.ListChatsPayload) => readonly ["chats", string, {
            agentUuid?: string | undefined;
            releaseUuid?: string | undefined;
            userUuid?: string | undefined;
            triggerType?: "draft" | "chat" | "connector" | "web_extension" | "app" | "cli" | "workflow" | "schedule" | "native" | undefined;
            messageStatuses?: AiTypes.MessageStatus[] | undefined;
            name?: string | undefined;
            search?: string | undefined;
            createdAfter?: string | undefined;
            createdBefore?: string | undefined;
            limit?: number | undefined;
            offset?: number | undefined;
        }];
    };
    const messageKeys: {
        all: (workspaceUuid: string) => readonly ["messages", string];
        get: (workspaceUuid: string, uuid: string) => readonly ["messages", string, string];
        list: (workspaceUuid: string, payload: Api.ListMessagesPayload) => readonly ["messages", string, {
            chatUuid: string;
            limit?: number | undefined;
            offset?: number | undefined;
        }];
    };
    const memoryKeys: {
        all: (workspaceUuid: string) => readonly ["memories", string];
        list: (workspaceUuid: string, payload: Api.ListMemoriesPayload) => readonly ["memories", string, Api.ListMemoriesPayload];
    };
    const voteKeys: {
        all: (workspaceUuid: string) => readonly ["votes", string];
        list: (workspaceUuid: string, payload: Api.ListVotesPayload) => readonly ["votes", string, {
            chatUuid: string;
        }];
    };
    const releaseKeys: {
        all: (workspaceUuid: string) => readonly ["releases", string];
        get: (workspaceUuid: string, uuid: string) => readonly ["releases", string, string];
        getDraft: (workspaceUuid: string, workflowUuid: string) => readonly ["releases", string, string];
        list: (workspaceUuid: string, payload: Api.ListReleasesPayload) => readonly ["releases", string, {
            agentUuid?: string | undefined;
            userUuid?: string | undefined;
            statuses?: AiTypes.ReleaseStatus[] | undefined;
            limit?: number | undefined;
            offset?: number | undefined;
        }];
    };
    const documentKeys: {
        all: (workspaceUuid: string) => readonly ["documents", string];
        get: (workspaceUuid: string, uuid: string) => readonly ["documents", string, string];
        list: (workspaceUuid: string, payload: Api.ListDocumentsPayload) => readonly ["documents", string, {
            uuid: string;
            limit?: number | undefined;
            offset?: number | undefined;
        }];
    };
}
//# sourceMappingURL=ai.d.ts.map