@n8n/api-types 1.38.1 → 1.39.0

package/dist/dto/executions/execution-public.openapi.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tracingContextOpenApi = exports.customDataOpenApi = exports.workflowDataOpenApi = exports.dataOpenApi = exports.deletedExecutionIdOpenApi = exports.executionFieldDocs = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const openapi_nullable_1 = require("../openapi-nullable");
+exports.executionFieldDocs = {
+    id: { example: '1000' },
+    finished: {
+        example: true,
+        deprecated: true,
+        description: 'Whether the execution ran to completion. Use `status` instead.',
+    },
+    mode: {
+        enum: [...n8n_workflow_1.WorkflowExecuteModeList],
+        example: 'manual',
+    },
+    retryOf: (0, openapi_nullable_1.alsoNullable)({
+        description: 'ID of the execution this one is a retry of.',
+    }),
+    retrySuccessId: (0, openapi_nullable_1.alsoNullable)({
+        description: 'ID of the retry that succeeded, if this execution failed and a retry did not.',
+        example: '2',
+    }),
+    status: {
+        enum: [...n8n_workflow_1.ExecutionStatusList],
+    },
+    createdAt: { format: 'date-time' },
+    startedAt: (0, openapi_nullable_1.alsoNullable)({
+        format: 'date-time',
+        description: 'Null until the execution leaves the queue and starts running.',
+    }),
+    stoppedAt: (0, openapi_nullable_1.alsoNullable)({
+        format: 'date-time',
+        description: 'When the execution stopped. Null for the `new`, `running` and `unknown` statuses; a ' +
+            '`waiting` execution has stopped its current run, so it has a value.',
+    }),
+    deletedAt: (0, openapi_nullable_1.alsoNullable)({
+        format: 'date-time',
+        description: 'Always null. Soft-deleted executions are not returned.',
+    }),
+    workflowId: { example: '1000' },
+    waitTill: (0, openapi_nullable_1.alsoNullable)({
+        format: 'date-time',
+        description: 'The time at which a waiting execution resumes.',
+    }),
+    storedAt: {
+        enum: ['db', 'fs', 's3', 'az'],
+        description: 'Where the execution data is stored.',
+    },
+    deduplicationKey: (0, openapi_nullable_1.alsoNullable)({
+        description: 'Key used to stop a duplicate execution from being created.',
+    }),
+    jsonSizeBytes: {
+        description: 'Size of the stored execution data in bytes. 0 means unknown.',
+        example: 0,
+    },
+    binaryDataSizeBytes: {
+        description: 'Size of the stored binary data in bytes. 0 means unknown.',
+        example: 0,
+    },
+    workflowVersionId: (0, openapi_nullable_1.alsoNullable)({
+        description: 'ID of the workflow version this execution ran.',
+    }),
+    usedPrivateCredentials: {
+        description: 'Whether the execution used credentials that are not shared with the project.',
+        example: false,
+    },
+    dataTooLargeToDisplay: {
+        description: 'Present and true when the execution data was larger than ' +
+            '`EXECUTIONS_DATA_MAX_DISPLAY_SIZE`. `data` is then empty and `jsonSizeBytes` holds the ' +
+            'real size. Use `ignoreDataSizeLimit` to read it anyway.',
+    },
+};
+exports.deletedExecutionIdOpenApi = {
+    description: 'ID of the deleted execution. This endpoint returns it as a number, where every other ' +
+        'execution endpoint returns a string.',
+    example: 1000,
+};
+exports.dataOpenApi = {
+    type: 'object',
+    additionalProperties: true,
+    description: 'Detailed execution data. Only included when `includeData` is `true`.',
+    properties: {
+        redactionInfo: {
+            type: 'object',
+            nullable: true,
+            description: 'Present when execution data has been redacted.',
+            properties: {
+                isRedacted: { type: 'boolean', description: 'Whether the execution data was redacted.' },
+                reason: { type: 'string', description: 'The reason for redaction.' },
+                canReveal: {
+                    type: 'boolean',
+                    description: 'Whether the current user has permission to reveal the redacted data.',
+                },
+            },
+        },
+    },
+};
+exports.workflowDataOpenApi = {
+    type: 'object',
+    additionalProperties: true,
+    description: 'The workflow as it was saved when the execution ran. Only included when `includeData` is ' +
+        '`true`. Older executions carry more fields than newer ones.',
+};
+exports.customDataOpenApi = {
+    type: 'object',
+    additionalProperties: { type: 'string' },
+    description: 'Execution metadata set by the workflow. Only included when `includeData` is `true`.',
+};
+exports.tracingContextOpenApi = {
+    description: 'W3C trace context propagated with the execution.',
+};
+//# sourceMappingURL=execution-public.openapi.js.map

package/dist/dto/executions/execution-public.openapi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-public.openapi.js","sourceRoot":"","sources":["../../../src/dto/executions/execution-public.openapi.ts"],"names":[],"mappings":"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"}

package/dist/dto/executions/execution-tags-public.dto.d.ts

@@ -0,0 +1,24 @@
+declare const ExecutionTagsPublicDto_base: import("../../zod-class").ZodArrayClass<{
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+}[], import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    name: import("zod").ZodString;
+    createdAt: import("zod").ZodString;
+    updatedAt: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+}, {
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+}>>;
+export declare class ExecutionTagsPublicDto extends ExecutionTagsPublicDto_base {
+}
+export {};

package/dist/dto/executions/execution-tags-public.dto.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionTagsPublicDto = void 0;
+const zod_class_1 = require("../../zod-class");
+const tag_public_dto_1 = require("../tag/tag-public.dto");
+class ExecutionTagsPublicDto extends zod_class_1.Z.array(tag_public_dto_1.tagPublicSchema) {
+}
+exports.ExecutionTagsPublicDto = ExecutionTagsPublicDto;
+//# sourceMappingURL=execution-tags-public.dto.js.map

package/dist/dto/executions/execution-tags-public.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-tags-public.dto.js","sourceRoot":"","sources":["../../../src/dto/executions/execution-tags-public.dto.ts"],"names":[],"mappings":";;;AAAA,+CAAoC;AACpC,0DAAwD;AAKxD,4BAAoC,SAAQ,aAAC,CAAC,KAAK,CAAC,gCAAe,CAAC;CAAG"}

package/dist/dto/executions/get-execution-query.dto.d.ts

@@ -0,0 +1,13 @@
+import '../../openapi-extend';
+declare const GetExecutionQueryDto_base: import("../../zod-class").ZodClass<{
+    includeData: boolean;
+    ignoreDataSizeLimit: boolean;
+    redactExecutionData?: boolean | undefined;
+}, {
+    includeData: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEnum<["true", "false"]>, boolean, "false" | "true">>>;
+    ignoreDataSizeLimit: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEnum<["true", "false"]>, boolean, "false" | "true">>>;
+    redactExecutionData: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEnum<["true", "false"]>, boolean, "false" | "true">>;
+}>;
+export declare class GetExecutionQueryDto extends GetExecutionQueryDto_base {
+}
+export {};

package/dist/dto/executions/get-execution-query.dto.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetExecutionQueryDto = void 0;
+require("../../openapi-extend");
+const boolean_from_string_1 = require("../../schemas/boolean-from-string");
+const zod_class_1 = require("../../zod-class");
+class GetExecutionQueryDto extends zod_class_1.Z.class({
+    includeData: boolean_from_string_1.booleanFromString
+        .optional()
+        .default('false')
+        .openapi({ description: "Whether or not to include the execution's detailed data." }),
+    ignoreDataSizeLimit: boolean_from_string_1.booleanFromString
+        .optional()
+        .default('false')
+        .openapi({
+        description: 'Whether to return the full execution data even if it exceeds the configured size limit ' +
+            '(EXECUTIONS_DATA_MAX_DISPLAY_SIZE). Oversized executions are otherwise returned without ' +
+            'their data.',
+    }),
+    redactExecutionData: boolean_from_string_1.booleanFromString.optional().openapi({
+        description: 'Controls execution data redaction. When `true`, execution output data is always redacted. ' +
+            'When `false`, requests unredacted (revealed) data — requires the `execution:reveal` scope. ' +
+            'When omitted, follows the workflow redaction policy.',
+    }),
+}) {
+}
+exports.GetExecutionQueryDto = GetExecutionQueryDto;
+//# sourceMappingURL=get-execution-query.dto.js.map

package/dist/dto/executions/get-execution-query.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-execution-query.dto.js","sourceRoot":"","sources":["../../../src/dto/executions/get-execution-query.dto.ts"],"names":[],"mappings":";;;AAAA,gCAA8B;AAE9B,2EAAsE;AACtE,+CAAoC;AAEpC,0BAAkC,SAAQ,aAAC,CAAC,KAAK,CAAC;IACjD,WAAW,EAAE,uCAAiB;SAC5B,QAAQ,EAAE;SACV,OAAO,CAAC,OAAO,CAAC;SAChB,OAAO,CAAC,EAAE,WAAW,EAAE,0DAA0D,EAAE,CAAC;IACtF,mBAAmB,EAAE,uCAAiB;SACpC,QAAQ,EAAE;SACV,OAAO,CAAC,OAAO,CAAC;SAChB,OAAO,CAAC;QACR,WAAW,EACV,yFAAyF;YACzF,0FAA0F;YAC1F,aAAa;KACd,CAAC;IACH,mBAAmB,EAAE,uCAAiB,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC;QACzD,WAAW,EACV,4FAA4F;YAC5F,6FAA6F;YAC7F,sDAAsD;KACvD,CAAC;CACF,CAAC;CAAG"}

package/dist/dto/executions/list-executions-query.dto.d.ts

@@ -0,0 +1,28 @@
+import '../../openapi-extend';
+import { z } from 'zod';
+declare const ListExecutionsQueryDto_base: import("../../zod-class").ZodClass<{
+    includeData: boolean;
+    ignoreDataSizeLimit: boolean;
+    redactExecutionData?: boolean | undefined;
+    status?: "canceled" | "crashed" | "error" | "new" | "running" | "success" | "unknown" | "waiting" | undefined;
+    workflowId?: string | undefined;
+    projectId?: string | undefined;
+    startedAfter?: string | undefined;
+    startedBefore?: string | undefined;
+    limit: number;
+    cursor?: string | undefined;
+}, {
+    includeData: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodEnum<["true", "false"]>, boolean, "false" | "true">>>;
+    ignoreDataSizeLimit: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodEnum<["true", "false"]>, boolean, "false" | "true">>>;
+    redactExecutionData: z.ZodOptional<z.ZodEffects<z.ZodEnum<["true", "false"]>, boolean, "false" | "true">>;
+    status: z.ZodOptional<z.ZodEnum<["canceled", "crashed", "error", "new", "running", "success", "unknown", "waiting"]>>;
+    workflowId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    startedAfter: z.ZodOptional<z.ZodString>;
+    startedBefore: z.ZodOptional<z.ZodString>;
+    limit: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodString>, number, string | undefined>, number, string | undefined>, number, string | undefined>, number, string | undefined>;
+    cursor: z.ZodOptional<z.ZodString>;
+}>;
+export declare class ListExecutionsQueryDto extends ListExecutionsQueryDto_base {
+}
+export {};

package/dist/dto/executions/list-executions-query.dto.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListExecutionsQueryDto = void 0;
+require("../../openapi-extend");
+const n8n_workflow_1 = require("n8n-workflow");
+const zod_1 = require("zod");
+const boolean_from_string_1 = require("../../schemas/boolean-from-string");
+const zod_class_1 = require("../../zod-class");
+const pagination_dto_1 = require("../pagination/pagination.dto");
+class ListExecutionsQueryDto extends zod_class_1.Z.class({
+    includeData: boolean_from_string_1.booleanFromString
+        .optional()
+        .default('false')
+        .openapi({ description: "Whether or not to include the execution's detailed data." }),
+    ignoreDataSizeLimit: boolean_from_string_1.booleanFromString
+        .optional()
+        .default('false')
+        .openapi({
+        description: 'Whether to return the full execution data even if it exceeds the configured size limit ' +
+            '(EXECUTIONS_DATA_MAX_DISPLAY_SIZE). Oversized executions are otherwise returned without ' +
+            'their data.',
+    }),
+    redactExecutionData: boolean_from_string_1.booleanFromString.optional().openapi({
+        description: 'Controls execution data redaction. When `true`, execution output data is always redacted. ' +
+            'When `false`, requests unredacted (revealed) data — requires the `execution:reveal` scope. ' +
+            'When omitted, follows the workflow redaction policy.',
+    }),
+    status: zod_1.z
+        .enum(n8n_workflow_1.ExecutionStatusList)
+        .optional()
+        .openapi({ description: 'Status to filter the executions by.' }),
+    workflowId: zod_1.z
+        .string()
+        .optional()
+        .openapi({ description: 'Workflow to filter the executions by.', example: '1000' }),
+    projectId: zod_1.z.string().optional().openapi({ example: 'VmwOO9HeTEj20kxM' }),
+    startedAfter: zod_1.z.string().datetime({ offset: true }).optional().openapi({
+        description: 'Only return executions that started after this time.',
+        example: '2024-01-01T00:00:00.000Z',
+    }),
+    startedBefore: zod_1.z.string().datetime({ offset: true }).optional().openapi({
+        description: 'Only return executions that started before this time.',
+        example: '2024-12-31T23:59:59.999Z',
+    }),
+    limit: pagination_dto_1.publicApiPaginationSchema.limit,
+    cursor: zod_1.z.string().optional(),
+}) {
+}
+exports.ListExecutionsQueryDto = ListExecutionsQueryDto;
+//# sourceMappingURL=list-executions-query.dto.js.map

package/dist/dto/executions/list-executions-query.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-executions-query.dto.js","sourceRoot":"","sources":["../../../src/dto/executions/list-executions-query.dto.ts"],"names":[],"mappings":";;;AAAA,gCAA8B;AAE9B,+CAAmD;AACnD,6BAAwB;AAExB,2EAAsE;AACtE,+CAAoC;AACpC,iEAAyE;AAEzE,4BAAoC,SAAQ,aAAC,CAAC,KAAK,CAAC;IACnD,WAAW,EAAE,uCAAiB;SAC5B,QAAQ,EAAE;SACV,OAAO,CAAC,OAAO,CAAC;SAChB,OAAO,CAAC,EAAE,WAAW,EAAE,0DAA0D,EAAE,CAAC;IACtF,mBAAmB,EAAE,uCAAiB;SACpC,QAAQ,EAAE;SACV,OAAO,CAAC,OAAO,CAAC;SAChB,OAAO,CAAC;QACR,WAAW,EACV,yFAAyF;YACzF,0FAA0F;YAC1F,aAAa;KACd,CAAC;IACH,mBAAmB,EAAE,uCAAiB,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC;QACzD,WAAW,EACV,4FAA4F;YAC5F,6FAA6F;YAC7F,sDAAsD;KACvD,CAAC;IACF,MAAM,EAAE,OAAC;SACP,IAAI,CAAC,kCAAmB,CAAC;SACzB,QAAQ,EAAE;SACV,OAAO,CAAC,EAAE,WAAW,EAAE,qCAAqC,EAAE,CAAC;IACjE,UAAU,EAAE,OAAC;SACX,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,OAAO,CAAC,EAAE,WAAW,EAAE,uCAAuC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IACpF,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAGzE,YAAY,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC;QACtE,WAAW,EAAE,sDAAsD;QACnE,OAAO,EAAE,0BAA0B;KACnC,CAAC;IACF,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC;QACvE,WAAW,EAAE,uDAAuD;QACpE,OAAO,EAAE,0BAA0B;KACnC,CAAC;IAEF,KAAK,EAAE,0CAAyB,CAAC,KAAK;IACtC,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC7B,CAAC;CAAG"}

package/dist/dto/executions/retried-execution-public.dto.d.ts

@@ -0,0 +1,152 @@
+import '../../openapi-extend';
+import { z } from 'zod';
+export declare const retriedExecutionPublicSchema: z.ZodObject<{
+    id: z.ZodString;
+    mode: z.ZodString;
+    startedAt: z.ZodNullable<z.ZodString>;
+    workflowId: z.ZodString;
+    finished: z.ZodBoolean;
+    retryOf: z.ZodNullable<z.ZodString>;
+    status: z.ZodString;
+    waitTill: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    data: z.ZodType<Record<string, unknown>, z.ZodTypeDef, Record<string, unknown>>;
+    workflowData: z.ZodType<Record<string, unknown>, z.ZodTypeDef, Record<string, unknown>>;
+    customData: z.ZodRecord<z.ZodString, z.ZodString>;
+    annotation: z.ZodOptional<z.ZodObject<{
+        id: z.ZodNumber;
+        vote: z.ZodNullable<z.ZodString>;
+        tags: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            name: string;
+        }, {
+            id: string;
+            name: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+        vote: string | null;
+        tags: {
+            id: string;
+            name: string;
+        }[];
+    }, {
+        id: number;
+        vote: string | null;
+        tags: {
+            id: string;
+            name: string;
+        }[];
+    }>>;
+    storedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    mode: string;
+    startedAt: string | null;
+    workflowId: string;
+    finished: boolean;
+    retryOf: string | null;
+    status: string;
+    waitTill?: string | null | undefined;
+    data: Record<string, unknown>;
+    workflowData: Record<string, unknown>;
+    customData: Record<string, string>;
+    annotation?: {
+        id: number;
+        vote: string | null;
+        tags: {
+            id: string;
+            name: string;
+        }[];
+    } | undefined;
+    storedAt: string;
+}, {
+    id: string;
+    mode: string;
+    startedAt: string | null;
+    workflowId: string;
+    finished: boolean;
+    retryOf: string | null;
+    status: string;
+    waitTill?: string | null | undefined;
+    data: Record<string, unknown>;
+    workflowData: Record<string, unknown>;
+    customData: Record<string, string>;
+    annotation?: {
+        id: number;
+        vote: string | null;
+        tags: {
+            id: string;
+            name: string;
+        }[];
+    } | undefined;
+    storedAt: string;
+}>;
+declare const RetriedExecutionPublicDto_base: import("../../zod-class").ZodClass<{
+    id: string;
+    mode: string;
+    startedAt: string | null;
+    workflowId: string;
+    finished: boolean;
+    retryOf: string | null;
+    status: string;
+    waitTill?: string | null | undefined;
+    data: Record<string, unknown>;
+    workflowData: Record<string, unknown>;
+    customData: Record<string, string>;
+    annotation?: {
+        id: number;
+        vote: string | null;
+        tags: {
+            id: string;
+            name: string;
+        }[];
+    } | undefined;
+    storedAt: string;
+}, {
+    id: z.ZodString;
+    mode: z.ZodString;
+    startedAt: z.ZodNullable<z.ZodString>;
+    workflowId: z.ZodString;
+    finished: z.ZodBoolean;
+    retryOf: z.ZodNullable<z.ZodString>;
+    status: z.ZodString;
+    waitTill: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    data: z.ZodType<Record<string, unknown>, z.ZodTypeDef, Record<string, unknown>>;
+    workflowData: z.ZodType<Record<string, unknown>, z.ZodTypeDef, Record<string, unknown>>;
+    customData: z.ZodRecord<z.ZodString, z.ZodString>;
+    annotation: z.ZodOptional<z.ZodObject<{
+        id: z.ZodNumber;
+        vote: z.ZodNullable<z.ZodString>;
+        tags: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            name: string;
+        }, {
+            id: string;
+            name: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+        vote: string | null;
+        tags: {
+            id: string;
+            name: string;
+        }[];
+    }, {
+        id: number;
+        vote: string | null;
+        tags: {
+            id: string;
+            name: string;
+        }[];
+    }>>;
+    storedAt: z.ZodString;
+}>;
+export declare class RetriedExecutionPublicDto extends RetriedExecutionPublicDto_base {
+}
+export {};

package/dist/dto/executions/retried-execution-public.dto.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetriedExecutionPublicDto = exports.retriedExecutionPublicSchema = void 0;
+require("../../openapi-extend");
+const zod_1 = require("zod");
+const execution_public_dto_1 = require("./execution-public.dto");
+const retried_execution_public_openapi_1 = require("./retried-execution-public.openapi");
+const object_guard_schema_1 = require("../../schemas/object-guard.schema");
+const zod_class_1 = require("../../zod-class");
+const executionAnnotationPublicSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    vote: zod_1.z.string().nullable().openapi(retried_execution_public_openapi_1.executionAnnotationVoteOpenApi),
+    tags: zod_1.z.array(zod_1.z.object({ id: zod_1.z.string(), name: zod_1.z.string() })),
+});
+exports.retriedExecutionPublicSchema = zod_1.z.object({
+    id: zod_1.z.string().openapi(retried_execution_public_openapi_1.retriedExecutionIdOpenApi),
+    mode: execution_public_dto_1.executionPublicSchema.shape.mode.openapi(retried_execution_public_openapi_1.retriedExecutionModeOpenApi),
+    startedAt: execution_public_dto_1.executionPublicSchema.shape.startedAt.openapi(retried_execution_public_openapi_1.retriedExecutionStartedAtOpenApi),
+    workflowId: execution_public_dto_1.executionPublicSchema.shape.workflowId,
+    finished: execution_public_dto_1.executionPublicSchema.shape.finished,
+    retryOf: execution_public_dto_1.executionPublicSchema.shape.retryOf,
+    status: execution_public_dto_1.executionPublicSchema.shape.status,
+    waitTill: execution_public_dto_1.executionPublicSchema.shape.waitTill.optional(),
+    data: (0, object_guard_schema_1.objectGuardSchema)().openapi(retried_execution_public_openapi_1.retriedExecutionDataOpenApi),
+    workflowData: (0, object_guard_schema_1.objectGuardSchema)().openapi(retried_execution_public_openapi_1.retriedExecutionWorkflowDataOpenApi),
+    customData: zod_1.z.record(zod_1.z.string()).openapi(retried_execution_public_openapi_1.retriedExecutionCustomDataOpenApi),
+    annotation: executionAnnotationPublicSchema.optional().openapi(retried_execution_public_openapi_1.retriedExecutionAnnotationOpenApi),
+    storedAt: execution_public_dto_1.executionPublicSchema.shape.storedAt,
+});
+class RetriedExecutionPublicDto extends zod_class_1.Z.class(exports.retriedExecutionPublicSchema.shape) {
+}
+exports.RetriedExecutionPublicDto = RetriedExecutionPublicDto;
+//# sourceMappingURL=retried-execution-public.dto.js.map

package/dist/dto/executions/retried-execution-public.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retried-execution-public.dto.js","sourceRoot":"","sources":["../../../src/dto/executions/retried-execution-public.dto.ts"],"names":[],"mappings":";;;AAAA,gCAA8B;AAC9B,6BAAwB;AAExB,iEAA+D;AAC/D,yFAS4C;AAC5C,2EAAsE;AACtE,+CAAoC;AAEpC,MAAM,+BAA+B,GAAG,OAAC,CAAC,MAAM,CAAC;IAChD,EAAE,EAAE,OAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,iEAA8B,CAAC;IACnE,IAAI,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,OAAC,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;CAC7D,CAAC,CAAC;AAEU,QAAA,4BAA4B,GAAG,OAAC,CAAC,MAAM,CAAC;IACpD,EAAE,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,4DAAyB,CAAC;IACjD,IAAI,EAAE,4CAAqB,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,8DAA2B,CAAC;IAC3E,SAAS,EAAE,4CAAqB,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,mEAAgC,CAAC;IAC1F,UAAU,EAAE,4CAAqB,CAAC,KAAK,CAAC,UAAU;IAClD,QAAQ,EAAE,4CAAqB,CAAC,KAAK,CAAC,QAAQ;IAC9C,OAAO,EAAE,4CAAqB,CAAC,KAAK,CAAC,OAAO;IAC5C,MAAM,EAAE,4CAAqB,CAAC,KAAK,CAAC,MAAM;IAC1C,QAAQ,EAAE,4CAAqB,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE;IACzD,IAAI,EAAE,IAAA,uCAAiB,GAA2B,CAAC,OAAO,CAAC,8DAA2B,CAAC;IACvF,YAAY,EAAE,IAAA,uCAAiB,GAA2B,CAAC,OAAO,CACjE,sEAAmC,CACnC;IACD,UAAU,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,oEAAiC,CAAC;IAC3E,UAAU,EAAE,+BAA+B,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,oEAAiC,CAAC;IACjG,QAAQ,EAAE,4CAAqB,CAAC,KAAK,CAAC,QAAQ;CAC9C,CAAC,CAAC;AAEH,+BAAuC,SAAQ,aAAC,CAAC,KAAK,CAAC,QAAA,4BAA4B,CAAC,KAAK,CAAC;CAAG"}

package/dist/dto/executions/retried-execution-public.openapi.d.ts

@@ -0,0 +1,10 @@
+import type { ZodOpenAPIMetadata } from '@asteasolutions/zod-to-openapi';
+export declare const retriedExecutionIdOpenApi: ZodOpenAPIMetadata;
+export declare const retriedExecutionModeOpenApi: ZodOpenAPIMetadata;
+export declare const retriedExecutionStartedAtOpenApi: ZodOpenAPIMetadata;
+export declare const retriedExecutionDataOpenApi: ZodOpenAPIMetadata;
+export declare const retriedExecutionWorkflowDataOpenApi: ZodOpenAPIMetadata;
+export declare const retriedExecutionCustomDataOpenApi: ZodOpenAPIMetadata;
+export declare const retriedExecutionAnnotationOpenApi: ZodOpenAPIMetadata;
+export declare const executionAnnotationVoteOpenApi: ZodOpenAPIMetadata;
+export declare const loadWorkflowOpenApi: ZodOpenAPIMetadata;

package/dist/dto/executions/retried-execution-public.openapi.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadWorkflowOpenApi = exports.executionAnnotationVoteOpenApi = exports.retriedExecutionAnnotationOpenApi = exports.retriedExecutionCustomDataOpenApi = exports.retriedExecutionWorkflowDataOpenApi = exports.retriedExecutionDataOpenApi = exports.retriedExecutionStartedAtOpenApi = exports.retriedExecutionModeOpenApi = exports.retriedExecutionIdOpenApi = void 0;
+const execution_public_openapi_1 = require("./execution-public.openapi");
+const openapi_nullable_1 = require("../openapi-nullable");
+exports.retriedExecutionIdOpenApi = {
+    description: 'ID of the new execution that the retry started.',
+    example: '1001',
+};
+exports.retriedExecutionModeOpenApi = {
+    ...execution_public_openapi_1.executionFieldDocs.mode,
+    example: 'retry',
+};
+exports.retriedExecutionStartedAtOpenApi = {
+    ...execution_public_openapi_1.executionFieldDocs.startedAt,
+    description: 'The time at which the new execution started.',
+};
+exports.retriedExecutionDataOpenApi = {
+    ...execution_public_openapi_1.dataOpenApi,
+    description: 'Run data of the new execution.',
+};
+exports.retriedExecutionWorkflowDataOpenApi = {
+    ...execution_public_openapi_1.workflowDataOpenApi,
+    description: 'The workflow as it was saved when the original execution ran. `loadWorkflow` changes which ' +
+        'workflow the retry runs, not what this field reports.',
+};
+exports.retriedExecutionCustomDataOpenApi = {
+    ...execution_public_openapi_1.customDataOpenApi,
+    description: 'Execution metadata carried over from the original execution.',
+};
+exports.retriedExecutionAnnotationOpenApi = {
+    description: 'Annotation on the original execution. Absent when it carries none.',
+};
+exports.executionAnnotationVoteOpenApi = (0, openapi_nullable_1.alsoNullable)({
+    enum: ['up', 'down'],
+    description: 'Vote left on the original execution.',
+});
+exports.loadWorkflowOpenApi = {
+    description: 'Whether to load the currently saved workflow to execute instead of the one saved at the ' +
+        'time of the execution. If set to true, it will retry with the latest version of the workflow.',
+};
+//# sourceMappingURL=retried-execution-public.openapi.js.map

package/dist/dto/executions/retried-execution-public.openapi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retried-execution-public.openapi.js","sourceRoot":"","sources":["../../../src/dto/executions/retried-execution-public.openapi.ts"],"names":[],"mappings":";;;AAEA,yEAKoC;AACpC,0DAAmD;AAEtC,QAAA,yBAAyB,GAAuB;IAC5D,WAAW,EAAE,iDAAiD;IAC9D,OAAO,EAAE,MAAM;CACf,CAAC;AAEW,QAAA,2BAA2B,GAAuB;IAC9D,GAAG,6CAAkB,CAAC,IAAI;IAC1B,OAAO,EAAE,OAAO;CAChB,CAAC;AAEW,QAAA,gCAAgC,GAAuB;IACnE,GAAG,6CAAkB,CAAC,SAAS;IAC/B,WAAW,EAAE,8CAA8C;CAC3D,CAAC;AAEW,QAAA,2BAA2B,GAAuB;IAC9D,GAAG,sCAAW;IACd,WAAW,EAAE,gCAAgC;CAC7C,CAAC;AAEW,QAAA,mCAAmC,GAAuB;IACtE,GAAG,8CAAmB;IACtB,WAAW,EACV,6FAA6F;QAC7F,uDAAuD;CACxD,CAAC;AAEW,QAAA,iCAAiC,GAAuB;IACpE,GAAG,4CAAiB;IACpB,WAAW,EAAE,8DAA8D;CAC3E,CAAC;AAEW,QAAA,iCAAiC,GAAuB;IACpE,WAAW,EAAE,oEAAoE;CACjF,CAAC;AAEW,QAAA,8BAA8B,GAAuB,IAAA,+BAAY,EAAC;IAC9E,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,sCAAsC;CACnD,CAAC,CAAC;AAEU,QAAA,mBAAmB,GAAuB;IACtD,WAAW,EACV,0FAA0F;QAC1F,+FAA+F;CAChG,CAAC"}

package/dist/dto/executions/retry-execution-public.dto.d.ts

@@ -0,0 +1,17 @@
+import '../../openapi-extend';
+import { z } from 'zod';
+export declare const retryExecutionPublicSchema: z.ZodObject<{
+    loadWorkflow: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    loadWorkflow?: boolean | undefined;
+}, {
+    loadWorkflow?: boolean | undefined;
+}>;
+declare const RetryExecutionPublicDto_base: import("../../zod-class").ZodClass<{
+    loadWorkflow?: boolean | undefined;
+}, {
+    loadWorkflow: z.ZodOptional<z.ZodBoolean>;
+}>;
+export declare class RetryExecutionPublicDto extends RetryExecutionPublicDto_base {
+}
+export {};

package/dist/dto/executions/retry-execution-public.dto.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryExecutionPublicDto = exports.retryExecutionPublicSchema = void 0;
+require("../../openapi-extend");
+const zod_1 = require("zod");
+const retried_execution_public_openapi_1 = require("./retried-execution-public.openapi");
+const zod_class_1 = require("../../zod-class");
+exports.retryExecutionPublicSchema = zod_1.z.object({
+    loadWorkflow: zod_1.z.boolean().optional().openapi(retried_execution_public_openapi_1.loadWorkflowOpenApi),
+});
+class RetryExecutionPublicDto extends zod_class_1.Z.class(exports.retryExecutionPublicSchema.shape) {
+}
+exports.RetryExecutionPublicDto = RetryExecutionPublicDto;
+//# sourceMappingURL=retry-execution-public.dto.js.map

package/dist/dto/executions/retry-execution-public.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-execution-public.dto.js","sourceRoot":"","sources":["../../../src/dto/executions/retry-execution-public.dto.ts"],"names":[],"mappings":";;;AAAA,gCAA8B;AAC9B,6BAAwB;AAExB,yFAAyE;AACzE,+CAAoC;AAEvB,QAAA,0BAA0B,GAAG,OAAC,CAAC,MAAM,CAAC;IAClD,YAAY,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,sDAAmB,CAAC;CACjE,CAAC,CAAC;AAEH,6BAAqC,SAAQ,aAAC,CAAC,KAAK,CAAC,QAAA,0BAA0B,CAAC,KAAK,CAAC;CAAG"}

package/dist/dto/executions/stop-many-executions-public.dto.d.ts

@@ -0,0 +1,23 @@
+import '../../openapi-extend';
+import { z } from 'zod';
+export declare const STOPPABLE_PUBLIC_EXECUTION_STATUSES: readonly ['queued', 'running', 'waiting'];
+export type StoppablePublicExecutionStatus = (typeof STOPPABLE_PUBLIC_EXECUTION_STATUSES)[number];
+export declare const STOPPABLE_PUBLIC_TO_INTERNAL_STATUS: {
+    readonly queued: 'new';
+    readonly running: 'running';
+    readonly waiting: 'waiting';
+};
+declare const StopManyExecutionsPublicDto_base: import("../../zod-class").ZodClass<{
+    status: ("queued" | "running" | "waiting")[];
+    workflowId?: string | undefined;
+    startedAfter?: string | undefined;
+    startedBefore?: string | undefined;
+}, {
+    status: z.ZodArray<z.ZodEnum<["queued", "running", "waiting"]>, "many">;
+    workflowId: z.ZodOptional<z.ZodString>;
+    startedAfter: z.ZodOptional<z.ZodString>;
+    startedBefore: z.ZodOptional<z.ZodString>;
+}>;
+export declare class StopManyExecutionsPublicDto extends StopManyExecutionsPublicDto_base {
+}
+export {};

package/dist/dto/executions/stop-many-executions-public.dto.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopManyExecutionsPublicDto = exports.STOPPABLE_PUBLIC_TO_INTERNAL_STATUS = exports.STOPPABLE_PUBLIC_EXECUTION_STATUSES = void 0;
+require("../../openapi-extend");
+const zod_1 = require("zod");
+const zod_class_1 = require("../../zod-class");
+exports.STOPPABLE_PUBLIC_EXECUTION_STATUSES = ['queued', 'running', 'waiting'];
+exports.STOPPABLE_PUBLIC_TO_INTERNAL_STATUS = {
+    queued: 'new',
+    running: 'running',
+    waiting: 'waiting',
+};
+class StopManyExecutionsPublicDto extends zod_class_1.Z.class({
+    status: zod_1.z
+        .array(zod_1.z.enum(exports.STOPPABLE_PUBLIC_EXECUTION_STATUSES))
+        .min(1, 'must include at least one status')
+        .openapi({
+        description: 'Array of execution statuses to stop. Must include at least one status.',
+        example: ['queued', 'running', 'waiting'],
+    }),
+    workflowId: zod_1.z
+        .string()
+        .optional()
+        .openapi({
+        description: 'Optional workflow ID to filter executions. If not provided, will stop executions ' +
+            'across all accessible workflows. The literal value `all` has the same effect as ' +
+            'omitting it.',
+        example: '2tUt1wbLX592XDdX',
+    }),
+    startedAfter: zod_1.z.string().datetime({ offset: true }).optional().openapi({
+        description: 'Only stop executions that started after this time.',
+        example: '2024-01-01T00:00:00.000Z',
+    }),
+    startedBefore: zod_1.z.string().datetime({ offset: true }).optional().openapi({
+        description: 'Only stop executions that started before this time.',
+        example: '2024-12-31T23:59:59.999Z',
+    }),
+}) {
+}
+exports.StopManyExecutionsPublicDto = StopManyExecutionsPublicDto;
+//# sourceMappingURL=stop-many-executions-public.dto.js.map