@contractspec/example.workflow-system 1.57.0 → 1.59.0

package/dist/entities/index.js

@@ -1,32 +1,509 @@
-import { ApprovalCommentEntity, ApprovalDecisionEnum, ApprovalRequestEntity, ApprovalStatusEnum } from "./approval.js";
-import { WorkflowDefinitionEntity, WorkflowStatusEnum, WorkflowTriggerTypeEnum } from "./workflow.js";
-import { ApprovalModeEnum, StepTypeEnum, WorkflowStepEntity } from "./step.js";
-import { InstanceStatusEnum, StepExecutionEntity, StepExecutionStatusEnum, WorkflowInstanceEntity } from "./instance.js";
+// @bun
+// src/entities/approval.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var ApprovalStatusEnum = defineEntityEnum({
+  name: "ApprovalStatus",
+  values: [
+    "PENDING",
+    "APPROVED",
+    "REJECTED",
+    "DELEGATED",
+    "ESCALATED",
+    "WITHDRAWN",
+    "EXPIRED"
+  ],
+  schema: "workflow",
+  description: "Status of an approval request."
+});
+var ApprovalDecisionEnum = defineEntityEnum({
+  name: "ApprovalDecision",
+  values: [
+    "APPROVE",
+    "REJECT",
+    "REQUEST_CHANGES",
+    "DELEGATE",
+    "ABSTAIN"
+  ],
+  schema: "workflow",
+  description: "Possible approval decisions."
+});
+var ApprovalRequestEntity = defineEntity({
+  name: "ApprovalRequest",
+  description: "A pending approval request for a workflow step.",
+  schema: "workflow",
+  map: "approval_request",
+  fields: {
+    id: field.id({ description: "Unique approval request ID" }),
+    workflowInstanceId: field.foreignKey(),
+    stepExecutionId: field.foreignKey(),
+    approverId: field.foreignKey({ description: "User requested to approve" }),
+    approverRole: field.string({
+      isOptional: true,
+      description: "Role of the approver"
+    }),
+    title: field.string({ description: "Approval request title" }),
+    description: field.string({ isOptional: true }),
+    status: field.enum("ApprovalStatus", { default: "PENDING" }),
+    decision: field.enum("ApprovalDecision", { isOptional: true }),
+    decisionComment: field.string({
+      isOptional: true,
+      description: "Comment explaining decision"
+    }),
+    decidedAt: field.dateTime({ isOptional: true }),
+    delegatedTo: field.string({
+      isOptional: true,
+      description: "User delegated to"
+    }),
+    delegationReason: field.string({ isOptional: true }),
+    escalationLevel: field.int({
+      default: 0,
+      description: "Current escalation level"
+    }),
+    escalatedAt: field.dateTime({ isOptional: true }),
+    dueAt: field.dateTime({
+      isOptional: true,
+      description: "When approval is due"
+    }),
+    reminderSentAt: field.dateTime({ isOptional: true }),
+    contextSnapshot: field.json({
+      isOptional: true,
+      description: "Snapshot of relevant data for review"
+    }),
+    sequenceOrder: field.int({
+      default: 0,
+      description: "Order in approval chain"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    workflowInstance: field.belongsTo("WorkflowInstance", ["workflowInstanceId"], ["id"], { onDelete: "Cascade" }),
+    stepExecution: field.belongsTo("StepExecution", ["stepExecutionId"], ["id"])
+  },
+  indexes: [
+    index.on(["approverId", "status"]),
+    index.on(["workflowInstanceId", "status"]),
+    index.on(["stepExecutionId"]),
+    index.on(["status", "dueAt"]),
+    index.on(["createdAt"])
+  ],
+  enums: [ApprovalStatusEnum, ApprovalDecisionEnum]
+});
+var ApprovalCommentEntity = defineEntity({
+  name: "ApprovalComment",
+  description: "A comment on an approval request.",
+  schema: "workflow",
+  map: "approval_comment",
+  fields: {
+    id: field.id(),
+    approvalRequestId: field.foreignKey(),
+    authorId: field.foreignKey(),
+    content: field.string({ description: "Comment text" }),
+    isInternal: field.boolean({
+      default: false,
+      description: "Internal note vs public comment"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    approvalRequest: field.belongsTo("ApprovalRequest", ["approvalRequestId"], ["id"], { onDelete: "Cascade" })
+  },
+  indexes: [index.on(["approvalRequestId", "createdAt"])]
+});
 
-//#region src/entities/index.ts
-const workflowSystemEntities = [
-	WorkflowDefinitionEntity,
-	WorkflowStepEntity,
-	WorkflowInstanceEntity,
-	StepExecutionEntity,
-	ApprovalRequestEntity,
-	ApprovalCommentEntity
+// src/entities/workflow.ts
+import {
+  defineEntity as defineEntity2,
+  defineEntityEnum as defineEntityEnum2,
+  field as field2,
+  index as index2
+} from "@contractspec/lib.schema";
+var WorkflowStatusEnum = defineEntityEnum2({
+  name: "WorkflowStatus",
+  values: ["DRAFT", "ACTIVE", "DEPRECATED", "ARCHIVED"],
+  schema: "workflow",
+  description: "Status of a workflow definition."
+});
+var WorkflowTriggerTypeEnum = defineEntityEnum2({
+  name: "WorkflowTriggerType",
+  values: ["MANUAL", "EVENT", "SCHEDULED", "API"],
+  schema: "workflow",
+  description: "What triggers workflow instantiation."
+});
+var WorkflowDefinitionEntity = defineEntity2({
+  name: "WorkflowDefinition",
+  description: "A workflow blueprint that defines the process structure.",
+  schema: "workflow",
+  map: "workflow_definition",
+  fields: {
+    id: field2.id({ description: "Unique workflow definition ID" }),
+    name: field2.string({ description: "Human-readable workflow name" }),
+    key: field2.string({
+      description: 'Unique key for referencing (e.g., "purchase_approval")'
+    }),
+    description: field2.string({
+      isOptional: true,
+      description: "Detailed description"
+    }),
+    version: field2.int({
+      default: 1,
+      description: "Version number for versioning definitions"
+    }),
+    status: field2.enum("WorkflowStatus", { default: "DRAFT" }),
+    triggerType: field2.enum("WorkflowTriggerType", { default: "MANUAL" }),
+    triggerConfig: field2.json({
+      isOptional: true,
+      description: "Trigger-specific configuration"
+    }),
+    initialStepId: field2.string({
+      isOptional: true,
+      description: "First step when workflow starts"
+    }),
+    featureFlagKey: field2.string({
+      isOptional: true,
+      description: "Feature flag to control availability"
+    }),
+    settings: field2.json({
+      isOptional: true,
+      description: "Workflow-wide settings"
+    }),
+    metadata: field2.json({ isOptional: true, description: "Custom metadata" }),
+    organizationId: field2.foreignKey({ description: "Owning organization" }),
+    createdBy: field2.foreignKey({
+      description: "User who created this workflow"
+    }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    publishedAt: field2.dateTime({
+      isOptional: true,
+      description: "When workflow was activated"
+    }),
+    steps: field2.hasMany("WorkflowStep"),
+    instances: field2.hasMany("WorkflowInstance")
+  },
+  indexes: [
+    index2.unique(["organizationId", "key", "version"]),
+    index2.on(["organizationId", "status"]),
+    index2.on(["key", "version"])
+  ],
+  enums: [WorkflowStatusEnum, WorkflowTriggerTypeEnum]
+});
+
+// src/entities/step.ts
+import {
+  defineEntity as defineEntity3,
+  defineEntityEnum as defineEntityEnum3,
+  field as field3,
+  index as index3
+} from "@contractspec/lib.schema";
+var StepTypeEnum = defineEntityEnum3({
+  name: "StepType",
+  values: [
+    "START",
+    "APPROVAL",
+    "TASK",
+    "CONDITION",
+    "PARALLEL",
+    "WAIT",
+    "ACTION",
+    "END"
+  ],
+  schema: "workflow",
+  description: "Type of workflow step."
+});
+var ApprovalModeEnum = defineEntityEnum3({
+  name: "ApprovalMode",
+  values: [
+    "ANY",
+    "ALL",
+    "MAJORITY",
+    "SEQUENTIAL"
+  ],
+  schema: "workflow",
+  description: "How multiple approvers are handled."
+});
+var WorkflowStepEntity = defineEntity3({
+  name: "WorkflowStep",
+  description: "A single step/state in a workflow definition.",
+  schema: "workflow",
+  map: "workflow_step",
+  fields: {
+    id: field3.id({ description: "Unique step ID" }),
+    workflowDefinitionId: field3.foreignKey(),
+    name: field3.string({ description: "Human-readable step name" }),
+    key: field3.string({
+      description: 'Unique key within workflow (e.g., "manager_approval")'
+    }),
+    description: field3.string({ isOptional: true }),
+    type: field3.enum("StepType", { default: "TASK" }),
+    position: field3.int({ default: 0, description: "Order for display" }),
+    transitions: field3.json({ description: "Map of action -> next step key" }),
+    approvalMode: field3.enum("ApprovalMode", {
+      default: "ANY",
+      isOptional: true
+    }),
+    approverRoles: field3.string({
+      isArray: true,
+      description: "Roles that can approve"
+    }),
+    approverUserIds: field3.string({
+      isArray: true,
+      description: "Specific users that can approve"
+    }),
+    escalationConfig: field3.json({
+      isOptional: true,
+      description: "Escalation rules"
+    }),
+    assigneeRoles: field3.string({
+      isArray: true,
+      description: "Roles that can be assigned"
+    }),
+    taskTemplate: field3.json({
+      isOptional: true,
+      description: "Template for task creation"
+    }),
+    conditionExpression: field3.string({
+      isOptional: true,
+      description: "Expression for branching"
+    }),
+    waitDuration: field3.int({
+      isOptional: true,
+      description: "Wait duration in seconds"
+    }),
+    waitForEvent: field3.string({
+      isOptional: true,
+      description: "Event name to wait for"
+    }),
+    actionType: field3.string({
+      isOptional: true,
+      description: "Action to execute"
+    }),
+    actionConfig: field3.json({
+      isOptional: true,
+      description: "Action parameters"
+    }),
+    timeoutSeconds: field3.int({
+      isOptional: true,
+      description: "Step timeout"
+    }),
+    slaSeconds: field3.int({ isOptional: true, description: "SLA deadline" }),
+    notifyOnEnter: field3.json({
+      isOptional: true,
+      description: "Notification config when entering step"
+    }),
+    notifyOnExit: field3.json({
+      isOptional: true,
+      description: "Notification config when exiting step"
+    }),
+    metadata: field3.json({ isOptional: true }),
+    createdAt: field3.createdAt(),
+    updatedAt: field3.updatedAt(),
+    workflowDefinition: field3.belongsTo("WorkflowDefinition", ["workflowDefinitionId"], ["id"], { onDelete: "Cascade" }),
+    executions: field3.hasMany("StepExecution")
+  },
+  indexes: [
+    index3.unique(["workflowDefinitionId", "key"]),
+    index3.on(["workflowDefinitionId", "position"]),
+    index3.on(["type"])
+  ],
+  enums: [StepTypeEnum, ApprovalModeEnum]
+});
+
+// src/entities/instance.ts
+import {
+  defineEntity as defineEntity4,
+  defineEntityEnum as defineEntityEnum4,
+  field as field4,
+  index as index4
+} from "@contractspec/lib.schema";
+var InstanceStatusEnum = defineEntityEnum4({
+  name: "InstanceStatus",
+  values: [
+    "PENDING",
+    "RUNNING",
+    "WAITING",
+    "PAUSED",
+    "COMPLETED",
+    "CANCELLED",
+    "FAILED",
+    "TIMEOUT"
+  ],
+  schema: "workflow",
+  description: "Status of a workflow instance."
+});
+var StepExecutionStatusEnum = defineEntityEnum4({
+  name: "StepExecutionStatus",
+  values: [
+    "PENDING",
+    "ACTIVE",
+    "COMPLETED",
+    "SKIPPED",
+    "FAILED",
+    "TIMEOUT"
+  ],
+  schema: "workflow",
+  description: "Status of a step execution."
+});
+var WorkflowInstanceEntity = defineEntity4({
+  name: "WorkflowInstance",
+  description: "A running instance of a workflow definition.",
+  schema: "workflow",
+  map: "workflow_instance",
+  fields: {
+    id: field4.id({ description: "Unique instance ID" }),
+    workflowDefinitionId: field4.foreignKey(),
+    referenceId: field4.string({
+      isOptional: true,
+      description: "External reference (e.g., order ID)"
+    }),
+    referenceType: field4.string({
+      isOptional: true,
+      description: 'Type of reference (e.g., "Order")'
+    }),
+    status: field4.enum("InstanceStatus", { default: "PENDING" }),
+    currentStepId: field4.string({
+      isOptional: true,
+      description: "Current step being executed"
+    }),
+    contextData: field4.json({ description: "Data context for this instance" }),
+    triggeredBy: field4.foreignKey({
+      description: "User who triggered the workflow"
+    }),
+    triggerSource: field4.string({
+      isOptional: true,
+      description: 'Source of trigger (e.g., "api", "ui")'
+    }),
+    organizationId: field4.foreignKey(),
+    priority: field4.int({
+      default: 0,
+      description: "Processing priority (higher = more urgent)"
+    }),
+    dueAt: field4.dateTime({
+      isOptional: true,
+      description: "When this instance should complete"
+    }),
+    outcome: field4.string({
+      isOptional: true,
+      description: 'Final outcome (e.g., "approved", "rejected")'
+    }),
+    resultData: field4.json({
+      isOptional: true,
+      description: "Final result data"
+    }),
+    errorMessage: field4.string({
+      isOptional: true,
+      description: "Error message if failed"
+    }),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    startedAt: field4.dateTime({ isOptional: true }),
+    completedAt: field4.dateTime({ isOptional: true }),
+    workflowDefinition: field4.belongsTo("WorkflowDefinition", ["workflowDefinitionId"], ["id"]),
+    currentStep: field4.belongsTo("WorkflowStep", ["currentStepId"], ["id"]),
+    stepExecutions: field4.hasMany("StepExecution"),
+    approvalRequests: field4.hasMany("ApprovalRequest")
+  },
+  indexes: [
+    index4.on(["organizationId", "status"]),
+    index4.on(["workflowDefinitionId", "status"]),
+    index4.on(["referenceType", "referenceId"]),
+    index4.on(["triggeredBy", "status"]),
+    index4.on(["status", "dueAt"]),
+    index4.on(["createdAt"])
+  ],
+  enums: [InstanceStatusEnum]
+});
+var StepExecutionEntity = defineEntity4({
+  name: "StepExecution",
+  description: "Execution record of a step within a workflow instance.",
+  schema: "workflow",
+  map: "step_execution",
+  fields: {
+    id: field4.id({ description: "Unique execution ID" }),
+    workflowInstanceId: field4.foreignKey(),
+    workflowStepId: field4.foreignKey(),
+    status: field4.enum("StepExecutionStatus", { default: "PENDING" }),
+    executionOrder: field4.int({
+      default: 0,
+      description: "Order of execution within instance"
+    }),
+    inputData: field4.json({
+      isOptional: true,
+      description: "Data when entering step"
+    }),
+    outputData: field4.json({
+      isOptional: true,
+      description: "Data when exiting step"
+    }),
+    actionTaken: field4.string({
+      isOptional: true,
+      description: 'Action that caused transition (e.g., "approve")'
+    }),
+    transitionedTo: field4.string({
+      isOptional: true,
+      description: "Step key transitioned to"
+    }),
+    executedBy: field4.string({
+      isOptional: true,
+      description: "User who completed this step"
+    }),
+    errorMessage: field4.string({ isOptional: true }),
+    errorDetails: field4.json({ isOptional: true }),
+    retryCount: field4.int({ default: 0 }),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    startedAt: field4.dateTime({ isOptional: true }),
+    completedAt: field4.dateTime({ isOptional: true }),
+    workflowInstance: field4.belongsTo("WorkflowInstance", ["workflowInstanceId"], ["id"], { onDelete: "Cascade" }),
+    workflowStep: field4.belongsTo("WorkflowStep", ["workflowStepId"], ["id"])
+  },
+  indexes: [
+    index4.on(["workflowInstanceId", "executionOrder"]),
+    index4.on(["workflowInstanceId", "workflowStepId"]),
+    index4.on(["status"])
+  ],
+  enums: [StepExecutionStatusEnum]
+});
+// src/entities/index.ts
+var workflowSystemEntities = [
+  WorkflowDefinitionEntity,
+  WorkflowStepEntity,
+  WorkflowInstanceEntity,
+  StepExecutionEntity,
+  ApprovalRequestEntity,
+  ApprovalCommentEntity
 ];
-const workflowSystemSchemaContribution = {
-	moduleId: "@contractspec/example.workflow-system",
-	entities: workflowSystemEntities,
-	enums: [
-		WorkflowStatusEnum,
-		WorkflowTriggerTypeEnum,
-		StepTypeEnum,
-		ApprovalModeEnum,
-		InstanceStatusEnum,
-		StepExecutionStatusEnum,
-		ApprovalStatusEnum,
-		ApprovalDecisionEnum
-	]
+var workflowSystemSchemaContribution = {
+  moduleId: "@contractspec/example.workflow-system",
+  entities: workflowSystemEntities,
+  enums: [
+    WorkflowStatusEnum,
+    WorkflowTriggerTypeEnum,
+    StepTypeEnum,
+    ApprovalModeEnum,
+    InstanceStatusEnum,
+    StepExecutionStatusEnum,
+    ApprovalStatusEnum,
+    ApprovalDecisionEnum
+  ]
+};
+export {
+  workflowSystemSchemaContribution,
+  workflowSystemEntities,
+  WorkflowTriggerTypeEnum,
+  WorkflowStepEntity,
+  WorkflowStatusEnum,
+  WorkflowInstanceEntity,
+  WorkflowDefinitionEntity,
+  StepTypeEnum,
+  StepExecutionStatusEnum,
+  StepExecutionEntity,
+  InstanceStatusEnum,
+  ApprovalStatusEnum,
+  ApprovalRequestEntity,
+  ApprovalModeEnum,
+  ApprovalDecisionEnum,
+  ApprovalCommentEntity
 };
-
-//#endregion
-export { ApprovalCommentEntity, ApprovalDecisionEnum, ApprovalModeEnum, ApprovalRequestEntity, ApprovalStatusEnum, InstanceStatusEnum, StepExecutionEntity, StepExecutionStatusEnum, StepTypeEnum, WorkflowDefinitionEntity, WorkflowInstanceEntity, WorkflowStatusEnum, WorkflowStepEntity, WorkflowTriggerTypeEnum, workflowSystemEntities, workflowSystemSchemaContribution };
-//# sourceMappingURL=index.js.map

package/dist/entities/instance.d.ts

@@ -1,69 +1,64 @@
-import * as _contractspec_lib_schema0 from "@contractspec/lib.schema";
-
-//#region src/entities/instance.d.ts
 /**
  * Instance status enum - lifecycle of a workflow instance.
  */
-declare const InstanceStatusEnum: _contractspec_lib_schema0.EntityEnumDef;
+export declare const InstanceStatusEnum: import("@contractspec/lib.schema").EntityEnumDef;
 /**
  * Step execution status enum.
  */
-declare const StepExecutionStatusEnum: _contractspec_lib_schema0.EntityEnumDef;
+export declare const StepExecutionStatusEnum: import("@contractspec/lib.schema").EntityEnumDef;
 /**
  * WorkflowInstance entity - a running instance of a workflow.
  *
  * When a workflow is triggered, an instance is created. The instance
  * tracks the current state and all data associated with this execution.
  */
-declare const WorkflowInstanceEntity: _contractspec_lib_schema0.EntitySpec<{
-  id: _contractspec_lib_schema0.EntityScalarField;
-  workflowDefinitionId: _contractspec_lib_schema0.EntityScalarField;
-  referenceId: _contractspec_lib_schema0.EntityScalarField;
-  referenceType: _contractspec_lib_schema0.EntityScalarField;
-  status: _contractspec_lib_schema0.EntityEnumField;
-  currentStepId: _contractspec_lib_schema0.EntityScalarField;
-  contextData: _contractspec_lib_schema0.EntityScalarField;
-  triggeredBy: _contractspec_lib_schema0.EntityScalarField;
-  triggerSource: _contractspec_lib_schema0.EntityScalarField;
-  organizationId: _contractspec_lib_schema0.EntityScalarField;
-  priority: _contractspec_lib_schema0.EntityScalarField;
-  dueAt: _contractspec_lib_schema0.EntityScalarField;
-  outcome: _contractspec_lib_schema0.EntityScalarField;
-  resultData: _contractspec_lib_schema0.EntityScalarField;
-  errorMessage: _contractspec_lib_schema0.EntityScalarField;
-  createdAt: _contractspec_lib_schema0.EntityScalarField;
-  updatedAt: _contractspec_lib_schema0.EntityScalarField;
-  startedAt: _contractspec_lib_schema0.EntityScalarField;
-  completedAt: _contractspec_lib_schema0.EntityScalarField;
-  workflowDefinition: _contractspec_lib_schema0.EntityRelationField;
-  currentStep: _contractspec_lib_schema0.EntityRelationField;
-  stepExecutions: _contractspec_lib_schema0.EntityRelationField;
-  approvalRequests: _contractspec_lib_schema0.EntityRelationField;
+export declare const WorkflowInstanceEntity: import("@contractspec/lib.schema").EntitySpec<{
+    id: import("@contractspec/lib.schema").EntityScalarField;
+    workflowDefinitionId: import("@contractspec/lib.schema").EntityScalarField;
+    referenceId: import("@contractspec/lib.schema").EntityScalarField;
+    referenceType: import("@contractspec/lib.schema").EntityScalarField;
+    status: import("@contractspec/lib.schema").EntityEnumField;
+    currentStepId: import("@contractspec/lib.schema").EntityScalarField;
+    contextData: import("@contractspec/lib.schema").EntityScalarField;
+    triggeredBy: import("@contractspec/lib.schema").EntityScalarField;
+    triggerSource: import("@contractspec/lib.schema").EntityScalarField;
+    organizationId: import("@contractspec/lib.schema").EntityScalarField;
+    priority: import("@contractspec/lib.schema").EntityScalarField;
+    dueAt: import("@contractspec/lib.schema").EntityScalarField;
+    outcome: import("@contractspec/lib.schema").EntityScalarField;
+    resultData: import("@contractspec/lib.schema").EntityScalarField;
+    errorMessage: import("@contractspec/lib.schema").EntityScalarField;
+    createdAt: import("@contractspec/lib.schema").EntityScalarField;
+    updatedAt: import("@contractspec/lib.schema").EntityScalarField;
+    startedAt: import("@contractspec/lib.schema").EntityScalarField;
+    completedAt: import("@contractspec/lib.schema").EntityScalarField;
+    workflowDefinition: import("@contractspec/lib.schema").EntityRelationField;
+    currentStep: import("@contractspec/lib.schema").EntityRelationField;
+    stepExecutions: import("@contractspec/lib.schema").EntityRelationField;
+    approvalRequests: import("@contractspec/lib.schema").EntityRelationField;
 }>;
 /**
  * StepExecution entity - tracks execution of a step within an instance.
  */
-declare const StepExecutionEntity: _contractspec_lib_schema0.EntitySpec<{
-  id: _contractspec_lib_schema0.EntityScalarField;
-  workflowInstanceId: _contractspec_lib_schema0.EntityScalarField;
-  workflowStepId: _contractspec_lib_schema0.EntityScalarField;
-  status: _contractspec_lib_schema0.EntityEnumField;
-  executionOrder: _contractspec_lib_schema0.EntityScalarField;
-  inputData: _contractspec_lib_schema0.EntityScalarField;
-  outputData: _contractspec_lib_schema0.EntityScalarField;
-  actionTaken: _contractspec_lib_schema0.EntityScalarField;
-  transitionedTo: _contractspec_lib_schema0.EntityScalarField;
-  executedBy: _contractspec_lib_schema0.EntityScalarField;
-  errorMessage: _contractspec_lib_schema0.EntityScalarField;
-  errorDetails: _contractspec_lib_schema0.EntityScalarField;
-  retryCount: _contractspec_lib_schema0.EntityScalarField;
-  createdAt: _contractspec_lib_schema0.EntityScalarField;
-  updatedAt: _contractspec_lib_schema0.EntityScalarField;
-  startedAt: _contractspec_lib_schema0.EntityScalarField;
-  completedAt: _contractspec_lib_schema0.EntityScalarField;
-  workflowInstance: _contractspec_lib_schema0.EntityRelationField;
-  workflowStep: _contractspec_lib_schema0.EntityRelationField;
+export declare const StepExecutionEntity: import("@contractspec/lib.schema").EntitySpec<{
+    id: import("@contractspec/lib.schema").EntityScalarField;
+    workflowInstanceId: import("@contractspec/lib.schema").EntityScalarField;
+    workflowStepId: import("@contractspec/lib.schema").EntityScalarField;
+    status: import("@contractspec/lib.schema").EntityEnumField;
+    executionOrder: import("@contractspec/lib.schema").EntityScalarField;
+    inputData: import("@contractspec/lib.schema").EntityScalarField;
+    outputData: import("@contractspec/lib.schema").EntityScalarField;
+    actionTaken: import("@contractspec/lib.schema").EntityScalarField;
+    transitionedTo: import("@contractspec/lib.schema").EntityScalarField;
+    executedBy: import("@contractspec/lib.schema").EntityScalarField;
+    errorMessage: import("@contractspec/lib.schema").EntityScalarField;
+    errorDetails: import("@contractspec/lib.schema").EntityScalarField;
+    retryCount: import("@contractspec/lib.schema").EntityScalarField;
+    createdAt: import("@contractspec/lib.schema").EntityScalarField;
+    updatedAt: import("@contractspec/lib.schema").EntityScalarField;
+    startedAt: import("@contractspec/lib.schema").EntityScalarField;
+    completedAt: import("@contractspec/lib.schema").EntityScalarField;
+    workflowInstance: import("@contractspec/lib.schema").EntityRelationField;
+    workflowStep: import("@contractspec/lib.schema").EntityRelationField;
 }>;
-//#endregion
-export { InstanceStatusEnum, StepExecutionEntity, StepExecutionStatusEnum, WorkflowInstanceEntity };
 //# sourceMappingURL=instance.d.ts.map

package/dist/entities/instance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instance.d.ts","names":[],"sources":["../../src/entities/instance.ts"],"mappings":";;;;;;cAUa,kBAAA,EAcX,yBAAA,CAd6B,aAAA;;;;cAmBlB,uBAAA,EAYX,yBAAA,CAZkC,aAAA;AAApC;;;;;AAoBA;AApBA,cAoBa,sBAAA,4BAAsB,UAAA;MA8FjC,yBAAA,CAAA,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAKW,mBAAA,4BAAmB,UAAA;MA2E9B,yBAAA,CAAA,iBAAA"}
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../../src/entities/instance.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,eAAO,MAAM,kBAAkB,kDAc7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB,kDAYlC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;EA8FjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;EA2E9B,CAAC"}