@boboddy/sdk 0.0.7-alpha → 0.0.8-alpha

package/dist/packages/core/src/pipeline-definitions/pipeline-definition/contracts/linear-pipeline-definition-contracts.d.ts

@@ -0,0 +1,357 @@
+import { z } from "zod";
+declare const inputBindingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"pipeline_input">;
+    path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"step_output">;
+    stepKey: z.ZodString;
+    path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"step_signal">;
+    stepKey: z.ZodString;
+    signalKey: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"literal">;
+    value: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+}, z.core.$strip>], "source">;
+declare const inputBindingsSchema: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"pipeline_input">;
+    path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"step_output">;
+    stepKey: z.ZodString;
+    path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"step_signal">;
+    stepKey: z.ZodString;
+    signalKey: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"literal">;
+    value: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+}, z.core.$strip>], "source">>;
+export declare const linearPipelineStepInputBindingsSchema: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"pipeline_input">;
+    path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"step_output">;
+    stepKey: z.ZodString;
+    path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"step_signal">;
+    stepKey: z.ZodString;
+    signalKey: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"literal">;
+    value: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+}, z.core.$strip>], "source">>;
+export declare const linearPipelineStepAdvancementPolicyDefinitionSchema: z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    linearPipelineStepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    rulesJson: z.ZodCustom<import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson, import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson>;
+    defaultEventType: z.ZodEnum<{
+        continue: "continue";
+        block: "block";
+        needs_review: "needs_review";
+        complete: "complete";
+    }>;
+    defaultEventParamsJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+    allowedEventTypes: z.ZodArray<z.ZodEnum<{
+        continue: "continue";
+        block: "block";
+        needs_review: "needs_review";
+        complete: "complete";
+    }>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const linearPipelineStepDefinitionSchema: z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    linearPipelineDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    stepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    stepDefinitionVersion: z.ZodNumber;
+    key: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    position: z.ZodNumber;
+    inputBindingsJson: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"pipeline_input">;
+        path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"step_output">;
+        stepKey: z.ZodString;
+        path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"step_signal">;
+        stepKey: z.ZodString;
+        signalKey: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+    }, z.core.$strip>], "source">>>;
+    timeoutSeconds: z.ZodNullable<z.ZodNumber>;
+    retryPolicyJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+    advancementPolicyDefinition: z.ZodObject<{
+        id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        linearPipelineStepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        rulesJson: z.ZodCustom<import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson, import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson>;
+        defaultEventType: z.ZodEnum<{
+            continue: "continue";
+            block: "block";
+            needs_review: "needs_review";
+            complete: "complete";
+        }>;
+        defaultEventParamsJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+        allowedEventTypes: z.ZodArray<z.ZodEnum<{
+            continue: "continue";
+            block: "block";
+            needs_review: "needs_review";
+            complete: "complete";
+        }>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const linearPipelineDefinitionSchema: z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    key: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    version: z.ZodNumber;
+    status: z.ZodEnum<{
+        draft: "draft";
+        active: "active";
+        archived: "archived";
+    }>;
+    stepDefinitions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        linearPipelineDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        stepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        stepDefinitionVersion: z.ZodNumber;
+        key: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        position: z.ZodNumber;
+        inputBindingsJson: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"pipeline_input">;
+            path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            source: z.ZodLiteral<"step_output">;
+            stepKey: z.ZodString;
+            path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            source: z.ZodLiteral<"step_signal">;
+            stepKey: z.ZodString;
+            signalKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+        }, z.core.$strip>], "source">>>;
+        timeoutSeconds: z.ZodNullable<z.ZodNumber>;
+        retryPolicyJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+        advancementPolicyDefinition: z.ZodObject<{
+            id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+            linearPipelineStepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+            rulesJson: z.ZodCustom<import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson, import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson>;
+            defaultEventType: z.ZodEnum<{
+                continue: "continue";
+                block: "block";
+                needs_review: "needs_review";
+                complete: "complete";
+            }>;
+            defaultEventParamsJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+            allowedEventTypes: z.ZodArray<z.ZodEnum<{
+                continue: "continue";
+                block: "block";
+                needs_review: "needs_review";
+                complete: "complete";
+            }>>;
+            createdAt: z.ZodISODateTime;
+            updatedAt: z.ZodISODateTime;
+        }, z.core.$strip>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const createLinearPipelineStepDefinitionInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    key: z.ZodString;
+    stepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    stepDefinitionVersion: z.ZodNumber;
+    position: z.ZodNumber;
+    inputBindingsJson: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"pipeline_input">;
+        path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"step_output">;
+        stepKey: z.ZodString;
+        path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"step_signal">;
+        stepKey: z.ZodString;
+        signalKey: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+    }, z.core.$strip>], "source">>>;
+    timeoutSeconds: z.ZodNullable<z.ZodNumber>;
+    retryPolicyJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+    advancementPolicyDefinition: z.ZodObject<{
+        rulesJson: z.ZodCustom<import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson, import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson>;
+        defaultEventType: z.ZodEnum<{
+            continue: "continue";
+            block: "block";
+            needs_review: "needs_review";
+            complete: "complete";
+        }>;
+        defaultEventParamsJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+        allowedEventTypes: z.ZodArray<z.ZodEnum<{
+            continue: "continue";
+            block: "block";
+            needs_review: "needs_review";
+            complete: "complete";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const createLinearPipelineDefinitionInputSchema: z.ZodObject<{
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    key: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    version: z.ZodNumber;
+    status: z.ZodEnum<{
+        draft: "draft";
+        active: "active";
+        archived: "archived";
+    }>;
+    stepDefinitions: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        key: z.ZodString;
+        stepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        stepDefinitionVersion: z.ZodNumber;
+        position: z.ZodNumber;
+        inputBindingsJson: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"pipeline_input">;
+            path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            source: z.ZodLiteral<"step_output">;
+            stepKey: z.ZodString;
+            path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            source: z.ZodLiteral<"step_signal">;
+            stepKey: z.ZodString;
+            signalKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+        }, z.core.$strip>], "source">>>;
+        timeoutSeconds: z.ZodNullable<z.ZodNumber>;
+        retryPolicyJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+        advancementPolicyDefinition: z.ZodObject<{
+            rulesJson: z.ZodCustom<import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson, import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson>;
+            defaultEventType: z.ZodEnum<{
+                continue: "continue";
+                block: "block";
+                needs_review: "needs_review";
+                complete: "complete";
+            }>;
+            defaultEventParamsJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+            allowedEventTypes: z.ZodArray<z.ZodEnum<{
+                continue: "continue";
+                block: "block";
+                needs_review: "needs_review";
+                complete: "complete";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const updateLinearPipelineDefinitionInputSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        draft: "draft";
+        active: "active";
+        archived: "archived";
+    }>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    key: z.ZodString;
+    version: z.ZodNumber;
+}, z.core.$strip>;
+export declare const updateLinearPipelineStepDefinitionInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    key: z.ZodString;
+    stepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    stepDefinitionVersion: z.ZodNumber;
+    position: z.ZodNumber;
+    inputBindingsJson: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"pipeline_input">;
+        path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"step_output">;
+        stepKey: z.ZodString;
+        path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"step_signal">;
+        stepKey: z.ZodString;
+        signalKey: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+    }, z.core.$strip>], "source">>>;
+    timeoutSeconds: z.ZodNullable<z.ZodNumber>;
+    retryPolicyJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+    advancementPolicyDefinition: z.ZodObject<{
+        rulesJson: z.ZodCustom<import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson, import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson>;
+        defaultEventType: z.ZodEnum<{
+            continue: "continue";
+            block: "block";
+            needs_review: "needs_review";
+            complete: "complete";
+        }>;
+        defaultEventParamsJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+        allowedEventTypes: z.ZodArray<z.ZodEnum<{
+            continue: "continue";
+            block: "block";
+            needs_review: "needs_review";
+            complete: "complete";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const setLinearPipelineStepAdvancementPolicyDefinitionInputSchema: z.ZodObject<{
+    rulesJson: z.ZodCustom<import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson, import("../entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyRulesJson>;
+    defaultEventType: z.ZodEnum<{
+        continue: "continue";
+        block: "block";
+        needs_review: "needs_review";
+        complete: "complete";
+    }>;
+    defaultEventParamsJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+    allowedEventTypes: z.ZodArray<z.ZodEnum<{
+        continue: "continue";
+        block: "block";
+        needs_review: "needs_review";
+        complete: "complete";
+    }>>;
+}, z.core.$strip>;
+export declare const getLinearPipelineDefinitionInputSchema: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+export declare const listLinearPipelineDefinitionsByProjectIdInputSchema: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+export type LinearPipelineStepAdvancementPolicyDefinitionContract = z.infer<typeof linearPipelineStepAdvancementPolicyDefinitionSchema>;
+export type LinearPipelineStepDefinitionContract = z.infer<typeof linearPipelineStepDefinitionSchema>;
+export type LinearPipelineStepInputBinding = z.infer<typeof inputBindingSchema>;
+export type LinearPipelineStepInputBindings = z.infer<typeof inputBindingsSchema>;
+export type LinearPipelineDefinitionContract = z.infer<typeof linearPipelineDefinitionSchema>;
+export type CreateLinearPipelineStepDefinitionInput = z.input<typeof createLinearPipelineStepDefinitionInputSchema>;
+export type CreateLinearPipelineDefinitionInput = z.input<typeof createLinearPipelineDefinitionInputSchema>;
+export type UpdateLinearPipelineDefinitionInput = z.input<typeof updateLinearPipelineDefinitionInputSchema>;
+export type UpdateLinearPipelineStepDefinitionInput = z.input<typeof updateLinearPipelineStepDefinitionInputSchema>;
+export type SetLinearPipelineStepAdvancementPolicyDefinitionInput = z.input<typeof setLinearPipelineStepAdvancementPolicyDefinitionInputSchema>;
+export type GetLinearPipelineDefinitionInput = z.input<typeof getLinearPipelineDefinitionInputSchema>;
+export type ListLinearPipelineDefinitionsByProjectIdInput = z.input<typeof listLinearPipelineDefinitionsByProjectIdInputSchema>;
+export {};

package/dist/packages/core/src/pipeline-definitions/pipeline-definition/domain/linear-pipeline-definition-entity.d.ts

@@ -0,0 +1,36 @@
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import { LinearPipelineStepDefinitionEntity, type LinearPipelineStepDefinitionEntityProps } from "../entities/linear-pipeline-step-definition-entity";
+export declare const linearPipelineDefinitionStatusValues: readonly ["draft", "active", "archived"];
+export type LinearPipelineDefinitionStatus = (typeof linearPipelineDefinitionStatusValues)[number];
+export type LinearPipelineDefinitionEntityProps = {
+    id: UuidV7;
+    projectId: UuidV7;
+    key: string;
+    name: string;
+    description?: string | null | undefined;
+    version: number;
+    status: LinearPipelineDefinitionStatus;
+    stepDefinitions: readonly LinearPipelineStepDefinitionEntityProps[];
+    createdAt?: Date | string | null | undefined;
+    updatedAt?: Date | string | null | undefined;
+};
+export type CreateLinearPipelineDefinitionEntityProps = Omit<LinearPipelineDefinitionEntityProps, "id"> & {
+    id?: UuidV7 | undefined;
+};
+export declare class LinearPipelineDefinitionEntity {
+    readonly id: UuidV7;
+    readonly projectId: UuidV7;
+    readonly key: string;
+    readonly name: string;
+    readonly description: string | null;
+    readonly version: number;
+    readonly status: LinearPipelineDefinitionStatus;
+    readonly stepDefinitions: LinearPipelineStepDefinitionEntity[];
+    readonly createdAt: Date | null | undefined;
+    readonly updatedAt: Date | null | undefined;
+    private constructor();
+    static create(props: CreateLinearPipelineDefinitionEntityProps): LinearPipelineDefinitionEntity;
+    static rehydrate(props: LinearPipelineDefinitionEntityProps): LinearPipelineDefinitionEntity;
+    archive(now: Date): LinearPipelineDefinitionEntity;
+    toJSON(): LinearPipelineDefinitionEntityProps;
+}

package/dist/packages/core/src/pipeline-definitions/pipeline-definition/entities/linear-pipeline-step-advancement-policy-definition-entity.d.ts

@@ -0,0 +1,42 @@
+import type { AnyJsonObject } from "@boboddy/core/common/contracts/json";
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { RuleProperties } from "json-rules-engine";
+import { z } from "zod";
+export declare const linearPipelineStepAdvancementPolicyEventTypeValues: readonly ["continue", "block", "needs_review", "complete"];
+export type LinearPipelineStepAdvancementPolicyEventType = (typeof linearPipelineStepAdvancementPolicyEventTypeValues)[number];
+export type LinearPipelineStepAdvancementPolicyRule = Omit<RuleProperties, "onSuccess" | "onFailure"> & Record<string, unknown>;
+export type LinearPipelineStepAdvancementPolicyRulesJson = {
+    rules: LinearPipelineStepAdvancementPolicyRule[];
+};
+export type LinearPipelineStepAdvancementPolicyDefinitionEntityProps = {
+    id: UuidV7;
+    linearPipelineStepDefinitionId: UuidV7;
+    rulesJson: LinearPipelineStepAdvancementPolicyRulesJson;
+    defaultEventType: LinearPipelineStepAdvancementPolicyEventType;
+    defaultEventParamsJson?: AnyJsonObject | null | undefined;
+    allowedEventTypes: LinearPipelineStepAdvancementPolicyEventType[];
+    createdAt?: Date | string | null | undefined;
+    updatedAt?: Date | string | null | undefined;
+};
+export type CreateLinearPipelineStepAdvancementPolicyDefinitionEntityProps = Omit<LinearPipelineStepAdvancementPolicyDefinitionEntityProps, "id"> & {
+    id?: UuidV7 | undefined;
+};
+export declare const linearPipelineStepAdvancementPolicyRuleSchema: z.ZodCustom<LinearPipelineStepAdvancementPolicyRule, LinearPipelineStepAdvancementPolicyRule>;
+export declare const linearPipelineStepAdvancementPolicyRulesJsonSchema: z.ZodCustom<LinearPipelineStepAdvancementPolicyRulesJson, LinearPipelineStepAdvancementPolicyRulesJson>;
+export declare const parseLinearPipelineStepAdvancementPolicyRules: (rulesJson: LinearPipelineStepAdvancementPolicyRulesJson, allowedEventTypes: readonly LinearPipelineStepAdvancementPolicyEventType[]) => LinearPipelineStepAdvancementPolicyRule[];
+export declare const validateLinearPipelineStepAdvancementPolicyDefinition: (rulesJson: LinearPipelineStepAdvancementPolicyRulesJson, allowedEventTypes: readonly LinearPipelineStepAdvancementPolicyEventType[]) => void;
+export declare class LinearPipelineStepAdvancementPolicyDefinitionEntity {
+    readonly id: UuidV7;
+    readonly linearPipelineStepDefinitionId: UuidV7;
+    readonly rulesJson: LinearPipelineStepAdvancementPolicyRulesJson;
+    readonly rules: LinearPipelineStepAdvancementPolicyRule[];
+    readonly defaultEventType: LinearPipelineStepAdvancementPolicyEventType;
+    readonly defaultEventParamsJson: AnyJsonObject | null;
+    readonly allowedEventTypes: LinearPipelineStepAdvancementPolicyEventType[];
+    readonly createdAt: Date | null | undefined;
+    readonly updatedAt: Date | null | undefined;
+    private constructor();
+    static create(props: CreateLinearPipelineStepAdvancementPolicyDefinitionEntityProps): LinearPipelineStepAdvancementPolicyDefinitionEntity;
+    static rehydrate(props: LinearPipelineStepAdvancementPolicyDefinitionEntityProps): LinearPipelineStepAdvancementPolicyDefinitionEntity;
+    toJSON(): LinearPipelineStepAdvancementPolicyDefinitionEntityProps;
+}

package/dist/packages/core/src/pipeline-definitions/pipeline-definition/entities/linear-pipeline-step-definition-entity.d.ts

@@ -0,0 +1,42 @@
+import type { AnyJsonObject } from "@boboddy/core/common/contracts/json";
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import { LinearPipelineStepAdvancementPolicyDefinitionEntity, type LinearPipelineStepAdvancementPolicyDefinitionEntityProps } from "./linear-pipeline-step-advancement-policy-definition-entity";
+export type LinearPipelineStepDefinitionEntityProps = {
+    id: UuidV7;
+    linearPipelineDefinitionId: UuidV7;
+    stepDefinitionId: UuidV7;
+    stepDefinitionVersion: number;
+    key: string;
+    name: string;
+    description?: string | null | undefined;
+    position: number;
+    inputBindingsJson?: AnyJsonObject | null | undefined;
+    timeoutSeconds?: number | null | undefined;
+    retryPolicyJson?: AnyJsonObject | null | undefined;
+    advancementPolicyDefinition: LinearPipelineStepAdvancementPolicyDefinitionEntityProps | null | undefined;
+    createdAt?: Date | string | null | undefined;
+    updatedAt?: Date | string | null | undefined;
+};
+export type CreateLinearPipelineStepDefinitionEntityProps = Omit<LinearPipelineStepDefinitionEntityProps, "id"> & {
+    id?: UuidV7 | undefined;
+};
+export declare class LinearPipelineStepDefinitionEntity {
+    readonly id: UuidV7;
+    readonly linearPipelineDefinitionId: UuidV7;
+    readonly stepDefinitionId: UuidV7;
+    readonly stepDefinitionVersion: number;
+    readonly key: string;
+    readonly name: string;
+    readonly description: string | null;
+    readonly position: number;
+    readonly inputBindingsJson: AnyJsonObject | null;
+    readonly timeoutSeconds: number | null;
+    readonly retryPolicyJson: AnyJsonObject | null;
+    readonly advancementPolicyDefinition: LinearPipelineStepAdvancementPolicyDefinitionEntity | null;
+    readonly createdAt: Date | null | undefined;
+    readonly updatedAt: Date | null | undefined;
+    private constructor();
+    static create(props: CreateLinearPipelineStepDefinitionEntityProps): LinearPipelineStepDefinitionEntity;
+    static rehydrate(props: LinearPipelineStepDefinitionEntityProps): LinearPipelineStepDefinitionEntity;
+    toJSON(): LinearPipelineStepDefinitionEntityProps;
+}

package/dist/packages/core/src/pipeline-definitions/pipeline-definition/infra/drizzle-linear-pipeline-definition-repo.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { LinearPipelineDefinitionRepo } from "../application/linear-pipeline-definition-repo";
+import { LinearPipelineDefinitionEntity, type LinearPipelineDefinitionEntityProps } from "../domain/linear-pipeline-definition-entity";
+export declare class DrizzleLinearPipelineDefinitionRepo implements LinearPipelineDefinitionRepo {
+    private toEntity;
+    private loadManyFromRows;
+    load(id: LinearPipelineDefinitionEntityProps["id"], dbExecutor?: DbExecutor): Promise<LinearPipelineDefinitionEntity | null>;
+    listByProjectId(projectId: LinearPipelineDefinitionEntityProps["projectId"], dbExecutor?: DbExecutor): Promise<LinearPipelineDefinitionEntity[]>;
+    create(linearPipelineDefinition: LinearPipelineDefinitionEntity, dbExecutor?: DbExecutor): Promise<LinearPipelineDefinitionEntity>;
+    save(linearPipelineDefinition: LinearPipelineDefinitionEntity, dbExecutor?: DbExecutor): Promise<LinearPipelineDefinitionEntity>;
+}

package/dist/packages/core/src/pipeline-definitions/step-definition/application/archive-step-definition.d.ts

@@ -0,0 +1,9 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { type GetStepDefinitionInput, type StepDefinitionContract } from "../contracts/step-definition-contracts";
+import type { StepDefinitionRepo } from "./step-definition-repo";
+export declare const archiveStepDefinition: (input: GetStepDefinitionInput, { stepDefinitionRepo, timeProvider, dbExecutor, }: {
+    stepDefinitionRepo: StepDefinitionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepDefinitionContract>;

package/dist/packages/core/src/pipeline-definitions/step-definition/application/create-step-definition.d.ts

@@ -0,0 +1,9 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { type CreateStepDefinitionInput, type StepDefinitionContract } from "../contracts/step-definition-contracts";
+import type { StepDefinitionRepo } from "./step-definition-repo";
+export declare const createStepDefinition: (input: CreateStepDefinitionInput, { stepDefinitionRepo, timeProvider, dbExecutor, }: {
+    stepDefinitionRepo: StepDefinitionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepDefinitionContract>;

package/dist/packages/core/src/pipeline-definitions/step-definition/application/get-step-definition.d.ts

@@ -0,0 +1,7 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { type GetStepDefinitionInput, type StepDefinitionContract } from "../contracts/step-definition-contracts";
+import type { StepDefinitionRepo } from "./step-definition-repo";
+export declare const getStepDefinition: (input: GetStepDefinitionInput, { stepDefinitionRepo, dbExecutor, }: {
+    stepDefinitionRepo: StepDefinitionRepo;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepDefinitionContract>;

package/dist/packages/core/src/pipeline-definitions/step-definition/application/list-step-definitions.d.ts

@@ -0,0 +1,7 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { type ListStepDefinitionsByProjectIdInput, type StepDefinitionContract } from "../contracts/step-definition-contracts";
+import type { StepDefinitionRepo } from "./step-definition-repo";
+export declare const listStepDefinitionsByProjectId: (input: ListStepDefinitionsByProjectIdInput, { stepDefinitionRepo, dbExecutor, }: {
+    stepDefinitionRepo: StepDefinitionRepo;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepDefinitionContract[]>;

package/dist/packages/core/src/pipeline-definitions/step-definition/application/step-definition-contract-mapper.d.ts

@@ -0,0 +1,3 @@
+import type { StepDefinitionContract } from "../contracts/step-definition-contracts";
+import type { StepDefinitionEntity } from "../domain/step-definition-entity";
+export declare const stepDefinitionEntityToContract: (stepDefinition: StepDefinitionEntity) => StepDefinitionContract;

package/dist/packages/core/src/pipeline-definitions/step-definition/application/step-definition-repo.d.ts

@@ -0,0 +1,9 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { StepDefinitionEntity } from "../domain/step-definition-entity";
+export type StepDefinitionRepo = {
+    load(id: UuidV7, dbExecutor?: DbExecutor): Promise<StepDefinitionEntity | null>;
+    listByProjectId(projectId: UuidV7, dbExecutor?: DbExecutor): Promise<StepDefinitionEntity[]>;
+    create(stepDefinition: StepDefinitionEntity, dbExecutor?: DbExecutor): Promise<StepDefinitionEntity>;
+    save(stepDefinition: StepDefinitionEntity, dbExecutor?: DbExecutor): Promise<StepDefinitionEntity>;
+};

package/dist/packages/core/src/pipeline-definitions/step-definition/application/update-step-definition.d.ts

@@ -0,0 +1,9 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { type GetStepDefinitionInput, type StepDefinitionContract, type UpdateStepDefinitionInput } from "../contracts/step-definition-contracts";
+import type { StepDefinitionRepo } from "./step-definition-repo";
+export declare const updateStepDefinition: (stepDefinitionIdInput: GetStepDefinitionInput, input: UpdateStepDefinitionInput, { stepDefinitionRepo, timeProvider, dbExecutor, }: {
+    stepDefinitionRepo: StepDefinitionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepDefinitionContract>;