import type { ConnectionTypes } from "@cargo-ai/types";
import type { Schema } from "@cargo-ai/utils";
import { z } from "zod";
import type { ApiType, DateToString } from "../types.js";
import type { Storage } from "./storage.js";
export declare namespace Connection {
    type RateLimit = ApiType<ConnectionTypes.RateLimit>;
    type Connector = ApiType<ConnectionTypes.Connector>;
    type CustomIntegration = ApiType<ConnectionTypes.CustomIntegration>;
    type IntegrationFilterConjonction = ApiType<ConnectionTypes.IntegrationFilterConjonction>;
    type IntegrationFilterCondition = ApiType<ConnectionTypes.IntegrationFilterCondition>;
    type IntegrationFilterGroup = ApiType<ConnectionTypes.IntegrationFilterGroup>;
    type IntegrationFilter = ApiType<ConnectionTypes.IntegrationFilter>;
    type IntegrationSort = ApiType<ConnectionTypes.IntegrationSort>;
    type IntegrationAction = ApiType<ConnectionTypes.PostMigrationIntegrationAction>;
    type Integration = ApiType<ConnectionTypes.PostMigrationIntegration>;
    type IntegrationExtractor = ApiType<ConnectionTypes.PostMigrationIntegrationExtractor>;
    type IntegrationExtractorMode = ApiType<ConnectionTypes.IntegrationExtractorMode>;
    type IntegrationExtractorUnification = ApiType<ConnectionTypes.IntegrationExtractorUnification>;
    type IntegrationCategory = ApiType<ConnectionTypes.IntegrationCategory>;
    type IntegrationSubCategory = ApiType<ConnectionTypes.IntegrationSubCategory>;
    type IntegrationLanguageModel = ApiType<ConnectionTypes.IntegrationLanguageModel>;
    type IntegrationManifest = ApiType<ConnectionTypes.IntegrationManifest>;
    type NativeIntegrationActionCategory = ApiType<ConnectionTypes.NativeIntegrationActionCategory>;
    type NativeIntegrationAction = ApiType<ConnectionTypes.NativeIntegrationAction>;
    type NativeIntegration = ApiType<ConnectionTypes.NativeIntegration>;
    type NativeIntegrationAgent = ApiType<ConnectionTypes.NativeIntegrationAgent>;
    type NativeIntegrationExtractor = ApiType<ConnectionTypes.NativeIntegrationExtractor>;
    type NativeIntegrationExtractorCategory = ApiType<ConnectionTypes.NativeIntegrationExtractorCategory>;
    namespace Api {
        type ConnectorAutocompletePayload = DateToString<{
            connectorUuid: string;
            slug: string;
            value?: string;
            params: Record<string, any>;
            refresh?: boolean;
            variables?: Record<string, any>;
        }>;
        type ConnectorAutocompleteResult = {
            results: {
                label: string;
                value: string;
                parent?: string;
                description?: string;
                configOverride?: Record<string, any>;
            }[];
        };
        const zodConnectorAutocompleteErrorReason: z.ZodEnum<{
            connectorNotFound: "connectorNotFound";
            failedToGetIntegration: "failedToGetIntegration";
            failedToGetIntegrationAutocomplete: "failedToGetIntegrationAutocomplete";
        }>;
        type GetConnectorDynamicSchemaPayload = DateToString<{
            connectorUuid: string;
            slug: string;
            params: Record<string, any>;
        }>;
        type GetConnectorDynamicSchemaResult = {
            schema: Schema | undefined;
            uiSchema: Record<string, any> | undefined;
        };
        const zodGetConnectorDynamicSchemaErrorReason: z.ZodEnum<{
            connectorNotFound: "connectorNotFound";
            failedToGetIntegration: "failedToGetIntegration";
        }>;
        type GetConnectorLanguageModelsPayload = DateToString<{
            connectorUuid: string;
        }>;
        type GetConnectorLanguageModelsResult = {
            languageModels: IntegrationLanguageModel[];
        };
        const zodGetConnectorLanguageModelsErrorReason: z.ZodEnum<{
            connectorNotFound: "connectorNotFound";
            integrationNotFound: "integrationNotFound";
            languageModelsNotSupported: "languageModelsNotSupported";
            failedToGetLanguageModels: "failedToGetLanguageModels";
        }>;
        type CreateConnectorPayload = DateToString<{
            name: string;
            slug: string;
            integrationSlug: string;
            config?: Record<string, any>;
            rateLimit?: RateLimit;
            cacheTtlMilliseconds?: number;
        }>;
        type CreateConnectorResult = {
            connector: Connector;
            dataset: Storage.Dataset;
        };
        const zodCreateConnectorErrorReason: z.ZodEnum<{
            connectorNotFound: "connectorNotFound";
            duplicateSlug: "duplicateSlug";
            integrationNotFound: "integrationNotFound";
            integrationDeprecated: "integrationDeprecated";
            unknown: "unknown";
        }>;
        type GetConnectorPayload = DateToString<{
            uuid: string;
        }>;
        type GetConnectorResult = {
            connector: Connector;
        };
        const zodGetConnectorErrorReason: z.ZodEnum<{
            connectorNotFound: "connectorNotFound";
        }>;
        type ListConnectorsPayload = DateToString<{
            integrationSlug?: string;
        }>;
        type ListConnectorsResult = {
            connectors: Connector[];
        };
        type UpdateConnectorPayload = DateToString<{
            uuid: string;
            name?: string;
            isDefault?: boolean;
            config?: Record<string, any> | null;
            rateLimit?: RateLimit | null;
            cacheTtlMilliseconds?: number | null;
        }>;
        type UpdateConnectorResult = {
            connector: Connector;
        };
        const zodUpdateConnectorErrorReason: z.ZodEnum<{
            connectorNotFound: "connectorNotFound";
            integrationNotFound: "integrationNotFound";
        }>;
        type ConnectorExistsBySlugPayload = DateToString<{
            slug: string;
        }>;
        type ConnectorExistsBySlugResult = {
            exists: boolean;
        };
        type GetIntegrationPayload = DateToString<{
            slug: string;
        }>;
        type GetIntegrationResult = {
            integration: Integration;
        };
        const zodGetIntegrationErrorReason: z.ZodEnum<{
            integrationNotFound: "integrationNotFound";
        }>;
        type ListIntegrationsPayload = DateToString<{
            category?: string;
            slugs?: string[];
            search?: string;
            hasActions?: boolean;
            hasExtractors?: boolean;
            /**
             * Filters on deprecation the way `hasActions` filters on actions: omit it
             * and both are returned. A surface offering something new passes `false`;
             * omitting is right for the rest, since existing connectors and models
             * resolve their integration from this list.
             */
            isDeprecated?: boolean;
        }>;
        type ListIntegrationsResult = {
            integrations: Integration[];
        };
        type CompleteIntegrationOauthPayload = DateToString<{
            slug: string;
            connectorUuid?: string;
            params: Record<string, any>;
        }>;
        type CompleteIntegrationOauthResult = {
            value: string;
            extraValues?: Record<string, string>;
        };
        type InitiateIntegrationOauthPayload = DateToString<{
            slug: string;
            params?: Record<string, unknown>;
        }>;
        type InitiateIntegrationOauthResult = {
            consentUrl: string;
        };
        const zodInitiateIntegrationOauthErrorReason: z.ZodEnum<{
            integrationNotFound: "integrationNotFound";
            initiateOauthNotSupported: "initiateOauthNotSupported";
            failedToInitiateOauth: "failedToInitiateOauth";
        }>;
        const zodRemoveConnectorErrorReason: z.ZodEnum<{
            connectorNotFound: "connectorNotFound";
            connectorIsUsedInWorkflows: "connectorIsUsedInWorkflows";
            connectorIsUsedInModels: "connectorIsUsedInModels";
        }>;
        type GetNativeIntegrationResult = {
            nativeIntegration: NativeIntegration;
        };
        type CreateCustomIntegrationPayload = DateToString<{
            kind: "external";
            baseUrl: string;
        } | {
            kind: "worker";
            workerUuid: string;
        }>;
        type CreateCustomIntegrationResult = {
            customIntegration: CustomIntegration;
        };
        const zodCreateCustomIntegrationErrorReason: z.ZodEnum<{
            workerNotFound: "workerNotFound";
        }>;
        type ListCustomIntegrationsResult = {
            customIntegrations: CustomIntegration[];
        };
        type GetCustomIntegrationPayload = DateToString<{
            uuid: string;
        }>;
        type GetCustomIntegrationResult = {
            connector: CustomIntegration;
        };
        const zodGetCustomIntegrationErrorReason: z.ZodEnum<{
            customIntegrationNotFound: "customIntegrationNotFound";
        }>;
        type UpdateCustomIntegrationPayload = DateToString<{
            uuid: string;
            baseUrl?: string;
            workerUuid?: string;
        }>;
        type UpdateCustomIntegrationResult = {
            customIntegration: CustomIntegration;
        };
        const zodUpdateCustomIntegrationErrorReason: z.ZodEnum<{
            workerNotFound: "workerNotFound";
            customIntegrationNotFound: "customIntegrationNotFound";
            customIntegrationNotWorker: "customIntegrationNotWorker";
            customIntegrationNotExternal: "customIntegrationNotExternal";
        }>;
        const zodRemoveCustomIntegrationErrorReason: z.ZodEnum<{
            customIntegrationNotFound: "customIntegrationNotFound";
        }>;
    }
    const connectorsKeys: {
        all: (workspaceUuid: string) => readonly ["connectors", string];
        list: (workspaceUuid: string, payload: Api.ListConnectorsPayload) => readonly ["connectors", string, {
            integrationSlug?: string | undefined;
        }];
        get: (workspaceUuid: string, uuid: string) => readonly ["connectors", string, string];
        autocomplete: (workspaceUuid: string, payload: Api.ConnectorAutocompletePayload) => readonly ["connectors", string, "autocomplete", {
            connectorUuid: string;
            slug: string;
            value?: string | undefined;
            params: {
                [x: string]: any;
            };
            refresh?: boolean | undefined;
            variables?: {
                [x: string]: any;
            } | undefined;
        }];
        getDynamicSchema: (workspaceUuid: string, payload: Api.GetConnectorDynamicSchemaPayload) => readonly ["connectors", string, "getDynamicSchema", {
            connectorUuid: string;
            slug: string;
            params: {
                [x: string]: any;
            };
        }];
        getLanguageModels: (workspaceUuid: string, payload: Api.GetConnectorLanguageModelsPayload) => readonly ["connectors", string, "getLanguageModels", {
            connectorUuid: string;
        }];
    };
    const integrationsKeys: {
        list: (payload: Api.ListIntegrationsPayload) => readonly ["integrations", {
            category?: string | undefined;
            slugs?: string[] | undefined;
            search?: string | undefined;
            hasActions?: boolean | undefined;
            hasExtractors?: boolean | undefined;
            isDeprecated?: boolean | undefined;
        }];
        get: (slug: string) => readonly ["integrations", string];
        getDocumentation: (slug: string) => readonly ["integrations", "documentation", string];
    };
    const nativeIntegrationKeys: {
        get: () => readonly ["nativeIntegration"];
    };
    const customIntegrationsKeys: {
        all: (workspaceUuid: string) => readonly ["customIntegrations", string];
        list: (workspaceUuid: string) => readonly ["customIntegrations", string, "list"];
        get: (workspaceUuid: string, uuid: string) => readonly ["customIntegrations", string, string];
    };
}
//# sourceMappingURL=connection.d.ts.map