@boboddy/sdk 0.0.8-alpha → 0.0.10-alpha

package/dist/packages/core/src/lib/errors.d.ts

@@ -33,4 +33,5 @@ export declare class PersistenceError extends CoreError {
 export declare class ConfigurationError extends CoreError {
     constructor(message: string, code?: string);
 }
+export type ExpectedCoreError = ResourceNotFoundError | ResourceConflictError | ResourceOwnershipError | CoreValidationError;
 export {};

package/dist/packages/core/src/lib/result.d.ts

@@ -0,0 +1,15 @@
+export type Ok<T> = {
+    readonly ok: true;
+    readonly value: T;
+};
+export type Err<E> = {
+    readonly ok: false;
+    readonly error: E;
+};
+export type Result<T, E> = Ok<T> | Err<E>;
+export declare const Result: {
+    readonly ok: <T>(value: T) => Ok<T>;
+    readonly err: <E>(error: E) => Err<E>;
+    /** Throw the error if ok === false. Use at API route boundaries to re-enter the existing onError handler. */
+    readonly unwrap: <T, E extends Error>(result: Result<T, E>) => T;
+};

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

@@ -1,9 +1,13 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 import { type CreateLinearPipelineStepDefinitionInput, type GetLinearPipelineDefinitionInput, type LinearPipelineDefinitionContract } from "../contracts/linear-pipeline-definition-contracts";
 import type { LinearPipelineDefinitionRepo } from "./linear-pipeline-definition-repo";
-export declare const addLinearPipelineStepDefinition: (linearPipelineDefinitionIdInput: GetLinearPipelineDefinitionInput, input: CreateLinearPipelineStepDefinitionInput, { linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+export declare const addLinearPipelineStepDefinition: (linearPipelineDefinitionIdInput: GetLinearPipelineDefinitionInput, input: CreateLinearPipelineStepDefinitionInput, { userAuthz, linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineDefinitionContract>;
+}) => Promise<Result<LinearPipelineDefinitionContract, ResourceNotFoundError>>;

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

@@ -1,9 +1,13 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 import { type GetLinearPipelineDefinitionInput, type LinearPipelineDefinitionContract } from "../contracts/linear-pipeline-definition-contracts";
 import type { LinearPipelineDefinitionRepo } from "./linear-pipeline-definition-repo";
-export declare const archiveLinearPipelineDefinition: (input: GetLinearPipelineDefinitionInput, { linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+export declare const archiveLinearPipelineDefinition: (input: GetLinearPipelineDefinitionInput, { userAuthz, linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineDefinitionContract>;
+}) => Promise<Result<LinearPipelineDefinitionContract, ResourceNotFoundError>>;

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

@@ -1,8 +1,10 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 import { type CreateLinearPipelineDefinitionInput, type LinearPipelineDefinitionContract } from "../contracts/linear-pipeline-definition-contracts";
 import type { LinearPipelineDefinitionRepo } from "./linear-pipeline-definition-repo";
-export declare const createLinearPipelineDefinition: (input: CreateLinearPipelineDefinitionInput, { linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+export declare const createLinearPipelineDefinition: (input: CreateLinearPipelineDefinitionInput, { userAuthz, linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+    userAuthz?: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;

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

@@ -1,7 +1,11 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 import { type GetLinearPipelineDefinitionInput, type LinearPipelineDefinitionContract } from "../contracts/linear-pipeline-definition-contracts";
 import type { LinearPipelineDefinitionRepo } from "./linear-pipeline-definition-repo";
-export declare const getLinearPipelineDefinition: (input: GetLinearPipelineDefinitionInput, { linearPipelineDefinitionRepo, dbExecutor, }: {
+export declare const getLinearPipelineDefinition: (input: GetLinearPipelineDefinitionInput, { userAuthz, linearPipelineDefinitionRepo, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineDefinitionContract>;
+}) => Promise<Result<LinearPipelineDefinitionContract, ResourceNotFoundError>>;

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

@@ -1,7 +1,9 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 import { type LinearPipelineDefinitionContract, type ListLinearPipelineDefinitionsByProjectIdInput } from "../contracts/linear-pipeline-definition-contracts";
 import type { LinearPipelineDefinitionRepo } from "./linear-pipeline-definition-repo";
-export declare const listLinearPipelineDefinitionsByProjectId: (input: ListLinearPipelineDefinitionsByProjectIdInput, { linearPipelineDefinitionRepo, dbExecutor, }: {
+export declare const listLinearPipelineDefinitionsByProjectId: (input: ListLinearPipelineDefinitionsByProjectIdInput, { userAuthz, linearPipelineDefinitionRepo, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     dbExecutor?: DbExecutor | undefined;
 }) => Promise<LinearPipelineDefinitionContract[]>;

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

@@ -1,9 +1,13 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 import { type GetLinearPipelineDefinitionInput, type LinearPipelineDefinitionContract } from "../contracts/linear-pipeline-definition-contracts";
 import type { LinearPipelineDefinitionRepo } from "./linear-pipeline-definition-repo";
-export declare const removeLinearPipelineStepDefinition: (linearPipelineDefinitionIdInput: GetLinearPipelineDefinitionInput, linearPipelineStepDefinitionIdInput: GetLinearPipelineDefinitionInput, { linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+export declare const removeLinearPipelineStepDefinition: (linearPipelineDefinitionIdInput: GetLinearPipelineDefinitionInput, linearPipelineStepDefinitionIdInput: GetLinearPipelineDefinitionInput, { userAuthz, linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineDefinitionContract>;
+}) => Promise<Result<LinearPipelineDefinitionContract, ResourceNotFoundError>>;

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

@@ -1,9 +1,13 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 import { type GetLinearPipelineDefinitionInput, type LinearPipelineDefinitionContract, type SetLinearPipelineStepAdvancementPolicyDefinitionInput } from "../contracts/linear-pipeline-definition-contracts";
 import type { LinearPipelineDefinitionRepo } from "./linear-pipeline-definition-repo";
-export declare const setLinearPipelineStepAdvancementPolicyDefinition: (linearPipelineDefinitionIdInput: GetLinearPipelineDefinitionInput, linearPipelineStepDefinitionIdInput: GetLinearPipelineDefinitionInput, input: SetLinearPipelineStepAdvancementPolicyDefinitionInput, { linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+export declare const setLinearPipelineStepAdvancementPolicyDefinition: (linearPipelineDefinitionIdInput: GetLinearPipelineDefinitionInput, linearPipelineStepDefinitionIdInput: GetLinearPipelineDefinitionInput, input: SetLinearPipelineStepAdvancementPolicyDefinitionInput, { userAuthz, linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineDefinitionContract>;
+}) => Promise<Result<LinearPipelineDefinitionContract, ResourceNotFoundError>>;

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

@@ -1,9 +1,13 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 import { type GetLinearPipelineDefinitionInput, type LinearPipelineDefinitionContract, type UpdateLinearPipelineDefinitionInput } from "../contracts/linear-pipeline-definition-contracts";
 import type { LinearPipelineDefinitionRepo } from "./linear-pipeline-definition-repo";
-export declare const updateLinearPipelineDefinition: (linearPipelineDefinitionIdInput: GetLinearPipelineDefinitionInput, input: UpdateLinearPipelineDefinitionInput, { linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+export declare const updateLinearPipelineDefinition: (linearPipelineDefinitionIdInput: GetLinearPipelineDefinitionInput, input: UpdateLinearPipelineDefinitionInput, { userAuthz, linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineDefinitionContract>;
+}) => Promise<Result<LinearPipelineDefinitionContract, ResourceNotFoundError>>;

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

@@ -1,9 +1,13 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 import { type GetLinearPipelineDefinitionInput, type LinearPipelineDefinitionContract, type UpdateLinearPipelineStepDefinitionInput } from "../contracts/linear-pipeline-definition-contracts";
 import type { LinearPipelineDefinitionRepo } from "./linear-pipeline-definition-repo";
-export declare const updateLinearPipelineStepDefinition: (linearPipelineDefinitionIdInput: GetLinearPipelineDefinitionInput, linearPipelineStepDefinitionIdInput: GetLinearPipelineDefinitionInput, input: UpdateLinearPipelineStepDefinitionInput, { linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+export declare const updateLinearPipelineStepDefinition: (linearPipelineDefinitionIdInput: GetLinearPipelineDefinitionInput, linearPipelineStepDefinitionIdInput: GetLinearPipelineDefinitionInput, input: UpdateLinearPipelineStepDefinitionInput, { userAuthz, linearPipelineDefinitionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineDefinitionContract>;
+}) => Promise<Result<LinearPipelineDefinitionContract, ResourceNotFoundError>>;

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

@@ -1,9 +1,13 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const archiveStepDefinition: (input: GetStepDefinitionInput, { userAuthz, stepDefinitionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     stepDefinitionRepo: StepDefinitionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<StepDefinitionContract>;
+}) => Promise<Result<StepDefinitionContract, ResourceNotFoundError>>;

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

@@ -1,8 +1,10 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const createStepDefinition: (input: CreateStepDefinitionInput, { userAuthz, stepDefinitionRepo, timeProvider, dbExecutor, }: {
+    userAuthz?: UserAuthorizationService;
     stepDefinitionRepo: StepDefinitionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;

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

@@ -1,7 +1,11 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const getStepDefinition: (input: GetStepDefinitionInput, { userAuthz, stepDefinitionRepo, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     stepDefinitionRepo: StepDefinitionRepo;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<StepDefinitionContract>;
+}) => Promise<Result<StepDefinitionContract, ResourceNotFoundError>>;

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

@@ -1,7 +1,9 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const listStepDefinitionsByProjectId: (input: ListStepDefinitionsByProjectIdInput, { userAuthz, stepDefinitionRepo, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     stepDefinitionRepo: StepDefinitionRepo;
     dbExecutor?: DbExecutor | undefined;
 }) => Promise<StepDefinitionContract[]>;

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

@@ -1,9 +1,13 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const updateStepDefinition: (stepDefinitionIdInput: GetStepDefinitionInput, input: UpdateStepDefinitionInput, { userAuthz, stepDefinitionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     stepDefinitionRepo: StepDefinitionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<StepDefinitionContract>;
+}) => Promise<Result<StepDefinitionContract, ResourceNotFoundError>>;

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

@@ -1,6 +1,8 @@
 import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
 import { type StepDefinitionTemplateContract } from "../contracts/step-definition-template-contracts";
 import type { StepDefinitionTemplateRepo } from "./step-definition-template-repo";
 export declare const getStepDefinitionTemplate: (id: UuidV7, { stepDefinitionTemplateRepo }: {
     stepDefinitionTemplateRepo: StepDefinitionTemplateRepo;
-}) => Promise<StepDefinitionTemplateContract>;
+}) => Promise<Result<StepDefinitionTemplateContract, ResourceNotFoundError>>;

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

@@ -1,11 +1,15 @@
 import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
+import { ResourceNotFoundError, CoreValidationError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
 import type { StepDefinitionRepo } from "../../step-definition/application/step-definition-repo";
 import type { StepDefinitionContract } from "../../step-definition/contracts/step-definition-contracts";
 import { type InstantiateStepDefinitionTemplateInput } from "../contracts/step-definition-template-contracts";
 import type { StepDefinitionTemplateRepo } from "./step-definition-template-repo";
-export declare const instantiateStepDefinitionTemplate: (templateId: UuidV7, input: InstantiateStepDefinitionTemplateInput, { stepDefinitionTemplateRepo, stepDefinitionRepo, timeProvider, }: {
+export declare const instantiateStepDefinitionTemplate: (templateId: UuidV7, input: InstantiateStepDefinitionTemplateInput, { userAuthz, stepDefinitionTemplateRepo, stepDefinitionRepo, timeProvider, }: {
+    userAuthz: UserAuthorizationService;
     stepDefinitionTemplateRepo: StepDefinitionTemplateRepo;
     stepDefinitionRepo: StepDefinitionRepo;
     timeProvider: TimeProvider;
-}) => Promise<StepDefinitionContract>;
+}) => Promise<Result<StepDefinitionContract, ResourceNotFoundError | CoreValidationError>>;

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

@@ -1,13 +1,12 @@
 import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
-import type { AuthorizationService } from "@boboddy/core/access/authorization/application/authorization-service";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 import type { FeedbackRequestRepo } from "./feedback-request-repo";
 type DeclineFeedbackRequestInput = {
     projectId: UuidV7;
     feedbackRequestId: UuidV7;
 };
 type DeclineFeedbackRequestDeps = {
-    userId: UuidV7;
-    authz: AuthorizationService;
+    userAuthz: UserAuthorizationService;
     feedbackRequestRepo: FeedbackRequestRepo;
 };
 export declare const declineFeedbackRequest: (input: DeclineFeedbackRequestInput, deps: DeclineFeedbackRequestDeps) => Promise<null>;

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

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

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

@@ -1,15 +1,19 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { CoreValidationError, ResourceNotFoundError } from "@boboddy/core/lib/errors";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { Result } from "@boboddy/core/lib/result";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const acceptLinearPipelineStepRun: (input: AcceptLinearPipelineStepRunInput, { userAuthz, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepDefinitionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
     stepDefinitionRepo: StepDefinitionRepo;
     stepExecutionRepo: StepExecutionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineExecutionContract>;
+}) => Promise<Result<LinearPipelineExecutionContract, ResourceNotFoundError | CoreValidationError>>;

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

@@ -1,12 +1,16 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
 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 { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const applyLinearPipelineStepResultAndAdvance: (linearPipelineExecutionIdInput: GetLinearPipelineExecutionInput, linearPipelineStepRunIdInput: GetLinearPipelineExecutionInput, linearPipelineStepRunAttemptIdInput: GetLinearPipelineExecutionInput, input: ApplyLinearPipelineStepResultInput, { userAuthz, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepDefinitionRepo, stepExecutionRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
+    userAuthz?: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
     stepDefinitionRepo: StepDefinitionRepo;
@@ -14,4 +18,4 @@ export declare const applyLinearPipelineStepResultAndAdvance: (linearPipelineExe
     timeProvider: TimeProvider;
     domainEventDispatcher?: InMemoryDomainEventDispatcher;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineExecutionContract>;
+}) => Promise<Result<LinearPipelineExecutionContract, ResourceNotFoundError>>;

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

@@ -1,11 +1,15 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { Result } from "@boboddy/core/lib/result";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const cancelLinearPipelineExecution: (input: GetLinearPipelineExecutionInput, { userAuthz, linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
     stepExecutionRepo: StepExecutionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineExecutionContract>;
+}) => Promise<Result<LinearPipelineExecutionContract, ResourceNotFoundError>>;

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

@@ -1,11 +1,15 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { CoreValidationError, ResourceNotFoundError } from "@boboddy/core/lib/errors";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { Result } from "@boboddy/core/lib/result";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const createLinearPipelineExecution: (input: CreateLinearPipelineExecutionInput, { userAuthz, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineExecutionContract>;
+}) => Promise<Result<LinearPipelineExecutionContract, ResourceNotFoundError | CoreValidationError>>;

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

@@ -1,13 +1,17 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { Result } from "@boboddy/core/lib/result";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const createLinearPipelineStepRunAttempt: (linearPipelineExecutionIdInput: GetLinearPipelineExecutionInput, linearPipelineStepRunIdInput: GetLinearPipelineExecutionInput, { userAuthz, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
     stepExecutionRepo: StepExecutionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineExecutionContract>;
+}) => Promise<Result<LinearPipelineExecutionContract, ResourceNotFoundError>>;

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

@@ -1,11 +1,15 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
+import { Result } from "@boboddy/core/lib/result";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const getLinearPipelineExecution: (input: GetLinearPipelineExecutionInput, { userAuthz, linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
     stepExecutionRepo: StepExecutionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineExecutionContract>;
+}) => Promise<Result<LinearPipelineExecutionContract, ResourceNotFoundError>>;

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

@@ -1,9 +1,13 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 import type { StepExecutionRepo } from "@boboddy/core/pipeline-executions/step-execution/application/step-execution-repo";
+import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-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, }: {
+export declare const listLinearPipelineExecutionsByDefinitionId: (input: ListLinearPipelineExecutionsByDefinitionIdInput, { userAuthz, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
+    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
     stepExecutionRepo: StepExecutionRepo;
     timeProvider: TimeProvider;

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

@@ -1,9 +1,11 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const listLinearPipelineExecutionsByProjectId: (input: ListLinearPipelineExecutionsByProjectIdInput, { userAuthz, linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
     stepExecutionRepo: StepExecutionRepo;
     timeProvider: TimeProvider;

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

@@ -1,11 +1,15 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { Result } from "@boboddy/core/lib/result";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const markLinearPipelineStepRunAttemptRunning: (linearPipelineExecutionIdInput: GetLinearPipelineExecutionInput, linearPipelineStepRunIdInput: GetLinearPipelineExecutionInput, linearPipelineStepRunAttemptIdInput: GetLinearPipelineExecutionInput, { userAuthz, linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    userAuthz?: UserAuthorizationService;
     linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
     stepExecutionRepo: StepExecutionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineExecutionContract>;
+}) => Promise<Result<LinearPipelineExecutionContract, ResourceNotFoundError>>;

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

@@ -1,15 +1,19 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { CoreValidationError, ResourceNotFoundError } from "@boboddy/core/lib/errors";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { Result } from "@boboddy/core/lib/result";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const queueFirstLinearPipelineStepRun: (input: GetLinearPipelineExecutionInput, { userAuthz, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepDefinitionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
     stepDefinitionRepo: StepDefinitionRepo;
     stepExecutionRepo: StepExecutionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineExecutionContract>;
+}) => Promise<Result<LinearPipelineExecutionContract, ResourceNotFoundError | CoreValidationError>>;

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

@@ -1,13 +1,17 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { CoreValidationError, ResourceNotFoundError } from "@boboddy/core/lib/errors";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { Result } from "@boboddy/core/lib/result";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const retriggerLinearPipelineStepRun: (input: RetriggerLinearPipelineStepRunInput, { userAuthz, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
     stepExecutionRepo: StepExecutionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineExecutionContract>;
+}) => Promise<Result<LinearPipelineExecutionContract, ResourceNotFoundError | CoreValidationError>>;

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

@@ -1,15 +1,19 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { CoreValidationError, ResourceNotFoundError } from "@boboddy/core/lib/errors";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { Result } from "@boboddy/core/lib/result";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 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, }: {
+export declare const startLinearPipelineExecution: (input: GetLinearPipelineExecutionInput, { userAuthz, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, stepDefinitionRepo, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
     linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
     stepDefinitionRepo: StepDefinitionRepo;
     stepExecutionRepo: StepExecutionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<LinearPipelineExecutionContract>;
+}) => Promise<Result<LinearPipelineExecutionContract, ResourceNotFoundError | CoreValidationError>>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/add-step-execution-result.d.ts

@@ -1,9 +1,13 @@
 import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { ResourceNotFoundError } from "@boboddy/core/lib/errors";
 import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { Result } from "@boboddy/core/lib/result";
+import type { UserAuthorizationService } from "@boboddy/core/access/authorization/application/user-authorization-service";
 import { type AddStepExecutionResultInput, type StepExecutionResultContract } from "../contracts/step-execution-contracts";
 import type { StepExecutionRepo } from "./step-execution-repo";
-export declare const addStepExecutionResult: (input: AddStepExecutionResultInput, { stepExecutionRepo, timeProvider, dbExecutor, }: {
+export declare const addStepExecutionResult: (input: AddStepExecutionResultInput, { userAuthz, stepExecutionRepo, timeProvider, dbExecutor, }: {
+    userAuthz: UserAuthorizationService;
     stepExecutionRepo: StepExecutionRepo;
     timeProvider: TimeProvider;
     dbExecutor?: DbExecutor | undefined;
-}) => Promise<StepExecutionResultContract>;
+}) => Promise<Result<StepExecutionResultContract, ResourceNotFoundError>>;