@cargo-ai/types 1.0.2 → 1.0.4

package/build/src/connection/connection.d.ts

@@ -0,0 +1,650 @@
+import type { Schema } from "@cargo-ai/utils";
+import type { Schema as JsonSchema } from "jsonschema";
+import type { z } from "zod/v4";
+import type { BillingTypes } from "../billing/billing.js";
+import type { OrchestrationTypes } from "../orchestration/index.js";
+export declare namespace ConnectionTypes {
+    export type RateLimit = {
+        unit: "day" | "hour" | "minute" | "second";
+        max: number;
+    };
+    export type EnrichedRateLimit = RateLimit & {
+        resourceId: string;
+        intervalMs: number;
+    };
+    export type Connector = {
+        uuid: string;
+        workspaceUuid: string;
+        userUuid: string;
+        name: string;
+        slug: string;
+        rateLimit: RateLimit | null;
+        cacheTtlMilliseconds: number | null;
+        integrationSlug: string;
+        playsCount: number;
+        toolsCount: number;
+        modelsCount: number;
+        createdAt: Date;
+        updatedAt: Date;
+        deletedAt: Date | null;
+    } & ({
+        useCredits: true;
+        config: null;
+    } | {
+        useCredits: false;
+        config: Record<string, any>;
+    });
+    export type CustomIntegration = {
+        uuid: string;
+        workspaceUuid: string;
+        slug: string;
+        baseUrl: string;
+        createdAt: Date;
+        updatedAt: Date;
+        deletedAt: Date | null;
+    };
+    export type IntegrationFilterConjonction = "or" | "and";
+    export type IntegrationFilterOperator = "lowerThan" | "lowerThanOrEquals" | "greaterThan" | "greaterThanOrEquals" | "is" | "isNot" | "contains" | "notContains" | "between" | "isNull" | "isNotNull" | "isEmpty" | "isNotEmpty";
+    export type IntegrationFilterCondition = {
+        propertyName: string;
+    } & ({
+        operator: Exclude<IntegrationFilterOperator, "isNull" | "isNotNull" | "isEmpty" | "isNotEmpty" | "between" | "is" | "isNot" | "contains" | "notContains">;
+        value: any;
+    } | {
+        operator: "is" | "isNot" | "contains" | "notContains";
+        values: any | any[];
+    } | {
+        operator: "isNull" | "isNotNull" | "isEmpty" | "isNotEmpty";
+    } | {
+        operator: "between";
+        value: any;
+        otherValue: any;
+    });
+    export type IntegrationFilterGroup = {
+        conditions: IntegrationFilterCondition[];
+        conjonction: IntegrationFilterConjonction;
+    };
+    export type IntegrationFilter = {
+        groups: IntegrationFilterGroup[];
+        conjonction: IntegrationFilterConjonction;
+    };
+    export type IntegrationSort = {
+        propertyName: string;
+        kind: "desc" | "asc";
+    }[];
+    export type IntegrationCategory = "engagement" | "marketing" | "sales" | "finance" | "analytics" | "freeform" | "success" | "support" | "enrichment" | "storage" | "custom";
+    export type IntegrationSubCategory = "websiteVisit" | "listBuilding" | "newHire" | "jobOffer" | "socialSelling" | "ecommerce" | "webScraper" | "developer";
+    export type IntegrationRateLimit = RateLimit & {
+        config: {
+            schema: Schema;
+        };
+    };
+    export type IntegrationRetry = {
+        maximumAttempts?: number;
+        initialInterval?: number;
+        backoffCoefficient?: number;
+    };
+    export type IntegrationCaching = {
+        isCompatible: boolean;
+    };
+    export type IntegrationActionChild = {
+        text: string;
+    };
+    export type IntegrationManifestAction = {
+        name: string;
+        description: string;
+        config: {
+            jsonSchema: JsonSchema;
+            uiSchema?: Record<string, any>;
+        };
+        credits?: {
+            rateLimits?: IntegrationRateLimit[];
+            costs: BillingTypes.CreditsCost[];
+        };
+        rateLimits?: IntegrationRateLimit[];
+        isSerialized?: boolean;
+        retry?: IntegrationRetry;
+        executing?: {
+            retry: IntegrationRetry;
+            withRateLimit: boolean;
+        };
+        caching?: IntegrationCaching;
+        children?: IntegrationActionChild[];
+    };
+    export type IntegrationExtractorModeFetch = {
+        kind: "fetch";
+        isIncremental: boolean;
+        isWatchable?: boolean;
+        minIntervalInSeconds?: number;
+        autoFetch?: boolean;
+        writeStrategy?: "append" | "overwrite";
+    };
+    export type IntegrationExtractorModeIngest = {
+        kind: "ingest";
+        autoIngest?: boolean;
+    };
+    export type IntegrationExtractorMode = IntegrationExtractorModeFetch | IntegrationExtractorModeIngest;
+    export type IntegrationExtractorUnificationReshaper = "urlExtractDomain" | "urlExtractLinkedinIdOrHandle" | "urlExtractCrunchbaseId" | "urlExtractTwitterHandle" | "urlExtractSalesNavigatorId";
+    export type IntegrationExtractorUnificationReference = "linkedinIdOrHandle" | "domain" | "email" | "crunchbaseId" | "twitterHandle" | "salesNavigatorId";
+    export type IntegrationExtractorUnificationColumn = {
+        slug: string;
+        reference: IntegrationExtractorUnificationReference;
+        reshaper?: IntegrationExtractorUnificationReshaper;
+    };
+    export type IntegrationExtractorUnificationType = "account" | "contact" | "accountEvent" | "contactEvent";
+    export type IntegrationExtractorUnification = {
+        config: {
+            jsonSchema: JsonSchema;
+        };
+        type: IntegrationExtractorUnificationType;
+        uniqueColumns: IntegrationExtractorUnificationColumn[];
+    };
+    export type IntegrationUnificationReference = IntegrationExtractorUnificationReference;
+    export type IntegrationUnificationReshaper = IntegrationExtractorUnificationReshaper;
+    export type IntegrationUnificationColumn = IntegrationExtractorUnificationColumn;
+    export type IntegrationUnificationType = IntegrationExtractorUnificationType;
+    export type IntegrationManifestExtractor = {
+        name: string;
+        description: string;
+        config: {
+            jsonSchema: JsonSchema;
+            uiSchema?: Record<string, any>;
+        };
+        credits?: {
+            rateLimits?: IntegrationRateLimit[];
+            costs: BillingTypes.CreditsCost[];
+        };
+        rateLimits?: IntegrationRateLimit[];
+        retry?: IntegrationRetry;
+        fetching?: {
+            retry: IntegrationRetry;
+            withRateLimit: boolean;
+        };
+        unifications?: IntegrationExtractorUnification[];
+        mode: IntegrationExtractorMode;
+        preview: "none" | "records" | "count";
+    };
+    export type IntegrationAgentTrigger<ConfigSchema extends Schema = Schema> = {
+        description: string;
+        config: {
+            schema: ConfigSchema;
+            uiSchema?: Record<string, any>;
+        };
+    };
+    export type IntegrationLanguageModel = {
+        name: string;
+        slug: string;
+        description: string;
+        contextWindowTokensLimit: number;
+        outputTokensLimit: number;
+        isReasoning: boolean;
+        credits?: {
+            cost: BillingTypes.CreditsCost;
+        };
+    };
+    export type IntegrationManifest = {
+        autocompletes: {
+            slug: string;
+            params: {
+                jsonSchema: JsonSchema;
+            };
+            cacheExpirationInSeconds?: number;
+        }[];
+        extractors: Record<string, IntegrationManifestExtractor>;
+        actions?: Record<string, IntegrationManifestAction>;
+    };
+    export type IntegrationConnectorData<Config> = {
+        uuid: string;
+        workspaceUuid: string;
+        config: Config;
+    };
+    export type IntegrationAgentData<TriggerConfig> = {
+        uuid: string;
+        workspaceUuid: string;
+        triggers: {
+            config: TriggerConfig;
+        }[];
+        name: string;
+        icon: {
+            color: "grey" | "green" | "purple" | "yellow" | "blue" | "red";
+        };
+    };
+    export type IntegrationAgentAttachment = {
+        s3Filename: string;
+        name: string;
+        contentType: string;
+    };
+    export type IntegrationAgentMessage<MessageMeta> = {
+        text: string;
+        userUuid?: string;
+        attachments: IntegrationAgentAttachment[];
+        meta: MessageMeta;
+    };
+    export type IntegrationAuthenticatePayload<ConnectorConfig = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+    };
+    export type IntegrationListUsersPayload<ConnectorConfig = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+    };
+    export type IntegrationAuthenticateResult = {
+        outcome: "success";
+        config?: Record<string, unknown>;
+    } | {
+        outcome: "error";
+        reason: "unauthenticated";
+        errorMessage?: string;
+    };
+    export type IntegrationActionExecutePayload<ConnectorConfig = unknown, Config = unknown, Meta = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        config: Config;
+        isDryExecution?: boolean;
+        meta?: Meta;
+    };
+    export type IntegrationActionExecuteResult<Meta = unknown> = {
+        outcome: "executed";
+        data?: Record<string, any>;
+        unitsCount?: number;
+        title: string;
+        iconUrl?: string;
+        childIndex?: number;
+    } | {
+        outcome: "executing";
+        data?: Record<string, any>;
+        meta?: Meta;
+    };
+    export type IntegrationActionValidatePayload<Config = unknown> = {
+        config: Config;
+    };
+    export type IntegrationActionValidateResult = {
+        outcome: "valid";
+    } | {
+        outcome: "notValid";
+        errorMessage: string;
+    };
+    export type IntegrationAutocompletePayload<ConnectorConfig = unknown, Slug = string, Params = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        slug: Slug;
+        value?: any;
+        params: Params;
+    };
+    export type IntegrationAutocompleteResult = {
+        results: {
+            label: string;
+            value: string;
+            parent?: string;
+            description?: string;
+            configOverride?: Record<string, any>;
+        }[];
+    };
+    export type IntegrationGetLanguageModelsPayload<ConnectorConfig = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+    };
+    export type IntegrationGetLanguageModelsResult = {
+        languageModels: IntegrationLanguageModel[];
+    };
+    export type IntegrationDynamicSchemaGetPayload<ConnectorConfig = unknown, Params = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        params: Params;
+    };
+    export type IntegrationDynamicSchemaGetResult = {
+        schema: Schema;
+        uiSchema?: Record<string, any>;
+    };
+    export type IntegrationCompleteOauthPayload<Params = unknown> = {
+        params: Params;
+    };
+    export type IntegrationCompleteOauthResult = {
+        value: string;
+    };
+    export type IntegrationColumnType = "string" | "number" | "object" | "array" | "date" | "boolean" | "vector" | "any";
+    export type IntegrationColumn = {
+        slug: string;
+        type: IntegrationColumnType;
+        label: string;
+        description?: string;
+    };
+    export type IntegrationExtractorCreatePayload<ConnectorConfig = unknown, Config = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        uuid: string;
+        config: Config;
+    };
+    export type IntegrationExtractorUpdatePayload<ConnectorConfig = unknown, Config = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        uuid: string;
+        config: Config;
+    };
+    export type IntegrationExtractorRemovePayload<ConnectorConfig = unknown, Config = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        uuid: string;
+        config: Config;
+    };
+    export type IntegrationExtractorPausePayload<ConnectorConfig = unknown, Config = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        uuid: string;
+        config: Config;
+    };
+    export type IntegrationExtractorResumePayload<ConnectorConfig = unknown, Config = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        uuid: string;
+        config: Config;
+    };
+    export type IntegrationExtractorFetchPayload<ConnectorConfig = unknown, Config = unknown, Meta = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        uuid: string;
+        config: Config;
+        meta?: Meta;
+        isDryFetch?: boolean;
+    };
+    export type IntegrationExtractorCountPayload<ConnectorConfig = unknown, Config = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        config: Config;
+    };
+    export type IntegrationExtractorCreateResult = {
+        outcome: "created";
+        extraConfig?: Record<string, unknown>;
+    } | {
+        outcome: "notCreated";
+        errorMessage: string;
+    };
+    export type IntegrationExtractorUpdateResult = {
+        outcome: "updated";
+        extraConfig?: Record<string, unknown>;
+    } | {
+        outcome: "notUpdated";
+        errorMessage: string;
+    };
+    export type IntegrationExtractorRecord = {
+        kind?: "removed" | "updated" | "added";
+        override: boolean;
+        record: Record<string, any>;
+    };
+    export type IntegrationExtractorFetchResult<Meta = unknown> = {
+        outcome: "fetched";
+        columns: IntegrationColumn[];
+        idColumnSlug: string;
+        titleColumnSlug: string;
+        timeColumnSlug?: string;
+        unitsCount?: number;
+        count?: number;
+        data: {
+            kind: "query";
+            query: string;
+            materialization: "table" | "view";
+        } | {
+            kind: "records";
+            records: IntegrationExtractorRecord[];
+            hasMore: boolean;
+            meta?: Meta;
+        };
+    } | {
+        outcome: "fetching";
+        columns: IntegrationColumn[];
+        idColumnSlug: string;
+        titleColumnSlug: string;
+        timeColumnSlug?: string;
+        data: {
+            kind: "query";
+        } | {
+            kind: "records";
+            meta?: Meta;
+        };
+    };
+    export type IntegrationExtractorCountResult = {
+        count: number;
+    };
+    export type IntegrationAgentFindChatPayload<ConnectorConfig = unknown, AgentTriggerConfig = unknown, Event = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        agent: IntegrationAgentData<AgentTriggerConfig>;
+        event: Event;
+    };
+    export type IntegrationAgentFindChatResult<Meta = unknown> = {
+        outcome: "found";
+        agentUuid: string;
+        slug: string;
+        meta: Meta;
+    } | {
+        outcome: "notFound";
+    };
+    export type IntegrationAgentRetrieveMessagesPayload<ConnectorConfig = unknown, AgentTriggerConfig = unknown, Event = unknown> = {
+        isNewChat: boolean;
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        agent: IntegrationAgentData<AgentTriggerConfig>;
+        event: Event;
+    };
+    export type IntegrationAgentRetrieveMessagesResult<MessageMeta = unknown> = {
+        outcome: "retrieved";
+        messages: IntegrationAgentMessage<MessageMeta>[];
+    } | {
+        outcome: "notRetrieved";
+    };
+    export type IntegrationAgentHandleMessagePayload<ConnectorConfig = unknown, AgentTriggerConfig = unknown, Meta = unknown, ChatMeta = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        agent: IntegrationAgentData<AgentTriggerConfig>;
+        meta: Meta | null;
+        chat: {
+            meta: ChatMeta;
+        };
+        text: string;
+        attachments: IntegrationAgentAttachment[];
+    };
+    export type IntegrationAgentHandleMessageResult<Meta = unknown> = {
+        meta: Meta;
+    };
+    export type IntegrationLanguageExtractorPayload<ConnectorConfig = unknown> = {
+        connector: IntegrationConnectorData<ConnectorConfig>;
+        slug: string;
+    };
+    export type IntegrationUser = {
+        id: string;
+        email: string;
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        profileImage?: string | undefined;
+    };
+    export type IntegrationAction<ConfigSchema extends Schema = Schema> = {
+        name?: string;
+        description?: string;
+        config: {
+            schema: ConfigSchema;
+            uiSchema?: Record<string, any>;
+        };
+        credits?: {
+            rateLimits?: IntegrationRateLimit[];
+            costs: BillingTypes.CreditsCost[];
+        };
+        rateLimits?: IntegrationRateLimit[];
+        isSerialized?: boolean;
+        retry?: IntegrationRetry;
+        executing?: {
+            retry: IntegrationRetry;
+            withRateLimit: boolean;
+        };
+        caching?: IntegrationCaching;
+        children?: IntegrationActionChild[];
+        execute: (payload: IntegrationActionExecutePayload<any, any, any>) => Promise<IntegrationActionExecuteResult<any>>;
+    };
+    export type IntegrationExtractor<ConfigSchema extends Schema = Schema> = {
+        name?: string;
+        description?: string;
+        config: {
+            schema: ConfigSchema;
+            uiSchema?: Record<string, any>;
+        };
+        credits?: {
+            rateLimits?: IntegrationRateLimit[];
+            costs: BillingTypes.CreditsCost[];
+        };
+        rateLimits?: IntegrationRateLimit[];
+        retry?: IntegrationRetry;
+        fetching?: {
+            retry: IntegrationRetry;
+            withRateLimit: boolean;
+        };
+        unifications?: IntegrationExtractorUnification[];
+        mode?: IntegrationExtractorMode;
+        preview?: "none" | "records" | "count";
+        fetch: (payload: IntegrationExtractorFetchPayload<any, any, any>) => Promise<IntegrationExtractorFetchResult<any>>;
+        count?: (payload: IntegrationExtractorCountPayload<any, any>) => Promise<IntegrationExtractorCountResult>;
+        create?: (payload: IntegrationExtractorCreatePayload<any, any>) => Promise<IntegrationExtractorCreateResult>;
+        update?: (payload: IntegrationExtractorUpdatePayload<any, any>) => Promise<IntegrationExtractorUpdateResult>;
+        remove?: (payload: IntegrationExtractorRemovePayload<any, any>) => Promise<void>;
+        pause?: (payload: IntegrationExtractorPausePayload<any, any>) => Promise<void>;
+        resume?: (payload: IntegrationExtractorResumePayload<any, any>) => Promise<void>;
+    };
+    export type IntegrationDynamicSchema = {
+        params: {
+            schema: Schema;
+        };
+        get: (payload: IntegrationDynamicSchemaGetPayload<any, any>) => Promise<IntegrationDynamicSchemaGetResult>;
+    };
+    export type IntegrationAgent<TriggerConfigSchema extends Schema = Schema> = {
+        trigger: IntegrationAgentTrigger<TriggerConfigSchema>;
+        findChat: (payload: IntegrationAgentFindChatPayload<any, any, any>) => Promise<IntegrationAgentFindChatResult<any>>;
+        retrieveMessages: (payload: IntegrationAgentRetrieveMessagesPayload<any, any, any>) => Promise<IntegrationAgentRetrieveMessagesResult<any>>;
+        handleMessage: (payload: IntegrationAgentHandleMessagePayload<any, any, any, any>) => Promise<IntegrationAgentHandleMessageResult<any>>;
+    };
+    export type IntegrationConnector<ConfigSchema extends Schema = Schema> = {
+        rateLimit?: RateLimit;
+        config: {
+            schema: ConfigSchema;
+            uiSchema?: Record<string, any>;
+        };
+        credits?: {
+            rateLimit?: RateLimit;
+            isCompatible?: boolean;
+            isLegacyCompatible?: boolean;
+        };
+        caching?: IntegrationCaching;
+    };
+    export type Integration = {
+        name: string;
+        description: string;
+        slug: string;
+        icon: string;
+        color: string;
+        url: string;
+        category: IntegrationCategory;
+        subCategories?: IntegrationSubCategory[];
+        documentationPath: string;
+        manifest: IntegrationManifest;
+        connector: IntegrationConnector;
+        authenticate: (payload: IntegrationAuthenticatePayload<any>) => Promise<IntegrationAuthenticateResult>;
+        actions: Record<string, IntegrationAction>;
+        extractors: Record<string, IntegrationExtractor>;
+        dynamicSchemas: Record<string, IntegrationDynamicSchema>;
+        listUsers?: (payload: IntegrationListUsersPayload<any>) => Promise<IntegrationUser[]>;
+        agent?: IntegrationAgent;
+        autocomplete?: (payload: IntegrationAutocompletePayload<any, any, any>) => Promise<IntegrationAutocompleteResult>;
+        completeOauth?: (payload: IntegrationCompleteOauthPayload<any>) => Promise<IntegrationCompleteOauthResult>;
+        getLanguageModels?: (payload: IntegrationGetLanguageModelsPayload<any>) => Promise<IntegrationGetLanguageModelsResult>;
+    };
+    export type PostMigrationIntegrationAction<ConfigSchema extends Schema = Schema> = Omit<IntegrationAction<ConfigSchema>, "name" | "description" | "config"> & Required<Pick<IntegrationAction<ConfigSchema>, "name" | "description">> & {
+        config: {
+            schema: ConfigSchema;
+            jsonSchema?: JsonSchema;
+            uiSchema?: Record<string, any>;
+        };
+    };
+    export type PostMigrationIntegrationExtractor<ConfigSchema extends Schema = Schema> = Omit<IntegrationExtractor<ConfigSchema>, "config"> & Required<Pick<IntegrationExtractor<ConfigSchema>, "name" | "description" | "mode" | "preview">> & {
+        config: {
+            schema: ConfigSchema;
+            jsonSchema?: JsonSchema;
+            uiSchema?: Record<string, any>;
+        };
+    };
+    export type PostMigrationIntegration = {
+        name: string;
+        description: string;
+        slug: string;
+        icon: string;
+        color: string;
+        url: string;
+        category: IntegrationCategory;
+        subCategories?: IntegrationSubCategory[];
+        documentationPath: string;
+        connector: IntegrationConnector;
+        authenticate: (payload: IntegrationAuthenticatePayload<any>) => Promise<IntegrationAuthenticateResult>;
+        actions: Record<string, PostMigrationIntegrationAction>;
+        extractors: Record<string, PostMigrationIntegrationExtractor>;
+        dynamicSchemas: Record<string, IntegrationDynamicSchema>;
+        listUsers?: (payload: IntegrationListUsersPayload<any>) => Promise<IntegrationUser[]>;
+        agent?: IntegrationAgent;
+        autocomplete?: (payload: IntegrationAutocompletePayload<any, any, any>) => Promise<IntegrationAutocompleteResult>;
+        completeOauth?: (payload: IntegrationCompleteOauthPayload<any>) => Promise<IntegrationCompleteOauthResult>;
+        autocompletes: {
+            slug: string;
+            params: {
+                jsonSchema: JsonSchema;
+            };
+            cacheExpirationInSeconds?: number;
+        }[];
+        getLanguageModels?: (payload: IntegrationGetLanguageModelsPayload<any>) => Promise<IntegrationGetLanguageModelsResult>;
+    };
+    export type NativeIntegrationCategory = "invisible" | "logic" | "storage" | "ai" | "sales" | "code";
+    type NativeIntegrationActionPayload<Config> = {
+        workspaceUuid: string;
+        workflowUuid: string;
+        batchUuid?: string;
+        modelUuid?: string;
+        recordId?: string;
+        releaseUuid?: string;
+        runUuid?: string;
+        nodeUuid: string;
+        parentAgentUuid?: string;
+        parentChatUuid?: string;
+        parentMessageUuid?: string;
+        isDryExecution?: boolean;
+        config: Config;
+        context: unknown;
+        groupContext: unknown;
+        nodes?: OrchestrationTypes.Node[];
+    };
+    type NativeIntegrationActionResult = {
+        outcome: "executed";
+        data: Record<string, unknown> | unknown[] | null;
+        title: string;
+        unitsCount?: number;
+        childIndex?: number;
+    } | {
+        outcome: "executingBatch";
+        batchUuid: string;
+        childIndex: 0;
+    } | {
+        outcome: "executingRun";
+        runUuid: string;
+        childIndex: 0;
+    } | {
+        outcome: "executingMessage";
+        userMessageUuid: string;
+        assistantMessageUuid: string;
+        childIndex: 0;
+    } | {
+        outcome: "notExecuted";
+        errorMessage: string;
+        retry: boolean;
+    } | {
+        outcome: "waiting";
+        timeoutMilliseconds: number;
+    };
+    export type NativeIntegrationAction<ConfigSchema extends Schema = Schema> = {
+        name: string;
+        description: string;
+        category: NativeIntegrationCategory;
+        icon: string;
+        isSerialized?: boolean;
+        config: {
+            schema: ConfigSchema;
+            uiSchema?: Record<string, any>;
+        };
+        credits?: {
+            costs: BillingTypes.CreditsCost[];
+        };
+        childrenCount: number;
+        execute: (payload: NativeIntegrationActionPayload<z.infer<ConfigSchema>>) => Promise<NativeIntegrationActionResult>;
+    };
+    export type NativeIntegration = {
+        actions: Record<string, NativeIntegrationAction>;
+    };
+    export {};
+}
+//# sourceMappingURL=connection.d.ts.map