@zapier/zapier-sdk 0.77.0 → 0.77.2

package/dist/plugins/codeSubstrate/triggerWorkflow/index.js

@@ -1,40 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { workflowIdResolver } from "../../../resolvers/workflowId";
-import { ZapierApiError } from "../../../types/errors";
-import { codeSubstrateDefaults } from "../shared";
-import { TriggerWorkflowLookupResponseSchema, TriggerWorkflowOptionsSchema, TriggerWorkflowResponseSchema, } from "./schemas";
-export const triggerWorkflowPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "triggerWorkflow",
-    type: "create",
-    itemType: "WorkflowRun",
-    inputSchema: TriggerWorkflowOptionsSchema,
-    outputSchema: TriggerWorkflowResponseSchema,
-    resolvers: { workflow: workflowIdResolver },
-    handler: async ({ sdk, options }) => {
-        // Two-step: get the workflow's trigger_url, then fire it. Both go
-        // through the authenticated api client.
-        const rawWorkflow = await sdk.context.api.get(`/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}`, {
-            authRequired: true,
-            resource: { type: "workflow", id: options.workflow },
-        });
-        const workflow = TriggerWorkflowLookupResponseSchema.parse(rawWorkflow);
-        // trigger_url is an absolute URL. Take only the token (its last path
-        // segment) and rebuild the gateway path so the call routes through the
-        // authenticated proxy, the same as every other call here.
-        const segments = new URL(workflow.trigger_url).pathname.split("/");
-        const triggerToken = segments[segments.length - 1];
-        if (!triggerToken) {
-            throw new ZapierApiError(`Workflow ${options.workflow} returned a malformed trigger_url`, { statusCode: 0, response: workflow.trigger_url });
-        }
-        // Fire the trigger through the authenticated api client and return its
-        // response directly, the same as every other code-substrate method.
-        // api.post throws the SDK's typed errors on non-2xx.
-        const raw = await sdk.context.api.post(`/durableworkflowzaps/api/v0/workflows/trigger/${encodeURIComponent(triggerToken)}`, options.input, {
-            authRequired: true,
-            resource: { type: "workflow", id: options.workflow },
-        });
-        const data = TriggerWorkflowResponseSchema.parse(raw);
-        return { data };
-    },
-}));

package/dist/plugins/codeSubstrate/triggerWorkflow/schemas.d.ts

@@ -1,16 +0,0 @@
-import { z } from "zod";
-export declare const TriggerWorkflowLookupResponseSchema: z.ZodObject<{
-    trigger_url: z.ZodString;
-}, z.core.$loose>;
-export declare const TriggerWorkflowOptionsSchema: z.ZodObject<{
-    workflow: z.ZodString;
-    input: z.ZodOptional<z.ZodUnknown>;
-}, z.core.$strip>;
-export type TriggerWorkflowOptions = z.infer<typeof TriggerWorkflowOptionsSchema>;
-export declare const TriggerWorkflowResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    workflow_id: z.ZodString;
-    created_at: z.ZodString;
-}, z.core.$strip>;
-export type TriggerWorkflowResponse = z.infer<typeof TriggerWorkflowResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/codeSubstrate/triggerWorkflow/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/triggerWorkflow/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,mCAAmC;;iBAIhC,CAAC;AAEjB,eAAO,MAAM,4BAA4B;;;iBAYtC,CAAC;AAEJ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;iBAIxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC"}

package/dist/plugins/codeSubstrate/triggerWorkflow/schemas.js

@@ -1,26 +0,0 @@
-import { z } from "zod";
-// Minimal shape we read off the GET /workflows/{id} response. The
-// workflow lookup happens inline (we only need the trigger_url), so we
-// pin a focused schema here rather than importing the full
-// GetWorkflowResponseSchema and coupling these plugins together.
-// trigger_url is required (matches getWorkflow / listWorkflows /
-// createWorkflow / updateWorkflow which all declare it z.string()).
-export const TriggerWorkflowLookupResponseSchema = z
-    .object({
-    trigger_url: z.string(),
-})
-    .passthrough();
-export const TriggerWorkflowOptionsSchema = z
-    .object({
-    workflow: z.string().uuid().describe("Durable workflow ID"),
-    input: z
-        .unknown()
-        .optional()
-        .describe("JSON payload delivered as the trigger body. Sent as `application/json`; omit to fire with an empty body."),
-})
-    .describe("Look up a workflow's trigger URL and fire it manually, as the authenticated account.");
-export const TriggerWorkflowResponseSchema = z.object({
-    id: z.string().describe("Trigger ID (UUID)"),
-    workflow_id: z.string().describe("The workflow that was triggered (UUID)"),
-    created_at: z.string().describe("When the trigger was received (ISO-8601)"),
-});

package/dist/plugins/codeSubstrate/updateWorkflow/index.d.ts

@@ -1,85 +0,0 @@
-export declare const updateWorkflowPlugin: (sdk: {
-    context: {
-        api: import("../../..").ApiClient;
-        resolveCredentials: () => Promise<string | {
-            clientId: string;
-            clientSecret: string;
-            type?: "client_credentials" | undefined;
-            baseUrl?: string | undefined;
-            scope?: string | undefined;
-        } | {
-            clientId: string;
-            type?: "pkce" | undefined;
-            baseUrl?: string | undefined;
-            scope?: string | undefined;
-        } | undefined>;
-    };
-} & {
-    context: import("../../eventEmission").EventEmissionContext;
-} & {
-    listWorkflows: (options?: ({
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        id: string;
-        name: string;
-        description: string | null;
-        trigger_url: string;
-        enabled: boolean;
-        is_private: boolean;
-        created_by_user_id: string | null;
-        current_version_id: string | null;
-        triggers: {
-            selected_api: string;
-            action: string;
-            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
-            authentication_id?: string | null | undefined;
-            params?: Record<string, unknown> | undefined;
-            error?: string | null | undefined;
-        }[];
-        created_at: string;
-        updated_at: string;
-        disabled_reason?: "trigger_claim_failed" | null | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listWorkflows: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    updateWorkflow: (options?: {
-        workflow: string;
-        name?: string | undefined;
-        description?: string | null | undefined;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            name: string;
-            description: string | null;
-            trigger_url: string;
-            enabled: boolean;
-            is_private: boolean;
-            created_by_user_id: string | null;
-            created_at: string;
-            updated_at: string;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            updateWorkflow: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type UpdateWorkflowPluginProvides = ReturnType<typeof updateWorkflowPlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/codeSubstrate/updateWorkflow/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/updateWorkflow/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkChC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,UAAU,CACnD,OAAO,oBAAoB,CAC5B,CAAC"}

package/dist/plugins/codeSubstrate/updateWorkflow/index.js

@@ -1,28 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { workflowIdResolver } from "../../../resolvers/workflowId";
-import { codeSubstrateDefaults } from "../shared";
-import { UpdateWorkflowOptionsSchema, UpdateWorkflowResponseSchema, } from "./schemas";
-export const updateWorkflowPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "updateWorkflow",
-    type: "update",
-    itemType: "Workflow",
-    inputSchema: UpdateWorkflowOptionsSchema,
-    outputSchema: UpdateWorkflowResponseSchema,
-    resolvers: { workflow: workflowIdResolver },
-    handler: async ({ sdk, options }) => {
-        const body = {};
-        if (options.name !== undefined) {
-            body.name = options.name;
-        }
-        if (options.description !== undefined) {
-            body.description = options.description;
-        }
-        const raw = await sdk.context.api.patch(`/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}`, body, {
-            authRequired: true,
-            resource: { type: "workflow", id: options.workflow },
-        });
-        const data = UpdateWorkflowResponseSchema.parse(raw);
-        return { data };
-    },
-}));

package/dist/plugins/codeSubstrate/updateWorkflow/schemas.d.ts

@@ -1,20 +0,0 @@
-import { z } from "zod";
-export declare const UpdateWorkflowOptionsSchema: z.ZodObject<{
-    workflow: z.ZodString;
-    name: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>;
-export type UpdateWorkflowOptions = z.infer<typeof UpdateWorkflowOptionsSchema>;
-export declare const UpdateWorkflowResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodNullable<z.ZodString>;
-    trigger_url: z.ZodString;
-    enabled: z.ZodBoolean;
-    is_private: z.ZodBoolean;
-    created_by_user_id: z.ZodNullable<z.ZodString>;
-    created_at: z.ZodString;
-    updated_at: z.ZodString;
-}, z.core.$strip>;
-export type UpdateWorkflowResponse = z.infer<typeof UpdateWorkflowResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/codeSubstrate/updateWorkflow/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/updateWorkflow/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,2BAA2B;;;;iBAY0B,CAAC;AAEnE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,4BAA4B;;;;;;;;;;iBA0BvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC"}

package/dist/plugins/codeSubstrate/updateWorkflow/schemas.js

@@ -1,37 +0,0 @@
-import { z } from "zod";
-export const UpdateWorkflowOptionsSchema = z
-    .object({
-    workflow: z.string().uuid().describe("Durable workflow ID"),
-    name: z.string().min(1).optional().describe("New name for the workflow"),
-    description: z
-        .string()
-        .nullish()
-        .describe("New description for the workflow (pass null to clear)"),
-})
-    .refine((data) => data.name !== undefined || data.description !== undefined, {
-    message: "Provide name or description (at least one is required)",
-})
-    .describe("Update a durable workflow's name and/or description");
-export const UpdateWorkflowResponseSchema = z.object({
-    id: z.string().describe("Workflow ID (UUID)"),
-    name: z.string().describe("Workflow name (post-update)"),
-    description: z
-        .string()
-        .nullable()
-        .describe("Workflow description, post-update (null if unset)"),
-    trigger_url: z
-        .string()
-        .describe("Public webhook URL that fires this workflow when POSTed to. Embeds a secret trigger token in the path — treat as sensitive."),
-    enabled: z
-        .boolean()
-        .describe("Whether the workflow currently accepts triggers"),
-    is_private: z
-        .boolean()
-        .describe("Whether the workflow is private to the creating user. False means account-visible."),
-    created_by_user_id: z
-        .string()
-        .nullable()
-        .describe("User ID of the workflow creator (null in legacy data)"),
-    created_at: z.string().describe("When the workflow was created (ISO-8601)"),
-    updated_at: z.string().describe("When this update was applied (ISO-8601)"),
-});

package/dist/plugins/connections/index.d.ts

@@ -1,19 +0,0 @@
-import type { ManifestPluginProvides } from "../manifest";
-export declare const connectionsPlugin: (sdk: {
-    context: Pick<ManifestPluginProvides["context"], "getManifestConnections">;
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    context: {
-        resolveConnection: (name: string) => Promise<{
-            connectionId: string | number;
-        } | undefined>;
-        getConnectionsMap: () => Promise<Record<string, {
-            connectionId: string | number;
-        }> | null>;
-    };
-};
-export type ConnectionsPluginProvides = ReturnType<typeof connectionsPlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/connections/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/connections/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE1D,eAAO,MAAM,iBAAiB;aAEjB,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,EAAE,wBAAwB,CAAC;;;;;;;kCAatC,MAAM;;;;;;;CAU7C,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/plugins/connections/index.js

@@ -1,21 +0,0 @@
-import { definePlugin } from "kitcore";
-export const connectionsPlugin = definePlugin((sdk) => {
-    let cachedMap;
-    async function loadConnectionsMap() {
-        if (cachedMap === undefined) {
-            cachedMap = (await sdk.context.getManifestConnections()) ?? null;
-        }
-        return cachedMap;
-    }
-    return {
-        context: {
-            resolveConnection: async (name) => {
-                const map = await loadConnectionsMap();
-                return map?.[name];
-            },
-            getConnectionsMap: async () => {
-                return loadConnectionsMap();
-            },
-        },
-    };
-});

package/dist/plugins/createClientCredentials/index.d.ts

@@ -1,32 +0,0 @@
-import type { ApiClient } from "../../api";
-export declare const createClientCredentialsPlugin: (sdk: {
-    context: {
-        api: ApiClient;
-    };
-} & {
-    context: import("../eventEmission").EventEmissionContext;
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    createClientCredentials: (options?: {
-        name: string;
-        allowedScopes: ("external" | "credentials")[];
-        policy?: Record<string, unknown> | undefined;
-    } | undefined) => Promise<{
-        data: {
-            client_id: string;
-            name: string;
-            client_secret: string;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            createClientCredentials: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type CreateClientCredentialsPluginProvides = ReturnType<typeof createClientCredentialsPlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/createClientCredentials/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/createClientCredentials/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAQ3C,eAAO,MAAM,6BAA6B;aACvB;QAAE,GAAG,EAAE,SAAS,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;CA4BpC,CAAC;AAEF,MAAM,MAAM,qCAAqC,GAAG,UAAU,CAC5D,OAAO,6BAA6B,CACrC,CAAC"}

package/dist/plugins/createClientCredentials/index.js

@@ -1,29 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPluginMethod } from "kitcore";
-import { CreateClientCredentialsSchema } from "./schemas";
-import { ClientCredentialsCreatedItemSchema } from "../../schemas/ClientCredentials";
-import { clientCredentialsCreatedItemFormatter } from "../../formatters/clientCredentials";
-import { clientCredentialsNameResolver } from "../../resolvers";
-export const createClientCredentialsPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    name: "createClientCredentials",
-    categories: ["client-credentials"],
-    type: "create",
-    itemType: "ClientCredentials",
-    inputSchema: CreateClientCredentialsSchema,
-    outputSchema: ClientCredentialsCreatedItemSchema,
-    formatter: clientCredentialsCreatedItemFormatter,
-    confirm: "create-secret",
-    resolvers: { name: clientCredentialsNameResolver },
-    handler: async ({ sdk, options }) => {
-        const { api } = sdk.context;
-        const response = await api.post("/api/v0/client-credentials", {
-            name: options.name,
-            allowed_scopes: options.allowedScopes,
-            ...(options.policy && { policy: options.policy }),
-        }, {
-            authRequired: true,
-            requiredScopes: ["credentials"],
-        });
-        return { data: response.data };
-    },
-}));

package/dist/plugins/createClientCredentials/schemas.d.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-import type { ClientCredentialsCreatedItem } from "@zapier/zapier-sdk-core/v0/schemas/client-credentials";
-export declare const CreateClientCredentialsSchema: z.ZodObject<{
-    name: z.ZodString;
-    allowedScopes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        external: "external";
-        credentials: "credentials";
-    }>>>;
-    policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-export type CreateClientCredentialsOptions = z.infer<typeof CreateClientCredentialsSchema>;
-export interface CreateClientCredentialsResult {
-    data: ClientCredentialsCreatedItem;
-}
-export interface CreateClientCredentialsSdkFunction {
-    createClientCredentials: (options: CreateClientCredentialsOptions) => Promise<CreateClientCredentialsResult>;
-}
-//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/createClientCredentials/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/createClientCredentials/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,uDAAuD,CAAC;AAE1G,eAAO,MAAM,6BAA6B;;;;;;;iBAc+B,CAAC;AAG1E,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,6BAA6B,CACrC,CAAC;AAGF,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,4BAA4B,CAAC;CACpC;AAGD,MAAM,WAAW,kCAAkC;IACjD,uBAAuB,EAAE,CACvB,OAAO,EAAE,8BAA8B,KACpC,OAAO,CAAC,6BAA6B,CAAC,CAAC;CAC7C"}

package/dist/plugins/createClientCredentials/schemas.js

@@ -1,16 +0,0 @@
-import { z } from "zod";
-import { CreateClientCredentialsRequestSchema } from "@zapier/zapier-sdk-core/v0/schemas/client-credentials";
-export const CreateClientCredentialsSchema = CreateClientCredentialsRequestSchema.omit({ allowed_scopes: true })
-    .extend({
-    allowedScopes: z
-        .array(z.enum(["credentials", "external"]))
-        .default(["external"])
-        .describe("Scopes to allow for these credentials"),
-    // Temporarily hidden while we finalise work to make approvals/policies customer-facing.
-    policy: z
-        .record(z.string(), z.unknown())
-        .optional()
-        .describe("Policy document (JSON) to attach to the credentials")
-        .meta({ deprecated: true }),
-})
-    .describe("Create new client credentials for the authenticated user");

package/dist/plugins/createConnection/index.d.ts

@@ -1,189 +0,0 @@
-import { type CreateConnectionItem } from "./schemas";
-export declare const createConnectionPlugin: (sdk: {
-    getConnectionStartUrl: (options?: {
-        app: string;
-    } | undefined) => Promise<{
-        data: import("../getConnectionStartUrl/schemas").GetConnectionStartUrlItem;
-    }>;
-} & {
-    context: {
-        meta: {
-            getConnectionStartUrl: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    waitForNewConnection: (options?: {
-        app: string;
-        startedAt: number;
-        timeoutMs?: number | undefined;
-        pollIntervalMs?: number | undefined;
-    } | undefined) => Promise<{
-        data: import("../waitForNewConnection/schemas").WaitForNewConnectionItem;
-    }>;
-} & {
-    context: {
-        meta: {
-            waitForNewConnection: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    getApp: (options?: {
-        app: string;
-    } | {
-        appKey: string;
-    } | undefined) => Promise<{
-        data: {
-            slug: string;
-            title: string;
-            key: string;
-            implementation_id: string;
-            description?: string | undefined;
-            is_hidden?: boolean | undefined;
-            auth_type?: string | undefined;
-            actions?: {
-                read?: number | undefined;
-                read_bulk?: number | undefined;
-                write?: number | undefined;
-                search?: number | undefined;
-                search_or_write?: number | undefined;
-                search_and_write?: number | undefined;
-                filter?: number | undefined;
-            } | undefined;
-            is_deprecated?: boolean | undefined;
-            is_beta?: boolean | undefined;
-            is_premium?: boolean | undefined;
-            age_in_days?: number | undefined;
-            banner?: string | undefined;
-            categories?: {
-                id: number;
-                name: string;
-                slug: string;
-            }[] | undefined;
-            images?: {
-                url_16x16?: string | undefined;
-                url_32x32?: string | undefined;
-                url_64x64?: string | undefined;
-                url_128x128?: string | undefined;
-            } | undefined;
-            popularity?: number | undefined;
-            has_filters?: boolean | undefined;
-            has_reads?: boolean | undefined;
-            has_searches?: boolean | undefined;
-            has_searches_or_writes?: boolean | undefined;
-            has_upfront_fields?: boolean | undefined;
-            has_writes?: boolean | undefined;
-            is_built_in?: boolean | undefined;
-            is_featured?: boolean | undefined;
-            is_invite?: boolean | undefined;
-            is_public?: boolean | undefined;
-            is_upcoming?: boolean | undefined;
-            visibility?: string | undefined;
-            primary_color?: string | undefined;
-            secondary_color?: string | undefined;
-            classification?: string | undefined;
-            api_docs_url?: string | undefined;
-            image?: string | undefined;
-            version?: string | undefined;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            getApp: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    listApps: (options?: ({
-        search?: string | undefined;
-        apps?: string[] | undefined;
-        appKeys?: string[] | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        slug: string;
-        title: string;
-        key: string;
-        implementation_id: string;
-        description?: string | undefined;
-        is_hidden?: boolean | undefined;
-        auth_type?: string | undefined;
-        actions?: {
-            read?: number | undefined;
-            read_bulk?: number | undefined;
-            write?: number | undefined;
-            search?: number | undefined;
-            search_or_write?: number | undefined;
-            search_and_write?: number | undefined;
-            filter?: number | undefined;
-        } | undefined;
-        is_deprecated?: boolean | undefined;
-        is_beta?: boolean | undefined;
-        is_premium?: boolean | undefined;
-        age_in_days?: number | undefined;
-        banner?: string | undefined;
-        categories?: {
-            id: number;
-            name: string;
-            slug: string;
-        }[] | undefined;
-        images?: {
-            url_16x16?: string | undefined;
-            url_32x32?: string | undefined;
-            url_64x64?: string | undefined;
-            url_128x128?: string | undefined;
-        } | undefined;
-        popularity?: number | undefined;
-        has_filters?: boolean | undefined;
-        has_reads?: boolean | undefined;
-        has_searches?: boolean | undefined;
-        has_searches_or_writes?: boolean | undefined;
-        has_upfront_fields?: boolean | undefined;
-        has_writes?: boolean | undefined;
-        is_built_in?: boolean | undefined;
-        is_featured?: boolean | undefined;
-        is_invite?: boolean | undefined;
-        is_public?: boolean | undefined;
-        is_upcoming?: boolean | undefined;
-        visibility?: string | undefined;
-        primary_color?: string | undefined;
-        secondary_color?: string | undefined;
-        classification?: string | undefined;
-        api_docs_url?: string | undefined;
-        image?: string | undefined;
-        version?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listApps: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: import("../eventEmission").EventEmissionContext;
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    createConnection: (options?: {
-        app: string;
-        browser: "never" | "auto" | "always";
-        timeoutMs?: number | undefined;
-        pollIntervalMs?: number | undefined;
-    } | undefined) => Promise<{
-        data: CreateConnectionItem;
-    }>;
-} & {
-    context: {
-        meta: {
-            createConnection: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type CreateConnectionPluginProvides = ReturnType<typeof createConnectionPlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/createConnection/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/createConnection/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,WAAW,CAAC;AAWnB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyBX,oBAAoB;;;;;;;;CAqD3C,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,UAAU,CACrD,OAAO,sBAAsB,CAC9B,CAAC"}