arvo-event-handler 3.0.14 → 3.0.16

package/dist/ArvoEventHandler/index.d.ts

@@ -3,84 +3,8 @@ import type IArvoEventHandler from '../IArvoEventHandler';
 import type { ArvoEventHandlerOpenTelemetryOptions, ArvoEventHandlerOtelSpanOptions } from '../types';
 import type { ArvoEventHandlerFunction, ArvoEventHandlerParam } from './types';
 /**
- * `ArvoEventHandler` is the foundational component for building stateless,
+ * The foundational component for building stateless,
  * contract-bound services in the Arvo system.
- *
- * It enforces strict contract validation, version-aware handler resolution,
- * and safe, observable event emission — all while maintaining type safety,
- * traceability, and support for multi-domain workflows.
- *
- * ## What It Does
- * - Ensures incoming events match the contract's `type` and `dataschema`
- * - Resolves the correct contract version using `dataschema`
- * - Validates input and output data via Zod schemas
- * - Executes the version-specific handler function
- * - Emits one or more response events based on the handler result
- * - Supports multi-domain broadcasting via `domain[]` on the emitted events
- * - Automatically emits system error events (`sys.*.error`) on failure
- * - Integrates deeply with OpenTelemetry for tracing and observability
- *
- * ## Error Boundaries
- * ArvoEventHandler enforces a clear separation between:
- *
- * - **Violations** — structural, schema, or config errors that break the contract.
- *   These are thrown and must be handled explicitly by the caller.
- *
- * - **System Errors** — runtime exceptions during execution that are caught and
- *   emitted as standardized `sys.<contract>.error` events.
- *
- * ## Domain Broadcasting
- * The handler supports multi-domain event distribution. When the handler
- * returns an event with a `domain` array, it is broadcast to one or more
- * routing contexts.
- *
- * ### System Error Domain Control
- * By default, system error events are broadcast into the source event’s domain,
- * the handler’s contract domain, and the `null` domain. This fallback ensures errors
- * are visible across all relevant contexts. Developers can override this behavior
- * using the optional `systemErrorDomain` field to specify an explicit set of
- * domain values, including symbolic constants from {@link ArvoDomain}.
- *
- * ### Supported Domain Values:
- * - A **concrete domain string** like `'audit.orders'` or `'human.review'`
- * - `null` to emit with no domain (standard internal flow)
- * - A **symbolic reference** from {@link ArvoDomain}
- *
- * ### Domain Resolution Rules:
- * - Each item in the `domain` array is resolved via {@link resolveEventDomain}
- * - Duplicate domains are deduplicated before emitting
- * - If `domain` is omitted entirely, Arvo defaults to `[null]`
- *
- * ### Example:
- * ```ts
- * return {
- *   type: 'evt.user.registered',
- *   data: { ... },
- *   domain: ['analytics', ArvoDomain.FROM_TRIGGERING_EVENT, null]
- * };
- * ```
- * This would emit at most 3 copies of the event, domained to:
- * - `'analytics'`
- * - the domain of the incoming event
- * - no domain (default)
- *
- * ### Domain Usage Guidance
- *
- * > **Avoid setting `contract.domain` unless fully intentional.**
- * 99% emitted event should default to `null` (standard processing pipeline).
- *
- * Contract-level domains enforce implicit routing for every emitted event
- * in that handler, making the behavior harder to override and debug.
- *
- * Prefer:
- * - Explicit per-event `domain` values in handler output
- * - Using `null` or symbolic constants to control domain cleanly
- *
- * ## When to Use Domains
- * Use domains when handling for specialized contexts:
- * - `'human.review'` → for human-in-the-loop steps
- * - `'analytics.workflow'` → to pipe events into observability systems
- * - `'external.partner.sync'` → to route to external services
  */
 export default class ArvoEventHandler<TContract extends ArvoContract> implements IArvoEventHandler {
     /** Contract instance that defines the event schema and validation rules */
@@ -93,35 +17,16 @@ export default class ArvoEventHandler<TContract extends ArvoContract> implements
     readonly handler: ArvoEventHandlerFunction<TContract>;
     /** The source identifier for events produced by this handler */
     get source(): TContract['type'];
+    /** Optional domains for routing system error events */
     readonly systemErrorDomain?: (string | null)[];
-    /**
-     * The contract-defined domain for this handler, used as the default domain for emitted events.
-     * Can be overridden by individual handler implementations for cross-domain workflows.
-     * Returns null if no domain is specified, indicating standard processing context.
-     */
+    /** The contract-defined domain for the handler */
     get domain(): string | null;
-    /**
-     * Initializes a new ArvoEventHandler instance with the specified contract and configuration.
-     * Validates handler implementations against contract versions during initialization.
-     *
-     * The constructor ensures that handler implementations exist for all supported contract
-     * versions and configures OpenTelemetry span attributes for monitoring event handling.
-     *
-     * @param param - Handler configuration including contract, execution units, and handler implementations
-     * @throws When handler implementations are missing for any contract version
-     */
     constructor(param: ArvoEventHandlerParam<TContract>);
     /**
      * Processes an incoming event according to the handler's contract specifications. This method
      * handles the complete lifecycle of event processing including validation, execution, error
      * handling, and multi-domain event broadcasting, while maintaining detailed telemetry through OpenTelemetry.
      *
-     * @param event - The incoming event to process
-     * @param opentelemetry - Configuration for OpenTelemetry context inheritance, defaults to inheriting from the event
-     * @returns Promise resolving to a structured result containing an array of output events
-     * @returns Structured response containing:
-     *   - `events`: Array of events to be emitted (may contain multiple events per handler output due to domain broadcasting)
-     *
      * @throws {ContractViolation} when input or output event data violates the contract schema,
      *                             or when event emission fails due to invalid data
      * @throws {ConfigViolation} when event type doesn't match contract type, when the
@@ -134,30 +39,22 @@ export default class ArvoEventHandler<TContract extends ArvoContract> implements
     }>;
     /**
      * Provides access to the system error event schema configuration.
-     *
-     * The schema defines the structure of error events emitted during execution failures.
-     * These events are automatically generated when runtime errors occur and follow a
-     * standardized format for consistent error handling across the system.
-     *
-     * Error events follow the naming convention: `sys.<contract-type>.error`
-     *
-     * @example
-     * For a contract handling 'com.user.create' events, system error events
-     * will have the type 'sys.com.user.create.error'
-     *
-     * @returns The error event schema containing type and validation rules
      */
-    get systemErrorSchema(): import("arvo-core").ArvoContractRecord<`sys.${string}.error`, import("zod").ZodObject<{
-        errorName: import("zod").ZodString;
-        errorMessage: import("zod").ZodString;
-        errorStack: import("zod").ZodNullable<import("zod").ZodString>;
-    }, "strip", import("zod").ZodTypeAny, {
-        errorName: string;
-        errorMessage: string;
-        errorStack: string | null;
-    }, {
-        errorName: string;
-        errorMessage: string;
-        errorStack: string | null;
-    }>>;
+    get systemErrorSchema(): {
+        domain: (string | null)[] | undefined;
+        type: `sys.${string}.error`;
+        schema: import("zod").ZodObject<{
+            errorName: import("zod").ZodString;
+            errorMessage: import("zod").ZodString;
+            errorStack: import("zod").ZodNullable<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            errorName: string;
+            errorMessage: string;
+            errorStack: string | null;
+        }, {
+            errorName: string;
+            errorMessage: string;
+            errorStack: string | null;
+        }>;
+    };
 }

package/dist/ArvoEventHandler/index.js

@@ -66,99 +66,14 @@ var orchestrationExecutionWrapper_1 = require("../ArvoOrchestrationUtils/orchest
 var errors_1 = require("../errors");
 var utils_1 = require("../utils");
 /**
- * `ArvoEventHandler` is the foundational component for building stateless,
+ * The foundational component for building stateless,
  * contract-bound services in the Arvo system.
- *
- * It enforces strict contract validation, version-aware handler resolution,
- * and safe, observable event emission — all while maintaining type safety,
- * traceability, and support for multi-domain workflows.
- *
- * ## What It Does
- * - Ensures incoming events match the contract's `type` and `dataschema`
- * - Resolves the correct contract version using `dataschema`
- * - Validates input and output data via Zod schemas
- * - Executes the version-specific handler function
- * - Emits one or more response events based on the handler result
- * - Supports multi-domain broadcasting via `domain[]` on the emitted events
- * - Automatically emits system error events (`sys.*.error`) on failure
- * - Integrates deeply with OpenTelemetry for tracing and observability
- *
- * ## Error Boundaries
- * ArvoEventHandler enforces a clear separation between:
- *
- * - **Violations** — structural, schema, or config errors that break the contract.
- *   These are thrown and must be handled explicitly by the caller.
- *
- * - **System Errors** — runtime exceptions during execution that are caught and
- *   emitted as standardized `sys.<contract>.error` events.
- *
- * ## Domain Broadcasting
- * The handler supports multi-domain event distribution. When the handler
- * returns an event with a `domain` array, it is broadcast to one or more
- * routing contexts.
- *
- * ### System Error Domain Control
- * By default, system error events are broadcast into the source event’s domain,
- * the handler’s contract domain, and the `null` domain. This fallback ensures errors
- * are visible across all relevant contexts. Developers can override this behavior
- * using the optional `systemErrorDomain` field to specify an explicit set of
- * domain values, including symbolic constants from {@link ArvoDomain}.
- *
- * ### Supported Domain Values:
- * - A **concrete domain string** like `'audit.orders'` or `'human.review'`
- * - `null` to emit with no domain (standard internal flow)
- * - A **symbolic reference** from {@link ArvoDomain}
- *
- * ### Domain Resolution Rules:
- * - Each item in the `domain` array is resolved via {@link resolveEventDomain}
- * - Duplicate domains are deduplicated before emitting
- * - If `domain` is omitted entirely, Arvo defaults to `[null]`
- *
- * ### Example:
- * ```ts
- * return {
- *   type: 'evt.user.registered',
- *   data: { ... },
- *   domain: ['analytics', ArvoDomain.FROM_TRIGGERING_EVENT, null]
- * };
- * ```
- * This would emit at most 3 copies of the event, domained to:
- * - `'analytics'`
- * - the domain of the incoming event
- * - no domain (default)
- *
- * ### Domain Usage Guidance
- *
- * > **Avoid setting `contract.domain` unless fully intentional.**
- * 99% emitted event should default to `null` (standard processing pipeline).
- *
- * Contract-level domains enforce implicit routing for every emitted event
- * in that handler, making the behavior harder to override and debug.
- *
- * Prefer:
- * - Explicit per-event `domain` values in handler output
- * - Using `null` or symbolic constants to control domain cleanly
- *
- * ## When to Use Domains
- * Use domains when handling for specialized contexts:
- * - `'human.review'` → for human-in-the-loop steps
- * - `'analytics.workflow'` → to pipe events into observability systems
- * - `'external.partner.sync'` → to route to external services
  */
 var ArvoEventHandler = /** @class */ (function () {
-    /**
-     * Initializes a new ArvoEventHandler instance with the specified contract and configuration.
-     * Validates handler implementations against contract versions during initialization.
-     *
-     * The constructor ensures that handler implementations exist for all supported contract
-     * versions and configures OpenTelemetry span attributes for monitoring event handling.
-     *
-     * @param param - Handler configuration including contract, execution units, and handler implementations
-     * @throws When handler implementations are missing for any contract version
-     */
     function ArvoEventHandler(param) {
         var _a;
         var _b, _c;
+        /** Optional domains for routing system error events */
         this.systemErrorDomain = undefined;
         this.contract = param.contract;
         this.executionunits = param.executionunits;
@@ -181,11 +96,7 @@ var ArvoEventHandler = /** @class */ (function () {
         configurable: true
     });
     Object.defineProperty(ArvoEventHandler.prototype, "domain", {
-        /**
-         * The contract-defined domain for this handler, used as the default domain for emitted events.
-         * Can be overridden by individual handler implementations for cross-domain workflows.
-         * Returns null if no domain is specified, indicating standard processing context.
-         */
+        /** The contract-defined domain for the handler */
         get: function () {
             return this.contract.domain;
         },
@@ -197,12 +108,6 @@ var ArvoEventHandler = /** @class */ (function () {
      * handles the complete lifecycle of event processing including validation, execution, error
      * handling, and multi-domain event broadcasting, while maintaining detailed telemetry through OpenTelemetry.
      *
-     * @param event - The incoming event to process
-     * @param opentelemetry - Configuration for OpenTelemetry context inheritance, defaults to inheriting from the event
-     * @returns Promise resolving to a structured result containing an array of output events
-     * @returns Structured response containing:
-     *   - `events`: Array of events to be emitted (may contain multiple events per handler output due to domain broadcasting)
-     *
      * @throws {ContractViolation} when input or output event data violates the contract schema,
      *                             or when event emission fails due to invalid data
      * @throws {ConfigViolation} when event type doesn't match contract type, when the
@@ -351,7 +256,7 @@ var ArvoEventHandler = /** @class */ (function () {
                                                     orchestrationParentSubject: null,
                                                     initEventId: event.id,
                                                     selfContract: this.contract.version('any'),
-                                                    systemErrorDomain: undefined,
+                                                    systemErrorDomain: this.systemErrorDomain,
                                                     executionunits: this.executionunits,
                                                     source: this.source,
                                                     domain: this.domain,
@@ -382,21 +287,9 @@ var ArvoEventHandler = /** @class */ (function () {
     Object.defineProperty(ArvoEventHandler.prototype, "systemErrorSchema", {
         /**
          * Provides access to the system error event schema configuration.
-         *
-         * The schema defines the structure of error events emitted during execution failures.
-         * These events are automatically generated when runtime errors occur and follow a
-         * standardized format for consistent error handling across the system.
-         *
-         * Error events follow the naming convention: `sys.<contract-type>.error`
-         *
-         * @example
-         * For a contract handling 'com.user.create' events, system error events
-         * will have the type 'sys.com.user.create.error'
-         *
-         * @returns The error event schema containing type and validation rules
          */
         get: function () {
-            return this.contract.systemError;
+            return __assign(__assign({}, this.contract.systemError), { domain: this.systemErrorDomain });
         },
         enumerable: false,
         configurable: true

package/dist/ArvoMachine/createMachine.d.ts

@@ -6,176 +6,85 @@ import type { EnqueueArvoEventActionParam, ExtractOrchestratorType, InferService
 /**
  * Establishes the foundation for creating Arvo-compatible state machines.
  *
- * This function configures the core elements of an Arvo state machine, including
- * built-in actions like `enqueueArvoEvent`, and enforces Arvo-specific constraints
- * to ensure compatibility with the Arvo event-driven system.
+ * Designed for synchronous state machine orchestrations in Arvo's event-driven architecture.
+ * Builds upon XState with Arvo-specific constraints to enforce predictable state transitions.
  *
- * @param param - Configuration object for the machine setup
- * @returns An object containing the `createMachine` function
- * @throws {Error} If 'actors', 'delays', or reserved action names are used in the configuration
- *
- * @description
- * `setupArvoMachine` is a crucial function in the Arvo ecosystem, designed to create
- * synchronous state machine orchestrations for Arvo's event-driven architecture.
- * It builds upon XState, providing a tailored implementation that:
- *
- * 1. Enforces synchronous behavior to maintain predictable state transitions
- * 3. Implements Arvo-specific constraints and features
- *
- * Key features:
- * - Synchronous execution: Ensures deterministic behavior in event-driven systems
- * - Built-in actions: Includes `enqueueArvoEvent` for Arvo event handling
- * - Constraint checking: Prevents usage of asynchronous features like 'actors' or 'delays'
- *
- * @remarks
- * While `setupArvoMachine` is based on XState's `setup` and `createMachine` functions,
- * it includes Arvo-specific modifications and restrictions. For a deeper understanding
- * of the underlying XState concepts, refer to the official XState documentation:
- * - XState setup: https://stately.ai/docs/setup
- * - XState createMachine: https://stately.ai/docs/machines
- *
- * @example
- * Here's a comprehensive example demonstrating how to use `setupArvoMachine`:
- *
- * ```typescript
- * import { setupArvoMachine } from 'arvo-xstate'
- * import { createArvoOrchestratorContract, ArvoErrorSchema, createArvoContract } from 'arvo-core'
- * import { z } from 'zod'
- *
- * // Define the LLM orchestrator contract
- * const llmContract = createArvoOrchestratorContract({
- *   uri: `#/orchestrators/llm/`,
- *   type: 'llm',
- *   versions: {
- *     '0.0.1': {
- *       init: z.object({
- *         request: z.string(),
- *         llm: z.enum(['gpt-4', 'gpt-4o']),
- *       }),
- *       complete: z.object({
- *         response: z.string(),
- *       })
- *     }
- *   }
- * })
- *
- * // Define the OpenAI service contract
- * const openAiContract = createArvoContract({
- *   uri: `#/services/openai`,
- *   type: 'com.openai.completions',
- *   versions: {
- *     '0.0.1': {
- *       accepts: z.object({
- *         request: z.string()
- *       }),
- *       emits: {
- *         'evt.openai.completions.success': z.object({
- *           response: z.string(),
- *         })
- *       }
- *     }
- *   }
- * })
- *
- * const machineId = 'machineV100'
- *
- * // Set up the Arvo machine
- * const llmMachine = setupArvoMachine({
- *   contracts: {
- *     self: llmContract.version('0.0.1'),
- *     services: {
- *       openAiContract.version('0.0.1'),
- *     }
- *   },
- *   types: {
- *     context: {} as {
- *       request: string,
- *       llm: string,
- *       response: string | null,
- *       errors: z.infer<typeof ArvoErrorSchema>[]
- *     },
- *     tags: {} as 'pending' | 'success' | 'error',
- *   },
- *   actions: {
- *     log: ({context, event}) => console.log({context, event})
- *   },
- *   guards: {
- *     isValid: ({context, event}) => Boolean(context.request)
- *   }
- * }).createMachine({
- *   id: machineId,
- *   context: ({input}) => ({
- *     request: input.request,
- *     llm: input.llm,
- *     response: null,
- *     errors: [],
- *   }),
- *   initial: 'validate',
- *   states: {
- *     validate: {
- *       always: [
- *         {
- *           guard: 'isValid',
- *           target: 'llm',
- *         },
- *         {
- *           target: 'error',
- *         }
- *       ]
- *     },
- *     llm: {
- *       entry: [
- *         {
- *           type: 'log',
- *         },
- *         emit(({context}) => ({
- *           type: 'com.openai.completions',
- *           data: {
- *             request: context.request,
- *           },
- *         }))
- *       ],
- *       on: {
- *         'evt.openai.completions.success': {
- *           actions: [
- *             assign({response: ({event}) => event.response})
- *           ],
- *           target: 'done'
- *         },
- *         'sys.com.openai.completions.error': {
- *           actions: [
- *             assign({errors: ({context, event}) => [...context.errors, event.body]})
- *           ],
- *           target: 'error'
- *         }
- *       }
- *     },
- *     done: {
- *       type: 'final'
- *     },
- *     error: {
- *       type: 'final'
- *     },
- *   }
- * });
- * ```
- *
- * This example demonstrates:
- * 1. Defining Arvo contracts for the orchestrator and a service
- * 2. Setting up an Arvo machine with contracts, types, actions, and guards
- * 3. Creating a machine with states for validation, LLM interaction, and error handling
- * 4. Using XState features like `emit` bound with Arvo contracts for event emitting and event handling via transitions
+ * @throws {ConfigViolation} When configuration violates Arvo constraints:
+ * - Using `actors` or `delays` (async behavior not supported)
+ * - Overriding reserved `enqueueArvoEvent` action name
+ * - Machine version mismatch with contract version
+ * - Using `invoke` or `after` in state configurations
+ * - Service contracts with duplicate URIs (multiple versions of same contract)
+ * - Circular dependency (self contract URI matches a service contract URI)
  */
 export declare function setupArvoMachine<TContext extends MachineContext, TSelfContract extends VersionedArvoContract<any, any>, TServiceContracts extends Record<string, VersionedArvoContract<any, any>>, TActions extends Record<string, ParameterizedObject['params'] | undefined> = {}, TGuards extends Record<string, ParameterizedObject['params'] | undefined> = {}, TTag extends string = string, TMeta extends MetaObject = MetaObject>(param: {
     schemas?: unknown;
+    /**
+     * Contract definitions for the machine's event interface.
+     * Defines what events the machine accepts, emits, and exchanges with services.
+     */
     contracts: {
+        /**
+         * Self contract defining the machine's initialization input structure
+         * and the completion output structure when the machine finishes execution.
+         */
         self: TSelfContract;
+        /**
+         * Service contracts defining the event interfaces for external services.
+         * Each service specifies the events it accepts and emits, enabling
+         * type-safe communication between the machine and its dependencies.
+         */
         services: TServiceContracts;
     };
+    /**
+     * Type definitions for the machine's internal structure.
+     * Specifies the shape of context and other variables used throughout
+     * the machine's lifecycle. These types enable full type inference and safety.
+     */
     types?: Omit<SetupTypes<TContext, InferServiceContract<TServiceContracts>['events'], {}, TTag, InferVersionedArvoContract<TSelfContract>['accepts']['data'], InferVersionedArvoContract<TSelfContract>['emits'][ReturnType<typeof ArvoOrchestratorEventTypeGen.complete<ExtractOrchestratorType<TSelfContract['accepts']['type']>>>]['data'], InferServiceContract<TServiceContracts>['emitted'], TMeta>, 'input' | 'output' | 'children' | 'emitted'>;
+    /**
+     * Named action implementations that can be referenced throughout the machine.
+     * Actions perform side effects like data transformations, context updates,
+     * and event emissions. Each action receives the current context and event,
+     * along with any parameters defined in its type.
+     *
+     * For more information, see [xstate action docs](https://stately.ai/docs/actions)
+     *
+     * @example
+     * ```typescript
+     * actions: {
+     *   updateUser: ({ context, event }, params) => {
+     *     // Transform and update context
+     *   },
+     *   logEvent: ({ event }) => {
+     *     // Log for debugging
+     *   }
+     * }
+     * ```
+     */
     actions?: {
         [K in keyof TActions]: ActionFunction<TContext, InferServiceContract<TServiceContracts>['events'], InferServiceContract<TServiceContracts>['events'], TActions[K], never, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, never, InferServiceContract<TServiceContracts>['emitted']>;
     };
+    /**
+     * Named guard implementations that control conditional state transitions.
+     * Guards are boolean functions that determine whether a transition should occur
+     * based on the current context and event. They enable dynamic flow control
+     * without side effects.
+     *
+     * For more information, see [xstate guard docs](https://stately.ai/docs/guards)
+     *
+     * @example
+     * ```typescript
+     * guards: {
+     *   isAuthorized: ({ context, event }, params) => {
+     *     return context.user.role === 'admin';
+     *   },
+     *   hasRequiredData: ({ context }) => {
+     *     return context.data !== null;
+     *   }
+     * }
+     * ```
+     */
     guards?: {
         [K in keyof TGuards]: (args: {
             context: TContext;
@@ -183,6 +92,42 @@ export declare function setupArvoMachine<TContext extends MachineContext, TSelfC
         }, params: TGuards[K]) => boolean;
     };
 }): {
+    /**
+     * Creates an Arvo-compatible state machine with the specified configuration.
+     *
+     * Constructs a fully-typed state machine that orchestrates event-driven workflows
+     * using the contracts and types defined in setup. The machine enforces synchronous
+     * execution and validates configuration against Arvo constraints.
+     *
+     * For more information, see [xstate state machine docs](https://stately.ai/docs/states)
+     * @returns {ArvoMachine} A configured Arvo machine ready for execution
+     * @throws {ConfigViolation} When configuration violates Arvo constraints (see {@link setupArvoMachine} docs)
+     *
+     * @example
+     * ```typescript
+     * const machine = setup.createMachine({
+     *   id: 'machineV100',
+     *   initial: 'verifying',
+     *   context: ({ input }) => ({
+     *     userId: input.data.userId,
+     *     verified: false
+     *   }),
+     *   states: {
+     *     verifying: {
+     *       on: {
+     *         'com.user.verified': {
+     *           target: 'active',
+     *           actions: { type: 'updateUser' }
+     *         }
+     *       }
+     *     },
+     *     active: {
+     *       type: 'final'
+     *     }
+     *   }
+     * });
+     * ```
+     */
     createMachine: <const TConfig extends MachineConfig<TContext, InferServiceContract<TServiceContracts>["events"], ToProvidedActor<{}, {}>, ToParameterizedObject<TActions & {
         enqueueArvoEvent: EnqueueArvoEventActionParam;
     }>, ToParameterizedObject<TGuards>, never, TTag, InferVersionedArvoContract<TSelfContract>["accepts"], z.input<TSelfContract["emits"][ReturnType<typeof ArvoOrchestratorEventTypeGen.complete<ExtractOrchestratorType<TSelfContract["accepts"]["type"]>>>]> & {