@cohesivesystems/processes 0.1.0-alpha.129

package/dist/generated/processes.shapes.generated.d.ts

@@ -0,0 +1,869 @@
+import type { AggregateExpr, AggregateOperator, AnnotationKey, AnnotationValue, ArrayTypeRef, BinaryExpr, BinaryOperator, BindingExpr, CallExpr, CapabilityRealizationKind, ConditionalExpr, ConstantExpr, CurrentItemExpr, DiagnosticSeverity, DocumentDiagnosticEvidence, DocumentOrigin, DocumentValidationDiagnostic, EntityReferenceTypeRef, EntityTypeName, EnumTypeRef, Expr, FieldCardinality, FieldExpr, FieldNullability, FieldPath, FieldPathSegment, FieldPresence, FieldRefExpr, GraphId, JsonTypeKind, JsonTypeRef, LiteralExpr, NamedTypeRef, ObjectFieldTypeDef, ObjectTypeRef, OpaqueRuntimeTypeRef, ParameterExpr, PrimitiveFormat, QualifiedShapeId, QuantityTypeRef, ScalarTypeKind, ScalarTypeRef, SegmentKind, ShapeId, TypeId, TypeInferenceDiagnostic, TypeRef, UnaryExpr, UnaryOperator, ValueBindingId, ValueContract } from '@cohesivesystems/relations';
+export type { AggregateExpr, AggregateOperator, AnnotationKey, AnnotationValue, ArrayTypeRef, BinaryExpr, BinaryOperator, BindingExpr, CallExpr, CapabilityRealizationKind, ConditionalExpr, ConstantExpr, CurrentItemExpr, DiagnosticSeverity, DocumentDiagnosticEvidence, DocumentOrigin, DocumentValidationDiagnostic, EntityReferenceTypeRef, EntityTypeName, EnumTypeRef, Expr, FieldCardinality, FieldExpr, FieldNullability, FieldPath, FieldPathSegment, FieldPresence, FieldRefExpr, GraphId, JsonTypeKind, JsonTypeRef, LiteralExpr, NamedTypeRef, ObjectFieldTypeDef, ObjectTypeRef, OpaqueRuntimeTypeRef, ParameterExpr, PrimitiveFormat, QualifiedShapeId, QuantityTypeRef, ScalarTypeKind, ScalarTypeRef, SegmentKind, ShapeId, TypeId, TypeInferenceDiagnostic, TypeRef, UnaryExpr, UnaryOperator, ValueBindingId, ValueContract };
+export type ProcessControlDecisionDisposition = 'Unspecified' | 'Inspected' | 'Applied' | 'DeferredToSafePoint' | 'Replayed' | 'AlreadySatisfied' | 'AlreadyRequested' | 'SignalAccepted' | 'SignalBuffered' | 'SignalDuplicate' | 'ActivationStarted' | 'SafePointReached' | 'AffinityBound' | 'Unauthorized' | 'TargetMismatch' | 'StaleAttempt' | 'StaleRevision' | 'IdentityConflict' | 'IdempotencyConflict' | 'SignalConflict' | 'AffinityConflict' | 'InvalidState' | 'InvalidCommand' | 'CancellationFinalized';
+export declare const processControlDecisionDispositions: {
+    readonly unspecified: "Unspecified";
+    readonly inspected: "Inspected";
+    readonly applied: "Applied";
+    readonly deferredToSafePoint: "DeferredToSafePoint";
+    readonly replayed: "Replayed";
+    readonly alreadySatisfied: "AlreadySatisfied";
+    readonly alreadyRequested: "AlreadyRequested";
+    readonly signalAccepted: "SignalAccepted";
+    readonly signalBuffered: "SignalBuffered";
+    readonly signalDuplicate: "SignalDuplicate";
+    readonly activationStarted: "ActivationStarted";
+    readonly safePointReached: "SafePointReached";
+    readonly affinityBound: "AffinityBound";
+    readonly unauthorized: "Unauthorized";
+    readonly targetMismatch: "TargetMismatch";
+    readonly staleAttempt: "StaleAttempt";
+    readonly staleRevision: "StaleRevision";
+    readonly identityConflict: "IdentityConflict";
+    readonly idempotencyConflict: "IdempotencyConflict";
+    readonly signalConflict: "SignalConflict";
+    readonly affinityConflict: "AffinityConflict";
+    readonly invalidState: "InvalidState";
+    readonly invalidCommand: "InvalidCommand";
+    readonly cancellationFinalized: "CancellationFinalized";
+};
+export declare const processControlDecisionDispositionLabels: Record<ProcessControlDecisionDisposition, string>;
+export interface ExecutionControlReceiptSummary {
+    commandId: ProcessControlCommandId;
+    disposition: ProcessControlReceiptDisposition;
+    beforeRevision: ProcessControlRevision;
+    afterRevision: ProcessControlRevision;
+    recordedAtUtc: string;
+}
+export type ExecutionDefinitionKind = string;
+export interface ExecutionDefinitionMetadata {
+    definitionId: ExecutionDefinitionId;
+    revisionId: ExecutionRevisionId;
+    schemaVersion: ExecutionIrSchemaVersion;
+    fingerprint: ExecutionDefinitionFingerprint;
+    provenance: ExecutionProvenance;
+    displayName?: string | null;
+    description?: string | null;
+    sourceMap: ExecutionSourceMap;
+    diagnostics: DocumentValidationDiagnostic[];
+}
+export interface ExecutionDefinitionExtension {
+    id: ExecutionExtensionId;
+    schemaVersion: ExecutionExtensionSchemaVersion;
+    value: PortableValue;
+}
+export type ExecutionIrSchemaVersion = string;
+export interface ExecutionExplainDefinitionReference {
+    kind: ExecutionDefinitionKind;
+    schemaVersion: ExecutionIrSchemaVersion;
+    definition: ExecutionDefinitionReference;
+    provenance: ExecutionProvenance;
+    sourceMap: ExecutionSourceMap;
+}
+export interface ExecutionInterpreterProfileReference {
+    id: string;
+    version: string;
+    schemaCompatibility: ExecutionIrSchemaCompatibilityDeclaration;
+    definitionKinds: ExecutionDefinitionKind[];
+    provenance: ExecutionProvenance;
+}
+export interface ExecutionExplainEvidence {
+    stage: string;
+    kind: string;
+    subject: string;
+    authority: ExecutionExplainEvidenceAuthority;
+    status: string;
+    realization?: CapabilityRealizationKind | null;
+    relatedSubjects: string[];
+    sourceReferences: string[];
+}
+export interface ExecutionExplainTraceReference {
+    definition: ExecutionDefinitionReference;
+    continuation?: ProcessContinuationIdentity | null;
+    activation: ActivationId;
+    fingerprint: ExecutionTraceFingerprint;
+}
+export interface ExecutionExplainFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export interface ExecutionDefinitionReference {
+    definitionId: ExecutionDefinitionId;
+    revisionId: ExecutionRevisionId;
+    fingerprint: ExecutionDefinitionFingerprint;
+}
+export type ProcessInstanceId = string;
+export type ProcessControlRevision = string;
+export type ProcessControlMode = 'Unspecified' | 'Running' | 'PauseRequested' | 'Paused' | 'RestartRequested' | 'CancellationRequested' | 'Cancelled' | 'Terminated' | 'Cancelling' | 'CancellationFailed';
+export declare const processControlModes: {
+    readonly unspecified: "Unspecified";
+    readonly running: "Running";
+    readonly pauseRequested: "PauseRequested";
+    readonly paused: "Paused";
+    readonly restartRequested: "RestartRequested";
+    readonly cancellationRequested: "CancellationRequested";
+    readonly cancelled: "Cancelled";
+    readonly terminated: "Terminated";
+    readonly cancelling: "Cancelling";
+    readonly cancellationFailed: "CancellationFailed";
+};
+export declare const processControlModeLabels: Record<ProcessControlMode, string>;
+export interface ExecutionAttemptStatus {
+    attemptId: ProcessAttemptId;
+    startedAtUtc: string;
+    endedAtUtc?: string | null;
+    disposition: ExecutionAttemptDisposition;
+    phase: ProcessControlExecutionPhase;
+    completedActivationCount: string;
+    lastSafePointId?: ProcessSafePointId | null;
+    lastSafePointNode?: ExecutionNodeId | null;
+}
+export type ProcessAttemptId = string;
+export interface ExecutionActivationStatus {
+    activationId: ActivationId;
+    attemptId: ProcessAttemptId;
+    startedUnderRevision: ProcessControlRevision;
+    startedAtUtc: string;
+}
+export interface ExecutionRuntimeStatusDetails {
+    tokensDisclosure: ExecutionStatusDisclosure;
+    tokens: ExecutionTokenStatus[];
+    waitsDisclosure: ExecutionStatusDisclosure;
+    waits: ExecutionWaitStatus[];
+    progressDisclosure: ExecutionStatusDisclosure;
+    progress?: ExecutionProgressStatus | null;
+    demandDisclosure: ExecutionStatusDisclosure;
+    demand?: ExecutionDemandStatus | null;
+    capacityDisclosure: ExecutionStatusDisclosure;
+    capacity?: ExecutionCapacityStatus | null;
+    health: ExecutionHealthStatus;
+    extensions: ExecutionRuntimeStatusExtension[];
+}
+export interface ExecutionTerminalOutcome {
+    kind: ExecutionTerminalOutcomeKind;
+    occurredAtUtc?: string | null;
+    detail?: ExecutionStatusValue | null;
+}
+export type ExecutionNodeId = string;
+export type ProcessNode = {
+    readonly $node: 'invokeTransition';
+} & InvokeTransitionProcessNode | {
+    readonly $node: 'evaluateRelation';
+} & EvaluateRelationProcessNode | {
+    readonly $node: 'request';
+} & RequestProcessNode | {
+    readonly $node: 'emitEvent';
+} & EmitEventProcessNode | {
+    readonly $node: 'sendSignal';
+} & SendSignalProcessNode | {
+    readonly $node: 'choice';
+} & ChoiceProcessNode | {
+    readonly $node: 'match';
+} & MatchProcessNode | {
+    readonly $node: 'fork';
+} & ForkProcessNode | {
+    readonly $node: 'join';
+} & JoinProcessNode | {
+    readonly $node: 'awaitMatch';
+} & AwaitMatchProcessNode | {
+    readonly $node: 'timer';
+} & TimerProcessNode | {
+    readonly $node: 'reply';
+} & ReplyProcessNode | {
+    readonly $node: 'durableCut';
+} & DurableCutProcessNode | {
+    readonly $node: 'invokeProcess';
+} & InvokeProcessProcessNode | {
+    readonly $node: 'forEachPartition';
+} & ForEachPartitionProcessNode | {
+    readonly $node: 'repeatAcrossActivation';
+} & RepeatAcrossActivationProcessNode | {
+    readonly $node: 'cancellationFinalizer';
+} & CancellationFinalizerProcessNode | {
+    readonly $node: 'return';
+} & ReturnProcessNode | {
+    readonly $node: 'fail';
+} & FailProcessNode;
+export declare const canonicalProcessNodeKinds: readonly ["awaitMatch", "cancellationFinalizer", "choice", "durableCut", "emitEvent", "evaluateRelation", "fail", "forEachPartition", "fork", "invokeProcess", "invokeTransition", "join", "match", "repeatAcrossActivation", "reply", "request", "return", "sendSignal", "timer"];
+export interface InvokeTransitionProcessNode {
+    transition: ExecutionDefinitionReference;
+    subject: Expr;
+    input: Expr;
+    continuation: ProcessContinuation;
+    receipt?: ProcessOutputBinding | null;
+    id: ExecutionNodeId;
+}
+export interface EvaluateRelationProcessNode {
+    relation: ExecutionDefinitionReference;
+    input: Expr;
+    continuation: ProcessContinuation;
+    id: ExecutionNodeId;
+}
+export interface RequestProcessNode {
+    id: ExecutionNodeId;
+    contract: RequestContractReference;
+    payload: Expr;
+    outcomes: ProcessRequestOutcomeBranch[];
+}
+export interface EmitEventProcessNode {
+    contract: DomainEventContractReference;
+    payload: Expr;
+    next: ProcessEdge;
+    id: ExecutionNodeId;
+}
+export interface SendSignalProcessNode {
+    id: ExecutionNodeId;
+    contract: SignalContractReference;
+    target: Expr;
+    payload: Expr;
+    next: ProcessEdge;
+}
+export interface ChoiceProcessNode {
+    selection: CaseSelection;
+    completeness: BranchCompleteness;
+    cases: ProcessChoiceCase[];
+    fallback?: ProcessFallback | null;
+    id: ExecutionNodeId;
+}
+export interface MatchProcessNode {
+    selection: CaseSelection;
+    completeness: BranchCompleteness;
+    value: Expr;
+    contract: ValueContract;
+    cases: ProcessMatchCase[];
+    fallback?: ProcessFallback | null;
+    id: ExecutionNodeId;
+}
+export interface ForkProcessNode {
+    branches: ProcessForkBranch[];
+    join: ExecutionNodeId;
+    limits: ProcessWorkLimits;
+    capacityDomains: ProcessCapacityDomainLimit[];
+    id: ExecutionNodeId;
+}
+export interface JoinProcessNode {
+    fork: ExecutionNodeId;
+    policy: ProcessJoinPolicy;
+    next: ProcessEdge;
+    result?: ProcessJoinResultProjection | null;
+    id: ExecutionNodeId;
+}
+export interface AwaitMatchProcessNode {
+    arbitration: ProcessAwaitArbitration;
+    clauses: ProcessAwaitClause[];
+    lateInput: ProcessAwaitInputDisposition;
+    staleInput: ProcessAwaitInputDisposition;
+    duplicateInput: ProcessAwaitInputDisposition;
+    missingTarget: ProcessAwaitMissingTargetDisposition;
+    retentionHorizon: TimeSpan;
+    id: ExecutionNodeId;
+}
+export interface TimerProcessNode {
+    id: ExecutionNodeId;
+    dueAt: Expr;
+    next: ProcessEdge;
+}
+export interface ReplyProcessNode {
+    id: ExecutionNodeId;
+    contract: ReplyContractReference;
+    request: RequestObligationBindingId;
+    payload: Expr;
+    next: ProcessEdge;
+}
+export interface DurableCutProcessNode {
+    resume: ProcessEdge;
+    id: ExecutionNodeId;
+}
+export interface InvokeProcessProcessNode {
+    process: ExecutionDefinitionReference;
+    contract: RequestContractReference;
+    outcomeMapping: ProcessChildOutcomeMapping;
+    input: Expr;
+    purpose: ProcessChildPurpose;
+    cancellation: ProcessChildCancellationPolicy;
+    outcomes: ProcessRequestOutcomeBranch[];
+    id: ExecutionNodeId;
+}
+export interface ForEachPartitionProcessNode {
+    partitions: Expr;
+    partition: ProcessOutputBinding;
+    progressIdentity: Expr;
+    process: ExecutionDefinitionReference;
+    contract: RequestContractReference;
+    outcomeMapping: ProcessChildOutcomeMapping;
+    childInput: Expr;
+    limits: ProcessWorkLimits;
+    failure: ProcessPartitionFailurePolicy;
+    capacityIdentity?: Expr | null;
+    capacityDomains: ProcessCapacityDomainLimit[];
+    cancellation: ProcessChildCancellationPolicy;
+    completed: ProcessEdge;
+    failed: ProcessEdge;
+    id: ExecutionNodeId;
+}
+export interface RepeatAcrossActivationProcessNode {
+    id: ExecutionNodeId;
+    continueWhen: Expr;
+    progress: Expr;
+    progressContract: ValueContract;
+    policy: ProcessRecurrencePolicy;
+    repeat: ProcessEdge;
+    completed: ProcessEdge;
+    exhausted: ProcessEdge;
+    stalled: ProcessEdge;
+    initialState?: Expr | null;
+    nextState?: Expr | null;
+    stateContract?: ValueContract | null;
+    stateOutput?: ProcessOutputBinding | null;
+}
+export interface CancellationFinalizerProcessNode {
+    process: ExecutionDefinitionReference;
+    contract: RequestContractReference;
+    outcomeMapping: ProcessChildOutcomeMapping;
+    id: ExecutionNodeId;
+}
+export interface ReturnProcessNode {
+    id: ExecutionNodeId;
+    result: Expr;
+}
+export interface FailProcessNode {
+    result: Expr;
+    id: ExecutionNodeId;
+}
+export type ProcessRecoveryPolicy = 'Unspecified' | 'ContinueAttempt' | 'RestartAttempt';
+export declare const processRecoveryPolicies: {
+    readonly unspecified: "Unspecified";
+    readonly continueAttempt: "ContinueAttempt";
+    readonly restartAttempt: "RestartAttempt";
+};
+export declare const processRecoveryPolicyLabels: Record<ProcessRecoveryPolicy, string>;
+export interface NormalizedExecutionTrace {
+    schemaVersion: ExecutionIrSchemaVersion;
+    kind: ExecutionDefinitionKind;
+    definition: ExecutionDefinitionReference;
+    continuation?: ProcessContinuationIdentity | null;
+    activation: ActivationId;
+    disposition: string;
+    safePointNode?: ExecutionNodeId | null;
+    durableCommitSequence?: string | null;
+    events: NormalizedExecutionTraceEvent[];
+}
+export type ProcessControlCommandId = string;
+export type ProcessControlReceiptDisposition = 'Unspecified' | 'Applied' | 'DeferredToSafePoint' | 'AlreadySatisfied' | 'AlreadyRequested' | 'SignalAccepted' | 'SignalBuffered' | 'SignalDuplicate';
+export declare const processControlReceiptDispositions: {
+    readonly unspecified: "Unspecified";
+    readonly applied: "Applied";
+    readonly deferredToSafePoint: "DeferredToSafePoint";
+    readonly alreadySatisfied: "AlreadySatisfied";
+    readonly alreadyRequested: "AlreadyRequested";
+    readonly signalAccepted: "SignalAccepted";
+    readonly signalBuffered: "SignalBuffered";
+    readonly signalDuplicate: "SignalDuplicate";
+};
+export declare const processControlReceiptDispositionLabels: Record<ProcessControlReceiptDisposition, string>;
+export type ExecutionDefinitionId = string;
+export type ExecutionRevisionId = string;
+export interface ExecutionDefinitionFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export interface ExecutionProvenance {
+    producer: ExecutionProducerProvenance;
+    source: ExecutionSourceProvenance;
+    origin: DocumentOrigin;
+}
+export interface ExecutionSourceMap {
+    entries: ExecutionSourceProvenance[];
+}
+export type ExecutionExtensionId = string;
+export type ExecutionExtensionSchemaVersion = string;
+export interface PortableValue {
+    contract: ValueContract;
+    state: PortableValueState;
+    value?: unknown | null;
+    failure?: DocumentValidationDiagnostic | null;
+}
+export interface ExecutionIrSchemaCompatibilityDeclaration {
+    supportedSchemaVersions: ExecutionIrSchemaVersion[];
+}
+export type ExecutionExplainEvidenceAuthority = 'Declared' | 'Derived' | 'ConventionDerived' | 'AdapterSupplied' | 'Interpreted' | 'Measured' | 'Recommended' | 'Applied';
+export declare const executionExplainEvidenceAuthorities: {
+    readonly declared: "Declared";
+    readonly derived: "Derived";
+    readonly conventionDerived: "ConventionDerived";
+    readonly adapterSupplied: "AdapterSupplied";
+    readonly interpreted: "Interpreted";
+    readonly measured: "Measured";
+    readonly recommended: "Recommended";
+    readonly applied: "Applied";
+};
+export declare const executionExplainEvidenceAuthorityLabels: Record<ExecutionExplainEvidenceAuthority, string>;
+export interface ProcessContinuationIdentity {
+    processInstanceId: ProcessInstanceId;
+    processAttemptId: ProcessAttemptId;
+}
+export type ActivationId = string;
+export interface ExecutionTraceFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export type ExecutionAttemptDisposition = 'Unspecified' | 'Current' | 'Abandoned' | 'Completed' | 'Failed' | 'Cancelled' | 'Terminated';
+export declare const executionAttemptDispositions: {
+    readonly unspecified: "Unspecified";
+    readonly current: "Current";
+    readonly abandoned: "Abandoned";
+    readonly completed: "Completed";
+    readonly failed: "Failed";
+    readonly cancelled: "Cancelled";
+    readonly terminated: "Terminated";
+};
+export declare const executionAttemptDispositionLabels: Record<ExecutionAttemptDisposition, string>;
+export type ProcessControlExecutionPhase = 'Unspecified' | 'Ready' | 'InActivation' | 'AtSafePoint' | 'Stopped';
+export declare const processControlExecutionPhases: {
+    readonly unspecified: "Unspecified";
+    readonly ready: "Ready";
+    readonly inActivation: "InActivation";
+    readonly atSafePoint: "AtSafePoint";
+    readonly stopped: "Stopped";
+};
+export declare const processControlExecutionPhaseLabels: Record<ProcessControlExecutionPhase, string>;
+export type ProcessSafePointId = string;
+export type ExecutionStatusDisclosure = 'Unknown' | 'Disclosed' | 'Redacted';
+export declare const executionStatusDisclosures: {
+    readonly unknown: "Unknown";
+    readonly disclosed: "Disclosed";
+    readonly redacted: "Redacted";
+};
+export declare const executionStatusDisclosureLabels: Record<ExecutionStatusDisclosure, string>;
+export interface ExecutionTokenStatus {
+    tokenId: TokenId;
+    node: ExecutionNodeId;
+    disposition: ExecutionTokenDisposition;
+}
+export interface ExecutionWaitStatus {
+    tokenId: TokenId;
+    node: ExecutionNodeId;
+    waitingSinceUtc: string;
+    deadlineUtc?: string | null;
+}
+export interface ExecutionProgressStatus {
+    completed: string;
+    total?: string | null;
+    unit: string;
+}
+export interface ExecutionDemandStatus {
+    ready: string;
+    delayed: string;
+}
+export interface ExecutionCapacityStatus {
+    active: string;
+    limit: string;
+}
+export type ExecutionHealthStatus = 'Unknown' | 'Healthy' | 'Degraded' | 'Unhealthy';
+export declare const executionHealthStatuses: {
+    readonly unknown: "Unknown";
+    readonly healthy: "Healthy";
+    readonly degraded: "Degraded";
+    readonly unhealthy: "Unhealthy";
+};
+export declare const executionHealthStatusLabels: Record<ExecutionHealthStatus, string>;
+export interface ExecutionRuntimeStatusExtension {
+    id: ExecutionExtensionId;
+    schemaVersion: ExecutionExtensionSchemaVersion;
+    value: ExecutionStatusValue;
+    provenance: ExecutionProvenance;
+}
+export type ExecutionTerminalOutcomeKind = 'None' | 'Completed' | 'Failed' | 'Cancelled' | 'Terminated';
+export declare const executionTerminalOutcomeKinds: {
+    readonly none: "None";
+    readonly completed: "Completed";
+    readonly failed: "Failed";
+    readonly cancelled: "Cancelled";
+    readonly terminated: "Terminated";
+};
+export declare const executionTerminalOutcomeKindLabels: Record<ExecutionTerminalOutcomeKind, string>;
+export interface ExecutionStatusValue {
+    contract: ValueContract;
+    disclosure: ExecutionStatusDisclosure;
+    value?: PortableValue | null;
+}
+export interface ProcessContinuation {
+    edge: ProcessEdge;
+    output?: ProcessOutputBinding | null;
+}
+export interface ProcessOutputBinding {
+    binding: ValueBindingId;
+    contract: ValueContract;
+}
+export interface RequestContractReference {
+    definition: ExecutionDefinitionReference;
+}
+export interface ProcessRequestOutcomeBranch {
+    id: ExecutionNodeId;
+    outcome: RequestTerminalOutcomeId;
+    continuation: ProcessContinuation;
+}
+export interface DomainEventContractReference {
+    definition: ExecutionDefinitionReference;
+}
+export interface ProcessEdge {
+    id: ProcessEdgeId;
+    target: ExecutionNodeId;
+}
+export interface SignalContractReference {
+    definition: ExecutionDefinitionReference;
+}
+export type CaseSelection = 'Unspecified' | 'OrderedFirstMatch';
+export declare const caseSelections: {
+    readonly unspecified: "Unspecified";
+    readonly orderedFirstMatch: "OrderedFirstMatch";
+};
+export declare const caseSelectionLabels: Record<CaseSelection, string>;
+export type BranchCompleteness = 'Unspecified' | 'Exhaustive' | 'Fallback';
+export declare const branchCompletenesses: {
+    readonly unspecified: "Unspecified";
+    readonly exhaustive: "Exhaustive";
+    readonly fallback: "Fallback";
+};
+export declare const branchCompletenessLabels: Record<BranchCompleteness, string>;
+export interface ProcessChoiceCase {
+    id: ExecutionNodeId;
+    predicate: Expr;
+    next: ProcessEdge;
+}
+export interface ProcessFallback {
+    id: ExecutionNodeId;
+    next: ProcessEdge;
+}
+export interface ProcessMatchCase {
+    id: ExecutionNodeId;
+    pattern: PortableValue;
+    next: ProcessEdge;
+}
+export interface ProcessForkBranch {
+    id: ExecutionNodeId;
+    start: ProcessEdge;
+    capacityDomain?: string | null;
+}
+export interface ProcessWorkLimits {
+    maximumItems: number;
+    maximumStartsPerActivation: number;
+    maximumParallelism: number;
+    minimumParallelism: number;
+}
+export interface ProcessCapacityDomainLimit {
+    identity: string;
+    maximumParallelism: number;
+}
+export interface ProcessJoinPolicy {
+    mode: ProcessJoinMode;
+    requiredCount: number;
+    failure: ProcessJoinFailurePolicy;
+    cancellation: ProcessJoinCancellationPolicy;
+    completionOrder: ProcessJoinCompletionOrder;
+    tieBreak: ProcessJoinTieBreak;
+}
+export interface ProcessJoinResultProjection {
+    output: ProcessOutputBinding;
+    resultContract: ValueContract;
+    branches: ProcessJoinBranchResult[];
+}
+export type ProcessAwaitArbitration = 'Unspecified' | 'ExclusivePriorityThenClauseId';
+export declare const processAwaitArbitrations: {
+    readonly unspecified: "Unspecified";
+    readonly exclusivePriorityThenClauseId: "ExclusivePriorityThenClauseId";
+};
+export declare const processAwaitArbitrationLabels: Record<ProcessAwaitArbitration, string>;
+export type ProcessAwaitClause = {
+    readonly $clause: 'interaction';
+} & ProcessAwaitInteractionClause | {
+    readonly $clause: 'timer';
+} & ProcessAwaitTimerClause;
+export declare const canonicalProcessAwaitClauseKinds: readonly ["interaction", "timer"];
+export interface ProcessAwaitInteractionClause {
+    id: ExecutionNodeId;
+    priority: number;
+    continuation: ProcessContinuation;
+    contract: InteractionContractReference;
+    input: ProcessOutputBinding;
+    requestObligation?: ProcessRequestObligationBinding | null;
+    guard?: Expr | null;
+}
+export interface ProcessAwaitTimerClause {
+    id: ExecutionNodeId;
+    priority: number;
+    continuation: ProcessContinuation;
+    dueAt: Expr;
+}
+export type ProcessAwaitInputDisposition = 'Unspecified' | 'Reject' | 'Observe' | 'ReusePriorDisposition';
+export declare const processAwaitInputDispositions: {
+    readonly unspecified: "Unspecified";
+    readonly reject: "Reject";
+    readonly observe: "Observe";
+    readonly reusePriorDisposition: "ReusePriorDisposition";
+};
+export declare const processAwaitInputDispositionLabels: Record<ProcessAwaitInputDisposition, string>;
+export type ProcessAwaitMissingTargetDisposition = 'Unspecified' | 'Reject' | 'Observe' | 'DeadLetter';
+export declare const processAwaitMissingTargetDispositions: {
+    readonly unspecified: "Unspecified";
+    readonly reject: "Reject";
+    readonly observe: "Observe";
+    readonly deadLetter: "DeadLetter";
+};
+export declare const processAwaitMissingTargetDispositionLabels: Record<ProcessAwaitMissingTargetDisposition, string>;
+export interface TimeSpan {
+    ticks: number;
+    days: number;
+    hours: number;
+    milliseconds: number;
+    microseconds: number;
+    nanoseconds: number;
+    minutes: number;
+    seconds: number;
+    totalDays: number;
+    totalHours: number;
+    totalMilliseconds: number;
+    totalMicroseconds: number;
+    totalNanoseconds: number;
+    totalMinutes: number;
+    totalSeconds: number;
+}
+export interface ReplyContractReference {
+    definition: ExecutionDefinitionReference;
+}
+export type RequestObligationBindingId = string;
+export interface ProcessChildOutcomeMapping {
+    completed: RequestTerminalOutcomeId;
+    failed: RequestTerminalOutcomeId;
+    cancelled: RequestTerminalOutcomeId;
+    terminated: RequestTerminalOutcomeId;
+}
+export type ProcessChildPurpose = 'Unspecified' | 'Work' | 'Compensation' | 'Reconciliation';
+export declare const processChildPurposes: {
+    readonly unspecified: "Unspecified";
+    readonly work: "Work";
+    readonly compensation: "Compensation";
+    readonly reconciliation: "Reconciliation";
+};
+export declare const processChildPurposeLabels: Record<ProcessChildPurpose, string>;
+export type ProcessChildCancellationPolicy = 'Unspecified' | 'Propagate' | 'Detach';
+export declare const processChildCancellationPolicies: {
+    readonly unspecified: "Unspecified";
+    readonly propagate: "Propagate";
+    readonly detach: "Detach";
+};
+export declare const processChildCancellationPolicyLabels: Record<ProcessChildCancellationPolicy, string>;
+export type ProcessPartitionFailurePolicy = 'Unspecified' | 'FailFast' | 'AwaitAll';
+export declare const processPartitionFailurePolicies: {
+    readonly unspecified: "Unspecified";
+    readonly failFast: "FailFast";
+    readonly awaitAll: "AwaitAll";
+};
+export declare const processPartitionFailurePolicyLabels: Record<ProcessPartitionFailurePolicy, string>;
+export interface ProcessRecurrencePolicy {
+    maximumOccurrences: number;
+    maximumUnchangedProgressOccurrences: number;
+}
+export interface NormalizedExecutionTraceEvent {
+    sequence: number;
+    kind: string;
+    node: ExecutionNodeId;
+    token?: TokenId | null;
+    branchOrClause?: ExecutionNodeId | null;
+    emission?: EmissionId | null;
+    correlation?: InteractionCorrelationId | null;
+    causation?: EmissionId | null;
+    idempotencyKey?: InteractionIdempotencyKey | null;
+    emissionFingerprint?: InteractionEnvelopeContentFingerprint | null;
+    relatedDefinition?: ExecutionDefinitionReference | null;
+    relatedNode?: ExecutionNodeId | null;
+    semanticPath?: FieldPath | null;
+    changed?: boolean | null;
+    operationOccurrence?: string | null;
+    inputDisposition?: string | null;
+    inputReason?: string | null;
+    waitRegistrationId?: ProcessWaitRegistrationId | null;
+    processOccurrence?: ProcessTraceOccurrenceEvidence | null;
+    requestOutcome?: RequestTerminalOutcomeId | null;
+    detail?: string | null;
+    sourceReferences: string[];
+}
+export interface ExecutionProducerProvenance {
+    producer: string;
+    version?: string | null;
+}
+export interface ExecutionSourceProvenance {
+    reference: string;
+    semanticPath?: ExecutionSemanticPath | null;
+    description?: string | null;
+}
+export type PortableValueState = 'Missing' | 'Absent' | 'Null' | 'Unknown' | 'Failed' | 'Concrete';
+export declare const portableValueStates: {
+    readonly missing: "Missing";
+    readonly absent: "Absent";
+    readonly null: "Null";
+    readonly unknown: "Unknown";
+    readonly failed: "Failed";
+    readonly concrete: "Concrete";
+};
+export declare const portableValueStateLabels: Record<PortableValueState, string>;
+export type TokenId = string;
+export type ExecutionTokenDisposition = 'Unspecified' | 'Ready' | 'Active' | 'Waiting' | 'Completed' | 'Failed' | 'Cancelled' | 'Pending';
+export declare const executionTokenDispositions: {
+    readonly unspecified: "Unspecified";
+    readonly ready: "Ready";
+    readonly active: "Active";
+    readonly waiting: "Waiting";
+    readonly completed: "Completed";
+    readonly failed: "Failed";
+    readonly cancelled: "Cancelled";
+    readonly pending: "Pending";
+};
+export declare const executionTokenDispositionLabels: Record<ExecutionTokenDisposition, string>;
+export type RequestTerminalOutcomeId = string;
+export type ProcessEdgeId = string;
+export type ProcessJoinMode = 'Unspecified' | 'All' | 'Any' | 'RequiredCount';
+export declare const processJoinModes: {
+    readonly unspecified: "Unspecified";
+    readonly all: "All";
+    readonly any: "Any";
+    readonly requiredCount: "RequiredCount";
+};
+export declare const processJoinModeLabels: Record<ProcessJoinMode, string>;
+export type ProcessJoinFailurePolicy = 'Unspecified' | 'FailFast' | 'WaitForRequired' | 'ExcludeFailed';
+export declare const processJoinFailurePolicies: {
+    readonly unspecified: "Unspecified";
+    readonly failFast: "FailFast";
+    readonly waitForRequired: "WaitForRequired";
+    readonly excludeFailed: "ExcludeFailed";
+};
+export declare const processJoinFailurePolicyLabels: Record<ProcessJoinFailurePolicy, string>;
+export type ProcessJoinCancellationPolicy = 'Unspecified' | 'CancelRemaining' | 'AwaitRemaining' | 'ContinueRemaining';
+export declare const processJoinCancellationPolicies: {
+    readonly unspecified: "Unspecified";
+    readonly cancelRemaining: "CancelRemaining";
+    readonly awaitRemaining: "AwaitRemaining";
+    readonly continueRemaining: "ContinueRemaining";
+};
+export declare const processJoinCancellationPolicyLabels: Record<ProcessJoinCancellationPolicy, string>;
+export type ProcessJoinCompletionOrder = 'Unspecified' | 'Unobservable' | 'Observable';
+export declare const processJoinCompletionOrders: {
+    readonly unspecified: "Unspecified";
+    readonly unobservable: "Unobservable";
+    readonly observable: "Observable";
+};
+export declare const processJoinCompletionOrderLabels: Record<ProcessJoinCompletionOrder, string>;
+export type ProcessJoinTieBreak = 'Unspecified' | 'BranchIdentity' | 'CompletionThenBranchIdentity';
+export declare const processJoinTieBreaks: {
+    readonly unspecified: "Unspecified";
+    readonly branchIdentity: "BranchIdentity";
+    readonly completionThenBranchIdentity: "CompletionThenBranchIdentity";
+};
+export declare const processJoinTieBreakLabels: Record<ProcessJoinTieBreak, string>;
+export interface ProcessJoinBranchResult {
+    branch: ExecutionNodeId;
+    result: Expr;
+}
+export type InteractionContractReference = {
+    readonly $contract: 'domainEvent';
+} & DomainEventContractReference | {
+    readonly $contract: 'request';
+} & RequestContractReference | {
+    readonly $contract: 'signal';
+} & SignalContractReference | {
+    readonly $contract: 'reply';
+} & ReplyContractReference;
+export interface ProcessRequestObligationBinding {
+    binding: RequestObligationBindingId;
+}
+export type EmissionId = string;
+export type InteractionCorrelationId = string;
+export type InteractionIdempotencyKey = string;
+export type InteractionEnvelopeContentFingerprint = string;
+export type ProcessWaitRegistrationId = string;
+export interface ProcessTraceOccurrenceEvidence {
+    disclosure: ExecutionTraceEvidenceDisclosure;
+    kind: ProcessTraceOccurrenceKind;
+    registrationId?: string | null;
+    ownerToken?: TokenId | null;
+    occurrence?: string | null;
+    progressIdentity?: string | null;
+    definition?: ExecutionDefinitionReference | null;
+    continuation?: ProcessContinuationIdentity | null;
+    repeatCount?: number | null;
+    unchangedProgressCount?: number | null;
+}
+export interface ExecutionSemanticPath {
+    segments: string[];
+}
+export type ExecutionTraceEvidenceDisclosure = 'Unknown' | 'Disclosed' | 'Redacted' | 'Unavailable' | 'Unsupported';
+export declare const executionTraceEvidenceDisclosures: {
+    readonly unknown: "Unknown";
+    readonly disclosed: "Disclosed";
+    readonly redacted: "Redacted";
+    readonly unavailable: "Unavailable";
+    readonly unsupported: "Unsupported";
+};
+export declare const executionTraceEvidenceDisclosureLabels: Record<ExecutionTraceEvidenceDisclosure, string>;
+export type ProcessTraceOccurrenceKind = 'Unspecified' | 'Child' | 'Partition' | 'Recurrence';
+export declare const processTraceOccurrenceKinds: {
+    readonly unspecified: "Unspecified";
+    readonly child: "Child";
+    readonly partition: "Partition";
+    readonly recurrence: "Recurrence";
+};
+export declare const processTraceOccurrenceKindLabels: Record<ProcessTraceOccurrenceKind, string>;
+export interface ExecutionControlResult {
+    disposition: ProcessControlDecisionDisposition;
+    status: ExecutionStatus;
+    receipt?: ExecutionControlReceiptSummary | null;
+    diagnosticCodes: string[];
+}
+export interface ExecutionDefinitionDocument {
+    kind: ExecutionDefinitionKind;
+    metadata: ExecutionDefinitionMetadata;
+    definition: unknown;
+    extensions: ExecutionDefinitionExtension[];
+}
+export interface ExecutionExplainArtifact {
+    schemaVersion: ExecutionIrSchemaVersion;
+    definition: ExecutionExplainDefinitionReference;
+    interpreter: ExecutionInterpreterProfileReference;
+    evidence: ExecutionExplainEvidence[];
+    trace?: ExecutionExplainTraceReference | null;
+    runtimeStatus?: ExecutionStatus | null;
+    diagnostics: DocumentValidationDiagnostic[];
+    fingerprint: ExecutionExplainFingerprint;
+}
+export interface ExecutionStatus {
+    schemaVersion: ExecutionIrSchemaVersion;
+    definition: ExecutionDefinitionReference;
+    processInstanceId: ProcessInstanceId;
+    controlRevision: ProcessControlRevision;
+    controlMode: ProcessControlMode;
+    attempts: ExecutionAttemptStatus[];
+    currentAttemptId: ProcessAttemptId;
+    activeActivation?: ExecutionActivationStatus | null;
+    runtime: ExecutionRuntimeStatusDetails;
+    terminalOutcome: ExecutionTerminalOutcome;
+    createdAtUtc: string;
+    updatedAtUtc: string;
+}
+export interface ProcessDefinition {
+    input: ValueContract;
+    result: ValueContract;
+    entry: ExecutionNodeId;
+    nodes: ProcessNode[];
+    recoveryPolicy: ProcessRecoveryPolicy;
+}
+export interface ProcessExecutionTraceArtifact {
+    schemaVersion: ExecutionIrSchemaVersion;
+    definition: ExecutionDefinitionReference;
+    processInstanceId: ProcessInstanceId;
+    missingTracePrefixCount: number;
+    traces: NormalizedExecutionTrace[];
+}
+//# sourceMappingURL=processes.shapes.generated.d.ts.map