@zapier/zapier-sdk 0.77.0 → 0.77.2

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

@@ -1,132 +0,0 @@
-export declare const getWorkflowVersionPlugin: (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>;
-        };
-    };
-} & {
-    listWorkflowVersions: (options?: ({
-        workflow: string;
-        pageSize?: number | undefined;
-        cursor?: string | undefined;
-        maxItems?: number | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        id: string;
-        workflow_id: string;
-        zapier_durable_version: string;
-        dependencies: Record<string, string> | null;
-        created_by_user_id: string;
-        created_at: string;
-        trigger: {
-            selected_api: string;
-            action: string;
-            authentication_id?: string | null | undefined;
-            params?: Record<string, unknown> | undefined;
-        } | null;
-        connections: Record<string, {
-            connection_id: string | number;
-        }> | null;
-        app_versions: Record<string, {
-            implementation_name: string;
-            version?: string | undefined;
-        }> | null;
-    }>;
-} & {
-    context: {
-        meta: {
-            listWorkflowVersions: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    getWorkflowVersion: (options?: {
-        workflow: string;
-        version: string;
-    } | undefined) => Promise<{
-        data: {
-            id: string;
-            workflow_id: string;
-            source_files: Record<string, string>;
-            zapier_durable_version: string;
-            dependencies: Record<string, string> | null;
-            created_by_user_id: string;
-            created_at: string;
-            trigger: {
-                selected_api: string;
-                action: string;
-                authentication_id?: string | null | undefined;
-                params?: Record<string, unknown> | undefined;
-            } | null;
-            connections: Record<string, {
-                connection_id: string | number;
-            }> | null;
-            app_versions: Record<string, {
-                implementation_name: string;
-                version?: string | undefined;
-            }> | null;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            getWorkflowVersion: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type GetWorkflowVersionPluginProvides = ReturnType<typeof getWorkflowVersionPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getWorkflowVersion/index.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BpC,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,UAAU,CACvD,OAAO,wBAAwB,CAChC,CAAC"}

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

@@ -1,25 +0,0 @@
-import { definePlugin, createPluginMethod } from "kitcore";
-import { workflowIdResolver } from "../../../resolvers/workflowId";
-import { workflowVersionIdResolver } from "../../../resolvers/workflowVersionId";
-import { codeSubstrateDefaults } from "../shared";
-import { GetWorkflowVersionOptionsSchema, GetWorkflowVersionResponseSchema, } from "./schemas";
-export const getWorkflowVersionPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "getWorkflowVersion",
-    type: "item",
-    itemType: "WorkflowVersion",
-    inputSchema: GetWorkflowVersionOptionsSchema,
-    outputSchema: GetWorkflowVersionResponseSchema,
-    resolvers: {
-        workflow: workflowIdResolver,
-        version: workflowVersionIdResolver,
-    },
-    handler: async ({ sdk, options }) => {
-        const raw = await sdk.context.api.get(`/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}/versions/${encodeURIComponent(options.version)}`, {
-            authRequired: true,
-            resource: { type: "workflow-version", id: options.version },
-        });
-        const data = GetWorkflowVersionResponseSchema.parse(raw);
-        return { data };
-    },
-}));

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

@@ -1,30 +0,0 @@
-import { z } from "zod";
-export declare const GetWorkflowVersionOptionsSchema: z.ZodObject<{
-    workflow: z.ZodString;
-    version: z.ZodString;
-}, z.core.$strip>;
-export type GetWorkflowVersionOptions = z.infer<typeof GetWorkflowVersionOptionsSchema>;
-export declare const GetWorkflowVersionResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    workflow_id: z.ZodString;
-    source_files: z.ZodRecord<z.ZodString, z.ZodString>;
-    zapier_durable_version: z.ZodString;
-    dependencies: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
-    created_by_user_id: z.ZodString;
-    created_at: z.ZodString;
-    trigger: z.ZodNullable<z.ZodObject<{
-        selected_api: z.ZodString;
-        action: z.ZodString;
-        authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
-    connections: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        connection_id: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodString]>;
-    }, z.core.$strip>>>;
-    app_versions: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-        implementation_name: z.ZodString;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type GetWorkflowVersionResponse = z.infer<typeof GetWorkflowVersionResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getWorkflowVersion/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,+BAA+B;;;iBAKgC,CAAC;AAE7E,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;iBA8B3C,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC"}

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

@@ -1,35 +0,0 @@
-import { z } from "zod";
-import { AppVersionBindingSchema, ConnectionBindingSchema, WorkflowVersionTriggerConfigSchema, } from "../shared-schemas";
-export const GetWorkflowVersionOptionsSchema = z
-    .object({
-    workflow: z.string().uuid().describe("Durable workflow ID"),
-    version: z.string().uuid().describe("Workflow version ID"),
-})
-    .describe("Get full details of a workflow version including source files");
-export const GetWorkflowVersionResponseSchema = z.object({
-    id: z.string().describe("Workflow version ID (UUID)"),
-    workflow_id: z.string().describe("Parent workflow ID (UUID)"),
-    source_files: z
-        .record(z.string(), z.string())
-        .describe("Source files keyed by filename → contents"),
-    zapier_durable_version: z
-        .string()
-        .describe("Pinned semver of @zapier/zapier-durable used by this version's runs"),
-    dependencies: z
-        .record(z.string(), z.string())
-        .nullable()
-        .describe("Additional npm dependencies pinned for this version (or null)"),
-    created_by_user_id: z
-        .string()
-        .describe("ID of the user who published this version"),
-    created_at: z.string().describe("When the version was published (ISO-8601)"),
-    trigger: WorkflowVersionTriggerConfigSchema.nullable().describe("Trigger configuration persisted on this version, or null for webhook-only workflows."),
-    connections: z
-        .record(z.string(), ConnectionBindingSchema)
-        .nullable()
-        .describe("Connection aliases bound on this version (or null)."),
-    app_versions: z
-        .record(z.string(), AppVersionBindingSchema)
-        .nullable()
-        .describe("App-version pins bound on this version (or null)."),
-});

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

@@ -1,55 +0,0 @@
-export declare const listDurableRunsPlugin: (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>;
-    };
-}) => {
-    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>;
-        };
-    };
-};
-export type ListDurableRunsPluginProvides = ReturnType<typeof listDurableRunsPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,31 +0,0 @@
-import { definePlugin, createPaginatedPluginMethod } from "kitcore";
-import { DEFAULT_PAGE_SIZE } from "../../../constants";
-import { codeSubstrateDefaults } from "../shared";
-import { ListDurableRunsApiResponseSchema, ListDurableRunsOptionsSchema, RunItemSchema, } from "./schemas";
-export const listDurableRunsPlugin = definePlugin((sdk) => createPaginatedPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "listDurableRuns",
-    type: "list",
-    itemType: "DurableRun",
-    inputSchema: ListDurableRunsOptionsSchema,
-    outputSchema: RunItemSchema,
-    defaultPageSize: DEFAULT_PAGE_SIZE,
-    handler: async ({ sdk, options }) => {
-        const searchParams = {};
-        if (options.pageSize !== undefined) {
-            searchParams.limit = options.pageSize.toString();
-        }
-        if (options.cursor) {
-            searchParams.cursor = options.cursor;
-        }
-        const raw = await sdk.context.api.get("/sdkdurableapi/api/v0/runs", {
-            searchParams,
-            authRequired: true,
-        });
-        const response = ListDurableRunsApiResponseSchema.parse(raw);
-        return {
-            data: response.results,
-            nextCursor: response.meta.next_cursor ?? undefined,
-        };
-    },
-}));

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

@@ -1,73 +0,0 @@
-import { z } from "zod";
-export declare const RunStatusSchema: z.ZodUnion<readonly [z.ZodEnum<{
-    failed: "failed";
-    initialized: "initialized";
-    started: "started";
-    finished: "finished";
-    cancelled: "cancelled";
-}>, z.ZodString]>;
-export type RunStatus = z.infer<typeof RunStatusSchema>;
-export declare const RunErrorSchema: z.ZodObject<{
-    code: z.ZodString;
-    message: z.ZodString;
-}, z.core.$loose>;
-export type RunError = z.infer<typeof RunErrorSchema>;
-export declare const RunItemSchema: z.ZodObject<{
-    id: z.ZodString;
-    status: z.ZodUnion<readonly [z.ZodEnum<{
-        failed: "failed";
-        initialized: "initialized";
-        started: "started";
-        finished: "finished";
-        cancelled: "cancelled";
-    }>, z.ZodString]>;
-    input: z.ZodUnknown;
-    output: z.ZodNullable<z.ZodUnknown>;
-    error: z.ZodNullable<z.ZodObject<{
-        code: z.ZodString;
-        message: z.ZodString;
-    }, z.core.$loose>>;
-    execution_id: z.ZodNullable<z.ZodString>;
-    is_private: z.ZodBoolean;
-    created_at: z.ZodString;
-    updated_at: z.ZodString;
-}, z.core.$strip>;
-export type RunItem = z.infer<typeof RunItemSchema>;
-export declare const ListDurableRunsOptionsSchema: z.ZodObject<{
-    pageSize: z.ZodOptional<z.ZodNumber>;
-    cursor: z.ZodOptional<z.ZodString>;
-    maxItems: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type ListDurableRunsOptions = z.infer<typeof ListDurableRunsOptionsSchema>;
-export declare const ListDurableRunsApiResponseSchema: z.ZodObject<{
-    results: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        status: z.ZodUnion<readonly [z.ZodEnum<{
-            failed: "failed";
-            initialized: "initialized";
-            started: "started";
-            finished: "finished";
-            cancelled: "cancelled";
-        }>, z.ZodString]>;
-        input: z.ZodUnknown;
-        output: z.ZodNullable<z.ZodUnknown>;
-        error: z.ZodNullable<z.ZodObject<{
-            code: z.ZodString;
-            message: z.ZodString;
-        }, z.core.$loose>>;
-        execution_id: z.ZodNullable<z.ZodString>;
-        is_private: z.ZodBoolean;
-        created_at: z.ZodString;
-        updated_at: z.ZodString;
-    }, z.core.$strip>>;
-    meta: z.ZodObject<{
-        limit: z.ZodNumber;
-        cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        next_cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>;
-    links: z.ZodOptional<z.ZodObject<{
-        next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ListDurableRunsApiResponse = z.infer<typeof ListDurableRunsApiResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/listDurableRuns/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,eAAe;;;;;;iBAG3B,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,cAAc;;;iBAQxB,CAAC;AAEJ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;iBAwBxB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,eAAO,MAAM,4BAA4B;;;;iBAiBtC,CAAC;AAEJ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY3C,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC"}

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

@@ -1,58 +0,0 @@
-import { z } from "zod";
-import { openEnum } from "kitcore";
-export const RunStatusSchema = openEnum(["initialized", "started", "finished", "failed", "cancelled"], "Run lifecycle status. `finished` / `failed` / `cancelled` are terminal.");
-export const RunErrorSchema = z
-    .object({
-    code: z.string().describe("Machine-readable error category"),
-    message: z.string().describe("Human-readable error summary"),
-})
-    .passthrough()
-    .describe("Structured run error. Always carries `code` and `message`; additional keys may appear depending on the error type.");
-export const RunItemSchema = z.object({
-    id: z.string().describe("Run ID (UUID)"),
-    status: RunStatusSchema,
-    input: z.unknown().describe("Input data passed to the run"),
-    output: z
-        .unknown()
-        .nullable()
-        .describe("Return value, present when status is `finished`"),
-    error: RunErrorSchema.nullable().describe("Structured error details when the run failed (null otherwise)"),
-    execution_id: z
-        .string()
-        .nullable()
-        .describe("Linked execution ID. Null until the run leaves the `initialized` state."),
-    is_private: z
-        .boolean()
-        .describe("When true, the run is visible only to the creating user; otherwise visible across the account."),
-    created_at: z.string().describe("When the run was created (ISO-8601)"),
-    updated_at: z.string().describe("When the run was last updated (ISO-8601)"),
-});
-export const ListDurableRunsOptionsSchema = z
-    .object({
-    pageSize: z
-        .number()
-        .min(1)
-        .max(100)
-        .optional()
-        .describe("Number of runs per page (max 100)"),
-    cursor: z.string().optional().describe("Pagination cursor"),
-    maxItems: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Maximum total items to return across all pages"),
-})
-    .describe("List run-once durable runs for the authenticated account, newest first");
-export const ListDurableRunsApiResponseSchema = z.object({
-    results: z.array(RunItemSchema),
-    meta: z.object({
-        limit: z.number(),
-        cursor: z.string().nullable().optional(),
-        next_cursor: z.string().nullable().optional(),
-    }),
-    links: z
-        .object({
-        next: z.string().nullable().optional(),
-    })
-        .optional(),
-});

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

@@ -1,88 +0,0 @@
-export declare const listWorkflowRunsPlugin: (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>;
-    };
-}) => {
-    listWorkflowRuns: (options?: ({
-        workflow: string;
-        pageSize?: number | undefined;
-        cursor?: string | undefined;
-        maxItems?: number | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        id: string;
-        trigger_id: string | null;
-        durable_run_id: string | null;
-        workflow_version_id: string | null;
-        status: string;
-        input: unknown;
-        error: unknown;
-        created_at: string;
-        updated_at: string;
-    }>;
-} & {
-    context: {
-        meta: {
-            listWorkflowRuns: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type ListWorkflowRunsPluginProvides = ReturnType<typeof listWorkflowRunsPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,34 +0,0 @@
-import { definePlugin, createPaginatedPluginMethod } from "kitcore";
-import { workflowIdResolver } from "../../../resolvers/workflowId";
-import { DEFAULT_PAGE_SIZE } from "../../../constants";
-import { codeSubstrateDefaults } from "../shared";
-import { ListWorkflowRunsApiResponseSchema, ListWorkflowRunsOptionsSchema, WorkflowRunListItemSchema, } from "./schemas";
-export const listWorkflowRunsPlugin = definePlugin((sdk) => createPaginatedPluginMethod(sdk, {
-    ...codeSubstrateDefaults,
-    name: "listWorkflowRuns",
-    type: "list",
-    itemType: "WorkflowRun",
-    inputSchema: ListWorkflowRunsOptionsSchema,
-    outputSchema: WorkflowRunListItemSchema,
-    defaultPageSize: DEFAULT_PAGE_SIZE,
-    resolvers: { workflow: workflowIdResolver },
-    handler: async ({ sdk, options }) => {
-        const searchParams = {};
-        if (options.pageSize !== undefined) {
-            searchParams.limit = options.pageSize.toString();
-        }
-        if (options.cursor) {
-            searchParams.cursor = options.cursor;
-        }
-        const raw = await sdk.context.api.get(`/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}/runs`, {
-            searchParams,
-            authRequired: true,
-            resource: { type: "workflow", id: options.workflow },
-        });
-        const response = ListWorkflowRunsApiResponseSchema.parse(raw);
-        return {
-            data: response.results,
-            nextCursor: response.meta.next_cursor ?? undefined,
-        };
-    },
-}));

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

@@ -1,63 +0,0 @@
-import { z } from "zod";
-export declare const WorkflowRunStatusSchema: z.ZodUnion<readonly [z.ZodEnum<{
-    failed: "failed";
-    initialized: "initialized";
-    started: "started";
-    finished: "finished";
-    cancelled: "cancelled";
-}>, z.ZodString]>;
-export type WorkflowRunStatus = z.infer<typeof WorkflowRunStatusSchema>;
-export declare const WorkflowRunListItemSchema: z.ZodObject<{
-    id: z.ZodString;
-    trigger_id: z.ZodNullable<z.ZodString>;
-    durable_run_id: z.ZodNullable<z.ZodString>;
-    workflow_version_id: z.ZodNullable<z.ZodString>;
-    status: z.ZodUnion<readonly [z.ZodEnum<{
-        failed: "failed";
-        initialized: "initialized";
-        started: "started";
-        finished: "finished";
-        cancelled: "cancelled";
-    }>, z.ZodString]>;
-    input: z.ZodUnknown;
-    error: z.ZodNullable<z.ZodUnknown>;
-    created_at: z.ZodString;
-    updated_at: z.ZodString;
-}, z.core.$strip>;
-export type WorkflowRunListItem = z.infer<typeof WorkflowRunListItemSchema>;
-export declare const ListWorkflowRunsOptionsSchema: z.ZodObject<{
-    workflow: z.ZodString;
-    pageSize: z.ZodOptional<z.ZodNumber>;
-    cursor: z.ZodOptional<z.ZodString>;
-    maxItems: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type ListWorkflowRunsOptions = z.infer<typeof ListWorkflowRunsOptionsSchema>;
-export declare const ListWorkflowRunsApiResponseSchema: z.ZodObject<{
-    results: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        trigger_id: z.ZodNullable<z.ZodString>;
-        durable_run_id: z.ZodNullable<z.ZodString>;
-        workflow_version_id: z.ZodNullable<z.ZodString>;
-        status: z.ZodUnion<readonly [z.ZodEnum<{
-            failed: "failed";
-            initialized: "initialized";
-            started: "started";
-            finished: "finished";
-            cancelled: "cancelled";
-        }>, z.ZodString]>;
-        input: z.ZodUnknown;
-        error: z.ZodNullable<z.ZodUnknown>;
-        created_at: z.ZodString;
-        updated_at: z.ZodString;
-    }, z.core.$strip>>;
-    meta: z.ZodObject<{
-        limit: z.ZodNumber;
-        cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        next_cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>;
-    links: z.ZodOptional<z.ZodObject<{
-        next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ListWorkflowRunsApiResponse = z.infer<typeof ListWorkflowRunsApiResponseSchema>;
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/listWorkflowRuns/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,uBAAuB;;;;;;iBAOjC,CAAC;AAEJ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;iBA8BpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,6BAA6B;;;;;iBAoBvC,CAAC;AAEJ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY5C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC"}