@boboddy/sdk 0.0.7-alpha → 0.0.9-alpha

package/dist/packages/core/src/pipeline-executions/feedback-request/application/list-feedback-requests-by-step-signal.d.ts

@@ -0,0 +1,15 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { AuthorizationService } from "@boboddy/core/access/authorization/application/authorization-service";
+import type { FeedbackRequestContract } from "../contracts/feedback-request-contracts";
+import type { FeedbackRequestRepo } from "./feedback-request-repo";
+type ListFeedbackRequestsByStepSignalInput = {
+    projectId: UuidV7;
+    stepSignalId: UuidV7;
+};
+type ListFeedbackRequestsByStepSignalDeps = {
+    userId: UuidV7;
+    authz: AuthorizationService;
+    feedbackRequestRepo: FeedbackRequestRepo;
+};
+export declare const listFeedbackRequestsByStepSignal: (input: ListFeedbackRequestsByStepSignalInput, deps: ListFeedbackRequestsByStepSignalDeps) => Promise<FeedbackRequestContract[]>;
+export {};

package/dist/packages/core/src/pipeline-executions/feedback-request/contracts/feedback-request-contracts.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const feedbackRequestStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    answered: "answered";
+    declined: "declined";
+}>;
+export declare const feedbackRequestSchema: 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>>;
+    stepSignalId: 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>>;
+    question: z.ZodString;
+    category: z.ZodString;
+    suggestedKey: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        answered: "answered";
+        declined: "declined";
+    }>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type FeedbackRequestContract = z.infer<typeof feedbackRequestSchema>;

package/dist/packages/core/src/pipeline-executions/feedback-request/domain/feedback-request-entity.d.ts

@@ -0,0 +1,29 @@
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+export type FeedbackRequestStatus = "pending" | "answered" | "declined";
+export type FeedbackRequestEntityProps = {
+    id: UuidV7;
+    stepSignalId: UuidV7;
+    question: string;
+    category: string;
+    suggestedKey: string | null;
+    status: FeedbackRequestStatus;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type CreateFeedbackRequestEntityProps = Omit<FeedbackRequestEntityProps, "id"> & {
+    id?: UuidV7;
+};
+export declare class FeedbackRequestEntity {
+    readonly id: UuidV7;
+    readonly stepSignalId: UuidV7;
+    readonly question: string;
+    readonly category: string;
+    readonly suggestedKey: string | null;
+    readonly status: FeedbackRequestStatus;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    private constructor();
+    static create(props: CreateFeedbackRequestEntityProps): FeedbackRequestEntity;
+    static rehydrate(props: FeedbackRequestEntityProps): FeedbackRequestEntity;
+    toJSON(): FeedbackRequestEntityProps;
+}

package/dist/packages/core/src/pipeline-executions/feedback-request/infra/drizzle-feedback-request-repo.d.ts

@@ -0,0 +1,10 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { FeedbackRequestRepo } from "../application/feedback-request-repo";
+import { FeedbackRequestEntity, type FeedbackRequestStatus } from "../domain/feedback-request-entity";
+export declare class DrizzleFeedbackRequestRepo implements FeedbackRequestRepo {
+    private toEntity;
+    create(entity: FeedbackRequestEntity, dbExecutor?: DbExecutor): Promise<FeedbackRequestEntity>;
+    listByStepSignalId(stepSignalId: UuidV7, dbExecutor?: DbExecutor): Promise<FeedbackRequestEntity[]>;
+    updateStatus(id: UuidV7, status: FeedbackRequestStatus, dbExecutor?: DbExecutor): Promise<void>;
+}

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/accept-linear-pipeline-step-run.d.ts

@@ -0,0 +1,15 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-repo";
+import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+import { type AcceptLinearPipelineStepRunInput, type LinearPipelineExecutionContract } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionRepo } from "./linear-pipeline-execution-repo";
+export declare const acceptLinearPipelineStepRun: (input: AcceptLinearPipelineStepRunInput, { linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepDefinitionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    stepDefinitionRepo: StepDefinitionRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract>;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/apply-linear-pipeline-step-result-and-advance.d.ts

@@ -0,0 +1,17 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { InMemoryDomainEventDispatcher } from "@boboddy/core/lib/domain-events/in-memory-domain-event-dispatcher";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-repo";
+import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
+import { type ApplyLinearPipelineStepResultInput, type GetLinearPipelineExecutionInput, type LinearPipelineExecutionContract } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionRepo } from "./linear-pipeline-execution-repo";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+export declare const applyLinearPipelineStepResultAndAdvance: (linearPipelineExecutionIdInput: GetLinearPipelineExecutionInput, linearPipelineStepRunIdInput: GetLinearPipelineExecutionInput, linearPipelineStepRunAttemptIdInput: GetLinearPipelineExecutionInput, input: ApplyLinearPipelineStepResultInput, { linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepDefinitionRepo, stepExecutionRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
+    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    stepDefinitionRepo: StepDefinitionRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    domainEventDispatcher?: InMemoryDomainEventDispatcher;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract>;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/cancel-linear-pipeline-execution.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+import { type GetLinearPipelineExecutionInput, type LinearPipelineExecutionContract } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionRepo } from "./linear-pipeline-execution-repo";
+export declare const cancelLinearPipelineExecution: (input: GetLinearPipelineExecutionInput, { linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract>;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/create-linear-pipeline-execution.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { type CreateLinearPipelineExecutionInput, type LinearPipelineExecutionContract } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-repo";
+import type { LinearPipelineExecutionRepo } from "./linear-pipeline-execution-repo";
+export declare const createLinearPipelineExecution: (input: CreateLinearPipelineExecutionInput, { linearPipelineDefinitionRepo, linearPipelineExecutionRepo, timeProvider, dbExecutor, }: {
+    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract>;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/create-linear-pipeline-step-run-attempt.d.ts

@@ -0,0 +1,13 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-repo";
+import { type GetLinearPipelineExecutionInput, type LinearPipelineExecutionContract } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionRepo } from "./linear-pipeline-execution-repo";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+export declare const createLinearPipelineStepRunAttempt: (linearPipelineExecutionIdInput: GetLinearPipelineExecutionInput, linearPipelineStepRunIdInput: GetLinearPipelineExecutionInput, { linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract>;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/get-linear-pipeline-execution.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+import { type GetLinearPipelineExecutionInput, type LinearPipelineExecutionContract } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionRepo } from "./linear-pipeline-execution-repo";
+export declare const getLinearPipelineExecution: (input: GetLinearPipelineExecutionInput, { linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract>;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/linear-pipeline-execution-contract-mapper.d.ts

@@ -0,0 +1,3 @@
+import type { LinearPipelineExecutionContract } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionEntity } from "../domain/linear-pipeline-execution-entity";
+export declare const linearPipelineExecutionEntityToContract: (entity: LinearPipelineExecutionEntity) => LinearPipelineExecutionContract;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/linear-pipeline-execution-helpers.d.ts

@@ -0,0 +1,52 @@
+import type { AnyJsonObject, AnyJsonValue } from "@boboddy/core/common/contracts/json";
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
+import type { LinearPipelineDefinitionEntity } from "@boboddy/core/pipeline-definitions/pipeline-definition/domain/linear-pipeline-definition-entity";
+import type { LinearPipelineStepDefinitionEntity } from "@boboddy/core/pipeline-definitions/pipeline-definition/entities/linear-pipeline-step-definition-entity";
+import type { LinearPipelineExecutionEntity } from "../domain/linear-pipeline-execution-entity";
+import { LinearPipelineExecutionEventEntity } from "../entities/linear-pipeline-execution-event-entity";
+import { LinearPipelineStepEvaluationEntity, type LinearPipelineStepEvaluationFinalStatus } from "../entities/linear-pipeline-step-evaluation-entity";
+import { LinearPipelineStepRunAttemptEntity } from "../entities/linear-pipeline-step-run-attempt-entity";
+import { LinearPipelineStepRunEntity } from "../entities/linear-pipeline-step-run-entity";
+import { StepExecutionEntity } from "@boboddy/core/pipeline-executions/step-execution/domain/step-execution-entity";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+export declare const toJsonValue: (value: Record<string, unknown>) => AnyJsonValue;
+export declare const toFinalStatus: (action: LinearPipelineStepEvaluationEntity["finalAction"]) => LinearPipelineStepEvaluationFinalStatus;
+export declare const appendExecutionEvent: (execution: LinearPipelineExecutionEntity, type: LinearPipelineExecutionEventEntity["type"], now: Date, payloadJson?: AnyJsonObject | null) => import("../entities/linear-pipeline-execution-event-entity").LinearPipelineExecutionEventEntityProps;
+export declare const getStepRunOrThrow: (execution: LinearPipelineExecutionEntity, stepRunId: UuidV7) => LinearPipelineStepRunEntity;
+export declare const getStepRunAttemptOrThrow: (stepRun: LinearPipelineExecutionEntity["stepRuns"][number], stepRunAttemptId: UuidV7) => LinearPipelineStepRunAttemptEntity;
+export declare const getLinearPipelineStepDefinitionOrThrow: (definition: LinearPipelineDefinitionEntity, linearPipelineStepDefinitionId: UuidV7) => LinearPipelineStepDefinitionEntity;
+export declare const getNextLinearPipelineStepDefinition: (definition: LinearPipelineDefinitionEntity, position: number) => LinearPipelineStepDefinitionEntity | null;
+export declare const createQueuedStepExecution: (projectId: UuidV7, stepDefinitionId: UuidV7, stepDefinitionVersion: number, inputJson: AnyJsonValue | null, executionTimeoutSeconds: number | null, stepExecutionRepo: StepExecutionRepo, timeProvider: TimeProvider) => Promise<StepExecutionEntity>;
+export declare const createQueuedStepRun: (execution: LinearPipelineExecutionEntity, linearPipelineStepDefinition: LinearPipelineStepDefinitionEntity, stepDefinitionRepo: StepDefinitionRepo, stepExecutionRepo: StepExecutionRepo, timeProvider: TimeProvider) => Promise<{
+    stepRun: LinearPipelineStepRunEntity;
+    attempt: LinearPipelineStepRunAttemptEntity;
+}>;
+export declare const buildFactsSnapshot: (execution: LinearPipelineExecutionEntity, stepRun: LinearPipelineExecutionEntity["stepRuns"][number], attempt: LinearPipelineExecutionEntity["stepRuns"][number]["attempts"][number], stepExecutionId: UuidV7, stepExecutionResultId: UuidV7, signals: Record<string, AnyJsonValue>) => {
+    signals: Record<string, AnyJsonValue>;
+    context: {
+        projectId: UuidV7;
+        stepDefinitionId: UuidV7;
+        stepExecutionId: UuidV7;
+        stepExecutionResultId: UuidV7;
+        linearPipelineDefinitionId: UuidV7;
+        linearPipelineExecutionId: UuidV7;
+        linearPipelineStepDefinitionId: UuidV7;
+        linearPipelineStepRunId: UuidV7;
+        linearPipelineStepRunAttemptId: UuidV7;
+        currentStepKey: string;
+        currentPosition: number;
+    };
+};
+export declare const evaluateStepRunAgainstPolicy: ({ execution, stepRun, attempt, stepExecutionId, stepExecutionResultId, signals, policyDefinition, now, }: {
+    execution: LinearPipelineExecutionEntity;
+    stepRun: LinearPipelineExecutionEntity["stepRuns"][number];
+    attempt: LinearPipelineExecutionEntity["stepRuns"][number]["attempts"][number];
+    stepExecutionId: UuidV7;
+    stepExecutionResultId: UuidV7;
+    signals: Record<string, AnyJsonValue>;
+    policyDefinition: NonNullable<LinearPipelineStepDefinitionEntity["advancementPolicyDefinition"]>;
+    now: Date;
+}) => Promise<LinearPipelineStepEvaluationEntity>;
+export declare const ensurePolicyDefinition: (stepDefinition: LinearPipelineStepDefinitionEntity) => import("../../../pipeline-definitions/pipeline-definition/entities/linear-pipeline-step-advancement-policy-definition-entity").LinearPipelineStepAdvancementPolicyDefinitionEntity;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/linear-pipeline-execution-repo.d.ts

@@ -0,0 +1,15 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { LinearPipelineExecutionEntity } from "../domain/linear-pipeline-execution-entity";
+export type LinearPipelineExecutionRepo = {
+    loadStepExecutionLink(stepExecutionId: UuidV7, dbExecutor?: DbExecutor): Promise<{
+        linearPipelineExecutionId: UuidV7;
+        linearPipelineStepRunId: UuidV7;
+        linearPipelineStepRunAttemptId: UuidV7;
+    } | null>;
+    load(id: UuidV7, dbExecutor?: DbExecutor): Promise<LinearPipelineExecutionEntity | null>;
+    listByProjectId(projectId: UuidV7, dbExecutor?: DbExecutor): Promise<LinearPipelineExecutionEntity[]>;
+    listByDefinitionId(linearPipelineDefinitionId: UuidV7, dbExecutor?: DbExecutor): Promise<LinearPipelineExecutionEntity[]>;
+    create(linearPipelineExecution: LinearPipelineExecutionEntity, dbExecutor?: DbExecutor): Promise<LinearPipelineExecutionEntity>;
+    save(linearPipelineExecution: LinearPipelineExecutionEntity, dbExecutor?: DbExecutor): Promise<LinearPipelineExecutionEntity>;
+};

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/linear-pipeline-step-input-resolution.d.ts

@@ -0,0 +1,5 @@
+import type { AnyJsonObject, AnyJsonValue } from "@boboddy/core/common/contracts/json";
+import type { LinearPipelineStepDefinitionEntity } from "@boboddy/core/pipeline-definitions/pipeline-definition/entities/linear-pipeline-step-definition-entity";
+import type { LinearPipelineExecutionEntity } from "../domain/linear-pipeline-execution-entity";
+export declare const resolveLinearPipelineStepInput: (linearPipelineStepDefinition: LinearPipelineStepDefinitionEntity, execution: LinearPipelineExecutionEntity) => AnyJsonValue | null;
+export declare const validateStepExecutionInput: (inputJson: AnyJsonValue | null, inputSchemaJson: AnyJsonObject | null) => void;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/list-linear-pipeline-executions-by-definition.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+import { type LinearPipelineExecutionContract, type ListLinearPipelineExecutionsByDefinitionIdInput } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionRepo } from "./linear-pipeline-execution-repo";
+export declare const listLinearPipelineExecutionsByDefinitionId: (input: ListLinearPipelineExecutionsByDefinitionIdInput, { linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract[]>;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/list-linear-pipeline-executions.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+import { type LinearPipelineExecutionContract, type ListLinearPipelineExecutionsByProjectIdInput } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionRepo } from "./linear-pipeline-execution-repo";
+export declare const listLinearPipelineExecutionsByProjectId: (input: ListLinearPipelineExecutionsByProjectIdInput, { linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract[]>;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/mark-linear-pipeline-step-run-attempt-running.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { type GetLinearPipelineExecutionInput, type LinearPipelineExecutionContract } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionRepo } from "./linear-pipeline-execution-repo";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+export declare const markLinearPipelineStepRunAttemptRunning: (linearPipelineExecutionIdInput: GetLinearPipelineExecutionInput, linearPipelineStepRunIdInput: GetLinearPipelineExecutionInput, linearPipelineStepRunAttemptIdInput: GetLinearPipelineExecutionInput, { linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract>;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/project-linear-pipeline-executions.d.ts

@@ -0,0 +1,10 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+import type { LinearPipelineExecutionContract } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionEntity } from "../domain/linear-pipeline-execution-entity";
+export declare const projectLinearPipelineExecutionsToContracts: (executions: LinearPipelineExecutionEntity[], { stepExecutionRepo, timeProvider, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract[]>;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/queue-first-linear-pipeline-step-run.d.ts

@@ -0,0 +1,15 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-repo";
+import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
+import { type GetLinearPipelineExecutionInput, type LinearPipelineExecutionContract } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionRepo } from "./linear-pipeline-execution-repo";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+export declare const queueFirstLinearPipelineStepRun: (input: GetLinearPipelineExecutionInput, { linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepDefinitionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    stepDefinitionRepo: StepDefinitionRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract>;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/retrigger-linear-pipeline-step-run.d.ts

@@ -0,0 +1,13 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-repo";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+import { type LinearPipelineExecutionContract, type RetriggerLinearPipelineStepRunInput } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionRepo } from "./linear-pipeline-execution-repo";
+export declare const retriggerLinearPipelineStepRun: (input: RetriggerLinearPipelineStepRunInput, { linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract>;

package/dist/packages/core/src/pipeline-executions/pipeline-execution/application/start-linear-pipeline-execution.d.ts

@@ -0,0 +1,15 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-repo";
+import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
+import { type GetLinearPipelineExecutionInput, type LinearPipelineExecutionContract } from "../contracts/linear-pipeline-execution-contracts";
+import type { LinearPipelineExecutionRepo } from "./linear-pipeline-execution-repo";
+import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+export declare const startLinearPipelineExecution: (input: GetLinearPipelineExecutionInput, { linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepDefinitionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    stepDefinitionRepo: StepDefinitionRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<LinearPipelineExecutionContract>;