@zapier/zapier-sdk 0.77.0 → 0.77.2

package/dist/plugins/capabilities/index.js

@@ -1,75 +0,0 @@
-import { definePlugin } from "kitcore";
-import { ZapierConfigurationError } from "../../types/errors";
-function toDescription(key) {
-    // "canDeleteTables" -> "To delete tables"
-    const words = key
-        .replace(/^can/, "")
-        .replace(/([A-Z])/g, " $1")
-        .trim()
-        .toLowerCase();
-    return `To ${words}`;
-}
-function toEnvVar(key) {
-    return "ZAPIER_" + key.replace(/([A-Z])/g, "_$1").toUpperCase();
-}
-function toCliFlag(key) {
-    return "--" + key.replace(/([A-Z])/g, "-$1").toLowerCase();
-}
-export function buildCapabilityMessage(key) {
-    return [
-        `${toDescription(key)}, use ${toCliFlag(key)} in the CLI,`,
-        `set ${key}: true in SDK options or .zapierrc,`,
-        `or set ${toEnvVar(key)}=true.`,
-    ].join(" ");
-}
-const GATED_FLAGS = [
-    "canIncludeSharedConnections",
-    "canIncludeSharedTables",
-    "canDeleteTables",
-];
-function isEnabledByEnv(key) {
-    const value = globalThis.process?.env?.[toEnvVar(key)];
-    if (value === undefined)
-        return undefined;
-    if (value === "true" || value === "1")
-        return true;
-    if (value === "false" || value === "0")
-        return false;
-    return undefined;
-}
-export const capabilitiesPlugin = definePlugin((sdk) => {
-    const options = sdk.context.options ?? {};
-    let cached;
-    /**
-     * Resolve each gated flag to true/false by checking (in priority order):
-     * SDK options, environment variables, and .zapierrc manifest.
-     * Results are cached after the first call.
-     */
-    async function resolveFlags() {
-        if (cached)
-            return cached;
-        const manifest = await sdk.context.getResolvedManifest();
-        cached = {};
-        for (const flag of GATED_FLAGS) {
-            cached[flag] = Boolean(options[flag] ??
-                isEnabledByEnv(flag) ??
-                manifest?.[flag]);
-        }
-        return cached;
-    }
-    return {
-        context: {
-            checkCapability: async (key) => {
-                const flags = await resolveFlags();
-                if (flags[key])
-                    return;
-                throw new ZapierConfigurationError(buildCapabilityMessage(key) +
-                    " (If you are an AI agent, you MUST NOT retry. Ask the user if they want to enable this.)", { configType: key });
-            },
-            hasCapability: async (key) => {
-                const flags = await resolveFlags();
-                return flags[key];
-            },
-        },
-    };
-});

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

@@ -1,70 +0,0 @@
-export declare const cancelDurableRunPlugin: (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;
-} & {
-    listDurableRuns: (options?: ({
-        pageSize?: number | undefined;
-        cursor?: string | undefined;
-        maxItems?: number | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        id: string;
-        status: string;
-        input: unknown;
-        output: unknown;
-        error: {
-            [x: string]: unknown;
-            code: string;
-            message: string;
-        } | null;
-        execution_id: string | null;
-        is_private: boolean;
-        created_at: string;
-        updated_at: string;
-    }>;
-} & {
-    context: {
-        meta: {
-            listDurableRuns: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    cancelDurableRun: (options?: {
-        run: string;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            status: "cancelled";
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            cancelDurableRun: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type CancelDurableRunPluginProvides = ReturnType<typeof cancelDurableRunPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/cancelDurableRun/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkClC,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,UAAU,CACrD,OAAO,sBAAsB,CAC9B,CAAC"}

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

@@ -1,28 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { durableRunIdResolver } from "../../../resolvers/durableRunId";
-import { codeSubstrateDefaults } from "../shared";
-import { CancelDurableRunOptionsSchema, CancelDurableRunResponseSchema, } from "./schemas";
-export const cancelDurableRunPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "cancelDurableRun",
-    type: "update",
-    itemType: "DurableRun",
-    inputSchema: CancelDurableRunOptionsSchema,
-    outputSchema: CancelDurableRunResponseSchema,
-    resolvers: { run: durableRunIdResolver },
-    handler: async ({ sdk, options }) => {
-        // Backend returns 204 on success. 404 (run missing) and 409 (run
-        // already terminal) propagate as their respective ZapierErrors so
-        // callers can distinguish — we don't soft-fold them into a status
-        // enum the way deleteWorkflow does, because cancelling an
-        // already-terminal run is a meaningfully different outcome that
-        // callers may want to surface to users.
-        await sdk.context.api.post(`/sdkdurableapi/api/v0/runs/${encodeURIComponent(options.run)}/cancel`, undefined, {
-            authRequired: true,
-            resource: { type: "run", id: options.run },
-        });
-        return {
-            data: { id: options.run, status: "cancelled" },
-        };
-    },
-}));

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

@@ -1,11 +0,0 @@
-import { z } from "zod";
-export declare const CancelDurableRunOptionsSchema: z.ZodObject<{
-    run: z.ZodString;
-}, z.core.$strip>;
-export type CancelDurableRunOptions = z.infer<typeof CancelDurableRunOptionsSchema>;
-export declare const CancelDurableRunResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    status: z.ZodLiteral<"cancelled">;
-}, z.core.$strip>;
-export type CancelDurableRunResponse = z.infer<typeof CancelDurableRunResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/cancelDurableRun/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,6BAA6B;;iBAMvC,CAAC;AAEJ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;iBAOzC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC"}

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

@@ -1,12 +0,0 @@
-import { z } from "zod";
-export const CancelDurableRunOptionsSchema = z
-    .object({
-    run: z.string().uuid().describe("Durable run ID"),
-})
-    .describe("Cancel a run-once durable run in initialized or started status. Returns 409 if the run is already terminal.");
-export const CancelDurableRunResponseSchema = z.object({
-    id: z.string().describe("Run ID that was targeted"),
-    status: z
-        .literal("cancelled")
-        .describe("Always `cancelled` on a successful call. Synthesized client-side — the backend returns 204; callers needing the run's full state should follow up with getDurableRun."),
-});

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

@@ -1,49 +0,0 @@
-export declare const createWorkflowPlugin: (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;
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    createWorkflow: (options?: {
-        name: string;
-        description?: string | undefined;
-        private?: boolean | undefined;
-        is_private?: boolean | 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;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            createWorkflow: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type CreateWorkflowPluginProvides = ReturnType<typeof createWorkflowPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,24 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { codeSubstrateDefaults } from "../shared";
-import { CreateWorkflowOptionsSchema, CreateWorkflowResponseSchema, } from "./schemas";
-export const createWorkflowPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "createWorkflow",
-    type: "create",
-    itemType: "Workflow",
-    inputSchema: CreateWorkflowOptionsSchema,
-    outputSchema: CreateWorkflowResponseSchema,
-    handler: async ({ sdk, options }) => {
-        const body = { name: options.name };
-        if (options.description !== undefined) {
-            body.description = options.description;
-        }
-        const isPrivate = options.private ?? options.is_private;
-        if (isPrivate !== undefined) {
-            body.is_private = isPrivate;
-        }
-        const raw = await sdk.context.api.post("/durableworkflowzaps/api/v0/workflows", body, { authRequired: true });
-        const data = CreateWorkflowResponseSchema.parse(raw);
-        return { data };
-    },
-}));

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

@@ -1,20 +0,0 @@
-import { z } from "zod";
-export declare const CreateWorkflowOptionsSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    private: z.ZodOptional<z.ZodBoolean>;
-    is_private: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type CreateWorkflowOptions = z.infer<typeof CreateWorkflowOptionsSchema>;
-export declare const CreateWorkflowResponseSchema: 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;
-}, z.core.$strip>;
-export type CreateWorkflowResponse = z.infer<typeof CreateWorkflowResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

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

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

@@ -1,42 +0,0 @@
-import { z } from "zod";
-export const CreateWorkflowOptionsSchema = z
-    .object({
-    name: z.string().min(1).describe("Workflow name"),
-    description: z
-        .string()
-        .optional()
-        .describe("Optional description for the workflow"),
-    private: z
-        .boolean()
-        .optional()
-        .describe("If true, only the creating user can see or manage this workflow. Defaults to false (account-visible)."),
-    /** @deprecated Use `private` instead. */
-    is_private: z
-        .boolean()
-        .optional()
-        .describe("If true, only the creating user can see or manage this workflow. Defaults to false (account-visible).")
-        .meta({ deprecated: true }),
-})
-    .describe("Create a durable workflow container. Starts disabled with no version; publish a version to add code.");
-export const CreateWorkflowResponseSchema = z.object({
-    id: z.string().describe("Workflow ID (UUID)"),
-    name: z.string().describe("Workflow name"),
-    description: z
-        .string()
-        .nullable()
-        .describe("Workflow description (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. Always false on a new workflow until enabled."),
-    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)"),
-});

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

@@ -1,75 +0,0 @@
-export declare const deleteWorkflowPlugin: (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>;
-    };
-}) => {
-    deleteWorkflow: (options?: {
-        workflow: string;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            deleteWorkflow: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type DeleteWorkflowPluginProvides = ReturnType<typeof deleteWorkflowPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/deleteWorkflow/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/deleteWorkflow/index.js

@@ -1,28 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { workflowIdResolver } from "../../../resolvers/workflowId";
-import { codeSubstrateDefaults } from "../shared";
-import { DeleteWorkflowOptionsSchema, DeleteWorkflowResponseSchema, } from "./schemas";
-export const deleteWorkflowPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "deleteWorkflow",
-    type: "delete",
-    itemType: "Workflow",
-    confirm: "delete",
-    inputSchema: DeleteWorkflowOptionsSchema,
-    outputSchema: DeleteWorkflowResponseSchema,
-    resolvers: { workflow: workflowIdResolver },
-    handler: async ({ sdk, options }) => {
-        // Backend returns 204 on success. 404 (workflow missing) propagates
-        // as ZapierNotFoundError. We intentionally don't fold 404 into a
-        // synthesized "already-deleted" outcome — the resource hint is
-        // caller-supplied (the SDK tagged the request itself), so an
-        // upstream / proxy / gateway 404 would falsely tell the caller
-        // the workflow was deleted. Callers wanting idempotency can
-        // catch ZapierNotFoundError themselves.
-        await sdk.context.api.delete(`/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}`, undefined, {
-            authRequired: true,
-            resource: { type: "workflow", id: options.workflow },
-        });
-        return { data: { id: options.workflow } };
-    },
-}));

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

@@ -1,10 +0,0 @@
-import { z } from "zod";
-export declare const DeleteWorkflowOptionsSchema: z.ZodObject<{
-    workflow: z.ZodString;
-}, z.core.$strip>;
-export type DeleteWorkflowOptions = z.infer<typeof DeleteWorkflowOptionsSchema>;
-export declare const DeleteWorkflowResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-}, z.core.$strip>;
-export type DeleteWorkflowResponse = z.infer<typeof DeleteWorkflowResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

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

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

@@ -1,13 +0,0 @@
-import { z } from "zod";
-export const DeleteWorkflowOptionsSchema = z
-    .object({
-    workflow: z.string().uuid().describe("Durable workflow ID"),
-})
-    .describe("Delete a durable workflow. Throws `ZapierNotFoundError` if the workflow doesn't exist; callers wanting idempotency should catch that themselves.");
-// Synthesized client-side — the backend returns 204 with no body. We
-// echo the targeted workflow id so callers don't lose the handle across
-// the call. Wired as `outputSchema` so the framework can validate the
-// handler's contract.
-export const DeleteWorkflowResponseSchema = z.object({
-    id: z.string().describe("Workflow ID that was targeted for deletion"),
-});

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

@@ -1,76 +0,0 @@
-export declare const disableWorkflowPlugin: (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>;
-    };
-}) => {
-    disableWorkflow: (options?: {
-        workflow: string;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            enabled: boolean;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            disableWorkflow: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type DisableWorkflowPluginProvides = ReturnType<typeof disableWorkflowPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/disableWorkflow/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BjC,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,UAAU,CACpD,OAAO,qBAAqB,CAC7B,CAAC"}

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

@@ -1,21 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { workflowIdResolver } from "../../../resolvers/workflowId";
-import { codeSubstrateDefaults } from "../shared";
-import { DisableWorkflowOptionsSchema, DisableWorkflowResponseSchema, } from "./schemas";
-export const disableWorkflowPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "disableWorkflow",
-    type: "update",
-    itemType: "Workflow",
-    inputSchema: DisableWorkflowOptionsSchema,
-    outputSchema: DisableWorkflowResponseSchema,
-    resolvers: { workflow: workflowIdResolver },
-    handler: async ({ sdk, options }) => {
-        const raw = await sdk.context.api.post(`/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}/disable`, undefined, {
-            authRequired: true,
-            resource: { type: "workflow", id: options.workflow },
-        });
-        const data = DisableWorkflowResponseSchema.parse(raw);
-        return { data };
-    },
-}));

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

@@ -1,11 +0,0 @@
-import { z } from "zod";
-export declare const DisableWorkflowOptionsSchema: z.ZodObject<{
-    workflow: z.ZodString;
-}, z.core.$strip>;
-export type DisableWorkflowOptions = z.infer<typeof DisableWorkflowOptionsSchema>;
-export declare const DisableWorkflowResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    enabled: z.ZodBoolean;
-}, z.core.$strip>;
-export type DisableWorkflowResponse = z.infer<typeof DisableWorkflowResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/disableWorkflow/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,4BAA4B;;iBAI+B,CAAC;AAEzE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;iBAOxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC"}

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

@@ -1,12 +0,0 @@
-import { z } from "zod";
-export const DisableWorkflowOptionsSchema = z
-    .object({
-    workflow: z.string().uuid().describe("Durable workflow ID"),
-})
-    .describe("Disable a durable workflow so it stops accepting triggers");
-export const DisableWorkflowResponseSchema = z.object({
-    id: z.string().describe("Workflow ID (UUID)"),
-    enabled: z
-        .boolean()
-        .describe("Workflow's enabled state after the operation. Typically false; mirrors the row's true state in case a concurrent enable raced with this call."),
-});