@temporal-contract/worker 0.0.3 → 0.0.5

package/dist/handler-Cp9h_XCy.d.cts

@@ -0,0 +1,560 @@
+import { Future, Result } from "@temporal-contract/boxed";
+import { ActivityOptions, ChildWorkflowOptions, WorkflowInfo } from "@temporalio/workflow";
+import { ActivityDefinition, AnySchema, ContractDefinition, QueryDefinition, SignalDefinition, UpdateDefinition, WorkflowDefinition } from "@temporal-contract/contract";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/types.d.ts
+/**
+ * Infer input type from a definition (worker perspective)
+ * Worker receives the output type (after input schema parsing/transformation)
+ */
+type WorkerInferInput<T extends {
+  input: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["input"]>;
+/**
+ * Infer output type from a definition (worker perspective)
+ * Worker returns the input type (before output schema parsing/transformation)
+ */
+type WorkerInferOutput<T extends {
+  output: AnySchema;
+}> = StandardSchemaV1.InferInput<T["output"]>;
+/**
+ * WORKER PERSPECTIVE
+ * Worker receives z.output of input (parsed data) and returns z.input of output (raw data)
+ */
+/**
+ * Infer workflow function signature from worker perspective
+ * Worker receives z.input and returns z.output
+ */
+type WorkerInferWorkflow<TWorkflow extends WorkflowDefinition> = (args: WorkerInferInput<TWorkflow>) => Promise<WorkerInferOutput<TWorkflow>>;
+/**
+ * Infer activity function signature from worker perspective
+ * Worker receives z.input and returns z.output
+ */
+type WorkerInferActivity<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Promise<WorkerInferOutput<TActivity>>;
+/**
+ * Infer signal handler signature from worker perspective
+ * Worker receives z.input
+ */
+type WorkerInferSignal<TSignal extends SignalDefinition> = (args: WorkerInferInput<TSignal>) => Promise<void>;
+/**
+ * Infer query handler signature from worker perspective
+ * Worker receives z.input and returns z.output
+ */
+type WorkerInferQuery<TQuery extends QueryDefinition> = (args: WorkerInferInput<TQuery>) => Promise<WorkerInferOutput<TQuery>>;
+/**
+ * Infer update handler signature from worker perspective
+ * Worker receives z.input and returns z.output
+ */
+type WorkerInferUpdate<TUpdate extends UpdateDefinition> = (args: WorkerInferInput<TUpdate>) => Promise<WorkerInferOutput<TUpdate>>;
+/**
+ * WORKER PERSPECTIVE - Contract-level types
+ */
+/**
+ * Infer all workflows from a contract (worker perspective)
+ */
+type WorkerInferWorkflows<TContract extends ContractDefinition> = { [K in keyof TContract["workflows"]]: WorkerInferWorkflow<TContract["workflows"][K]> };
+/**
+ * Infer all activities from a contract (worker perspective)
+ */
+type WorkerInferActivities<TContract extends ContractDefinition> = TContract["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof TContract["activities"]]: WorkerInferActivity<TContract["activities"][K]> } : {};
+/**
+ * Infer activities from a workflow definition (worker perspective)
+ */
+type WorkerInferWorkflowActivities<T extends WorkflowDefinition> = T["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof T["activities"]]: WorkerInferActivity<T["activities"][K]> } : {};
+/**
+ * Infer signals from a workflow definition (worker perspective)
+ */
+type WorkerInferWorkflowSignals<T extends WorkflowDefinition> = T["signals"] extends Record<string, SignalDefinition> ? { [K in keyof T["signals"]]: WorkerInferSignal<T["signals"][K]> } : {};
+/**
+ * Infer queries from a workflow definition (worker perspective)
+ */
+type WorkerInferWorkflowQueries<T extends WorkflowDefinition> = T["queries"] extends Record<string, QueryDefinition> ? { [K in keyof T["queries"]]: WorkerInferQuery<T["queries"][K]> } : {};
+/**
+ * Infer updates from a workflow definition (worker perspective)
+ */
+type WorkerInferWorkflowUpdates<T extends WorkflowDefinition> = T["updates"] extends Record<string, UpdateDefinition> ? { [K in keyof T["updates"]]: WorkerInferUpdate<T["updates"][K]> } : {};
+/**
+ * Infer all activities available in a workflow context (worker perspective)
+ * Combines workflow-specific activities with global activities
+ */
+type WorkerInferWorkflowContextActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = WorkerInferWorkflowActivities<TContract["workflows"][TWorkflowName]> & WorkerInferActivities<TContract>;
+/**
+ * UTILITY TYPES FOR ACTIVITY HANDLERS
+ */
+/**
+ * Infer the handler type for a global activity from a contract
+ *
+ * @example
+ * ```typescript
+ * const log: ActivityHandler<typeof myContract, "log"> = async ({ level, message }) => {
+ *   logger[level](message);
+ * };
+ * ```
+ */
+type ActivityHandler<TContract extends ContractDefinition, TActivityName extends keyof TContract["activities"]> = TContract["activities"] extends Record<string, ActivityDefinition> ? (args: WorkerInferInput<TContract["activities"][TActivityName]>) => Promise<WorkerInferOutput<TContract["activities"][TActivityName]>> : never;
+/**
+ * Infer the handler type for a workflow-specific activity from a contract
+ *
+ * @example
+ * ```typescript
+ * const processPayment: WorkflowActivityHandler<
+ *   typeof myContract,
+ *   "processOrder",
+ *   "processPayment"
+ * > = async ({ customerId, amount }) => {
+ *   // Implementation
+ *   return { transactionId, status: "success" as const, paidAmount: amount };
+ * };
+ * ```
+ */
+type WorkflowActivityHandler<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"], TActivityName extends keyof TContract["workflows"][TWorkflowName]["activities"]> = TContract["workflows"][TWorkflowName]["activities"] extends Record<string, ActivityDefinition> ? (args: WorkerInferInput<TContract["workflows"][TWorkflowName]["activities"][TActivityName]>) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]["activities"][TActivityName]>> : never;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * Base error class for worker errors
+ */
+declare class WorkerError extends Error {
+  constructor(message: string, cause?: unknown);
+}
+/**
+ * Activity error class that should be used to wrap all technical exceptions
+ * Forces proper error handling and enables retry policies
+ */
+declare class ActivityError extends Error {
+  readonly code: string;
+  readonly cause?: unknown;
+  constructor(code: string, message: string, cause?: unknown);
+}
+/**
+ * Error thrown when an activity definition is not found in the contract
+ */
+declare class ActivityDefinitionNotFoundError extends WorkerError {
+  readonly activityName: string;
+  readonly availableDefinitions: readonly string[];
+  constructor(activityName: string, availableDefinitions?: readonly string[]);
+}
+/**
+ * Error thrown when activity input validation fails
+ */
+declare class ActivityInputValidationError extends WorkerError {
+  readonly activityName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when activity output validation fails
+ */
+declare class ActivityOutputValidationError extends WorkerError {
+  readonly activityName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when workflow input validation fails
+ */
+declare class WorkflowInputValidationError extends WorkerError {
+  readonly workflowName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when workflow output validation fails
+ */
+declare class WorkflowOutputValidationError extends WorkerError {
+  readonly workflowName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when signal input validation fails
+ */
+declare class SignalInputValidationError extends WorkerError {
+  readonly signalName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(signalName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when query input validation fails
+ */
+declare class QueryInputValidationError extends WorkerError {
+  readonly queryName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when query output validation fails
+ */
+declare class QueryOutputValidationError extends WorkerError {
+  readonly queryName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when update input validation fails
+ */
+declare class UpdateInputValidationError extends WorkerError {
+  readonly updateName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when update output validation fails
+ */
+declare class UpdateOutputValidationError extends WorkerError {
+  readonly updateName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when a child workflow is not found in the contract
+ */
+declare class ChildWorkflowNotFoundError extends WorkerError {
+  readonly workflowName: string;
+  readonly availableWorkflows: readonly string[];
+  constructor(workflowName: string, availableWorkflows?: readonly string[]);
+}
+/**
+ * Generic error for child workflow operations
+ */
+declare class ChildWorkflowError extends WorkerError {
+  constructor(message: string, cause?: unknown);
+}
+//#endregion
+//#region src/handler.d.ts
+/**
+ * Typed handle for a child workflow with Future/Result pattern
+ */
+interface TypedChildWorkflowHandle<TWorkflow extends WorkflowDefinition> {
+  /**
+   * Get child workflow result with Result pattern
+   */
+  result: () => Future<Result<WorkerInferOutput<TWorkflow>, ChildWorkflowError>>;
+  /**
+   * Child workflow ID
+   */
+  workflowId: string;
+}
+/**
+ * Options for starting a child workflow
+ */
+type TypedChildWorkflowOptions = Pick<ChildWorkflowOptions, "workflowId" | "workflowIdReusePolicy" | "parentClosePolicy" | "workflowExecutionTimeout" | "workflowRunTimeout" | "workflowTaskTimeout" | "retry" | "memo" | "searchAttributes" | "cronSchedule" | "cancellationType">;
+/**
+ * Workflow context with typed activities (workflow + global) and workflow info
+ * Note: activities is typed as 'any' to work around TypeScript generic type inference limitations with Zod tuples
+ */
+interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> {
+  activities: WorkerInferWorkflowContextActivities<TContract, TWorkflowName>;
+  info: WorkflowInfo;
+  /**
+   * Define a signal handler within the workflow implementation
+   * Allows the signal handler to access workflow state
+   *
+   * @example
+   * ```ts
+   * implementation: async (context, args) => {
+   *   let currentValue = args.initialValue;
+   *
+   *   context.defineSignal('increment', async (signalArgs) => {
+   *     currentValue += signalArgs.amount;
+   *   });
+   *
+   *   // ... rest of workflow
+   * }
+   * ```
+   */
+  defineSignal: <K$1 extends keyof TContract["workflows"][TWorkflowName]["signals"]>(signalName: K$1, handler: SignalHandlerImplementation<TContract["workflows"][TWorkflowName]["signals"][K$1] extends SignalDefinition ? TContract["workflows"][TWorkflowName]["signals"][K$1] : never>) => void;
+  /**
+   * Define a query handler within the workflow implementation
+   * Allows the query handler to access workflow state
+   *
+   * @example
+   * ```ts
+   * implementation: async (context, args) => {
+   *   let currentValue = args.initialValue;
+   *
+   *   context.defineQuery('getCurrentValue', () => {
+   *     return { value: currentValue };
+   *   });
+   *
+   *   // ... rest of workflow
+   * }
+   * ```
+   */
+  defineQuery: <K$1 extends keyof TContract["workflows"][TWorkflowName]["queries"]>(queryName: K$1, handler: QueryHandlerImplementation<TContract["workflows"][TWorkflowName]["queries"][K$1] extends QueryDefinition ? TContract["workflows"][TWorkflowName]["queries"][K$1] : never>) => void;
+  /**
+   * Define an update handler within the workflow implementation
+   * Allows the update handler to access and modify workflow state
+   *
+   * @example
+   * ```ts
+   * implementation: async (context, args) => {
+   *   let currentValue = args.initialValue;
+   *
+   *   context.defineUpdate('multiply', async (updateArgs) => {
+   *     currentValue *= updateArgs.factor;
+   *     return { newValue: currentValue };
+   *   });
+   *
+   *   // ... rest of workflow
+   * }
+   * ```
+   */
+  defineUpdate: <K$1 extends keyof TContract["workflows"][TWorkflowName]["updates"]>(updateName: K$1, handler: UpdateHandlerImplementation<TContract["workflows"][TWorkflowName]["updates"][K$1] extends UpdateDefinition ? TContract["workflows"][TWorkflowName]["updates"][K$1] : never>) => void;
+  /**
+   * Start a child workflow and return a typed handle with Future/Result pattern
+   *
+   * Supports both same-contract and cross-contract child workflows:
+   * - Same contract: Pass workflowName from current contract
+   * - Cross-contract: Pass contract and workflowName to invoke workflows from other workers
+   *
+   * @example
+   * ```ts
+   * // Same contract child workflow
+   * const childResult = await context.startChildWorkflow(myContract, 'processPayment', {
+   *   workflowId: 'payment-123',
+   *   args: { amount: 100 }
+   * });
+   *
+   * // Cross-contract child workflow (from another worker)
+   * const otherResult = await context.startChildWorkflow(otherContract, 'sendNotification', {
+   *   workflowId: 'notification-123',
+   *   args: { message: 'Hello' }
+   * });
+   *
+   * childResult.match({
+   *   Ok: async (handle) => {
+   *     const result = await handle.result();
+   *     // ... handle result
+   *   },
+   *   Error: (error) => console.error('Failed to start:', error),
+   * });
+   * ```
+   */
+  startChildWorkflow: <TChildContract extends ContractDefinition, TChildWorkflowName extends keyof TChildContract["workflows"]>(contract: TChildContract, workflowName: TChildWorkflowName, options: TypedChildWorkflowOptions & {
+    args: WorkerInferInput<TChildContract["workflows"][TChildWorkflowName]>;
+  }) => Future<Result<TypedChildWorkflowHandle<TChildContract["workflows"][TChildWorkflowName]>, ChildWorkflowError>>;
+  /**
+   * Execute a child workflow (start and wait for result) with Future/Result pattern
+   *
+   * Supports both same-contract and cross-contract child workflows:
+   * - Same contract: Pass workflowName from current contract
+   * - Cross-contract: Pass contract and workflowName to invoke workflows from other workers
+   *
+   * @example
+   * ```ts
+   * // Same contract child workflow
+   * const result = await context.executeChildWorkflow(myContract, 'processPayment', {
+   *   workflowId: 'payment-123',
+   *   args: { amount: 100 }
+   * });
+   *
+   * // Cross-contract child workflow (from another worker)
+   * const otherResult = await context.executeChildWorkflow(otherContract, 'sendNotification', {
+   *   workflowId: 'notification-123',
+   *   args: { message: 'Hello' }
+   * });
+   *
+   * result.match({
+   *   Ok: (output) => console.log('Payment processed:', output),
+   *   Error: (error) => console.error('Processing failed:', error),
+   * });
+   * ```
+   */
+  executeChildWorkflow: <TChildContract extends ContractDefinition, TChildWorkflowName extends keyof TChildContract["workflows"]>(contract: TChildContract, workflowName: TChildWorkflowName, options: TypedChildWorkflowOptions & {
+    args: WorkerInferInput<TChildContract["workflows"][TChildWorkflowName]>;
+  }) => Future<Result<WorkerInferOutput<TChildContract["workflows"][TChildWorkflowName]>, ChildWorkflowError>>;
+}
+/**
+ * Workflow implementation function (receives context + typed args as tuple)
+ * Note: We use 'any' for args to work around TypeScript limitations with generic Zod tuple inference
+ * The actual type will be enforced at runtime by Zod validation
+ */
+type WorkflowImplementation<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = (context: WorkflowContext<TContract, TWorkflowName>, args: WorkerInferInput<TContract["workflows"][TWorkflowName]>) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]>>;
+/**
+ * Activity implementation using Result pattern
+ * Returns Future<Result<Output, ActivityError>> instead of throwing exceptions
+ */
+type BoxedActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;
+/**
+ * Signal handler implementation
+ */
+type SignalHandlerImplementation<TSignal extends SignalDefinition> = (args: WorkerInferInput<TSignal>) => void | Promise<void>;
+/**
+ * Query handler implementation
+ */
+type QueryHandlerImplementation<TQuery extends QueryDefinition> = (args: WorkerInferInput<TQuery>) => WorkerInferOutput<TQuery>;
+/**
+ * Update handler implementation
+ */
+type UpdateHandlerImplementation<TUpdate extends UpdateDefinition> = (args: WorkerInferInput<TUpdate>) => Promise<WorkerInferOutput<TUpdate>>;
+/**
+ * Map of all activity implementations for a contract (global + all workflow-specific)
+ */
+type ActivityImplementations<T extends ContractDefinition> = (T["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof T["activities"]]: BoxedActivityImplementation<T["activities"][K]> } : {}) & UnionToIntersection<{ [K in keyof T["workflows"]]: T["workflows"][K]["activities"] extends Record<string, ActivityDefinition> ? { [A in keyof T["workflows"][K]["activities"]]: BoxedActivityImplementation<T["workflows"][K]["activities"][A]> } : {} }[keyof T["workflows"]]>;
+/**
+ * Utility type to convert union to intersection
+ */
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/**
+ * Options for creating activities handler
+ */
+interface DeclareActivitiesHandlerOptions<T extends ContractDefinition> {
+  contract: T;
+  activities: ActivityImplementations<T>;
+}
+/**
+ * Activities handler ready for Temporal Worker
+ */
+interface ActivitiesHandler<T extends ContractDefinition> {
+  contract: T;
+  activities: Record<string, (...args: unknown[]) => Promise<unknown>>;
+}
+/**
+ * Options for declaring a workflow implementation
+ */
+interface DeclareWorkflowOptions<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> {
+  workflowName: TWorkflowName;
+  contract: TContract;
+  implementation: WorkflowImplementation<TContract, TWorkflowName>;
+  /**
+   * Default activity options applied to all activities in this workflow.
+   * These will be merged with the default startToCloseTimeout of 60 seconds.
+   * For more control, you can override specific Temporal ActivityOptions like:
+   * - startToCloseTimeout: Maximum time for activity execution
+   * - scheduleToCloseTimeout: End-to-end timeout including queuing
+   * - scheduleToStartTimeout: Maximum time activity can wait in queue
+   * - heartbeatTimeout: Time between heartbeats before considering activity dead
+   * - retry: Retry policy for failed activities
+   *
+   * @example
+   * ```ts
+   * activityOptions: {
+   *   startToCloseTimeout: '5m',
+   *   retry: { maximumAttempts: 3 }
+   * }
+   * ```
+   */
+  activityOptions?: ActivityOptions;
+}
+/**
+ * Create a typed activities handler with automatic validation and Result pattern
+ *
+ * This wraps all activity implementations with:
+ * - Validation at network boundaries
+ * - Result<T, ActivityError> pattern for explicit error handling
+ * - Automatic conversion from Result to Promise (throwing on Error)
+ *
+ * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
+ *
+ * Use this to create the activities object for the Temporal Worker.
+ *
+ * @example
+ * ```ts
+ * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+ * import { Result, Future } from '@temporal-contract/boxed';
+ * import myContract from './contract';
+ *
+ * export const activitiesHandler = declareActivitiesHandler({
+ *   contract: myContract,
+ *   activities: {
+ *     // Activity returns Result instead of throwing
+ *     // All technical exceptions must be wrapped in ActivityError for retry policies
+ *     sendEmail: (args) => {
+ *       return Future.make(async resolve => {
+ *         try {
+ *           await emailService.send(args);
+ *           resolve(Result.Ok({ sent: true }));
+ *         } catch (error) {
+ *           // Wrap technical errors in ActivityError to enable retries
+ *           resolve(Result.Error(
+ *             new ActivityError(
+ *               'EMAIL_SEND_FAILED',
+ *               'Failed to send email',
+ *               error // Original error as cause for debugging
+ *             )
+ *           ));
+ *         }
+ *       });
+ *     },
+ *   },
+ * });
+ *
+ * // Use with Temporal Worker
+ * import { Worker } from '@temporalio/worker';
+ *
+ * const worker = await Worker.create({
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities: activitiesHandler.activities,
+ *   taskQueue: activitiesHandler.contract.taskQueue,
+ * });
+ * ```
+ */
+declare function declareActivitiesHandler<T extends ContractDefinition>(options: DeclareActivitiesHandlerOptions<T>): ActivitiesHandler<T>;
+/**
+ * Create a typed workflow implementation with automatic validation
+ *
+ * This wraps a workflow implementation with:
+ * - Input/output validation
+ * - Typed workflow context with activities
+ * - Workflow info access
+ *
+ * Workflows must be defined in separate files and imported by the Temporal Worker
+ * via workflowsPath.
+ *
+ * @example
+ * ```ts
+ * // workflows/processOrder.ts
+ * import { declareWorkflow } from '@temporal-contract/worker';
+ * import myContract from '../contract';
+ *
+ * export const processOrder = declareWorkflow({
+ *   workflowName: 'processOrder',
+ *   contract: myContract,
+ *   implementation: async (context, orderId, customerId) => {
+ *     // context.activities: typed activities (workflow + global)
+ *     // context.info: WorkflowInfo
+ *
+ *     const inventory = await context.activities.validateInventory(orderId);
+ *
+ *     if (!inventory.available) {
+ *       throw new Error('Out of stock');
+ *     }
+ *
+ *     const payment = await context.activities.chargePayment(customerId, 100);
+ *
+ *     // Global activity
+ *     await context.activities.sendEmail(
+ *       customerId,
+ *       'Order processed',
+ *       'Your order has been processed'
+ *     );
+ *
+ *     return {
+ *       orderId,
+ *       status: payment.success ? 'success' : 'failed',
+ *       transactionId: payment.transactionId,
+ *     };
+ *   },
+ *   activityOptions: {
+ *     startToCloseTimeout: '1 minute',
+ *   },
+ * });
+ * ```
+ *
+ * Then in your worker setup:
+ * ```ts
+ * // worker.ts
+ * import { Worker } from '@temporalio/worker';
+ * import { activitiesHandler } from './activities';
+ *
+ * const worker = await Worker.create({
+ *   workflowsPath: require.resolve('./workflows'), // Imports processOrder
+ *   activities: activitiesHandler.activities,
+ *   taskQueue: activitiesHandler.contract.taskQueue,
+ * });
+ * ```
+ */
+declare function declareWorkflow<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(options: DeclareWorkflowOptions<TContract, TWorkflowName>): (args: WorkerInferInput<TContract["workflows"][TWorkflowName]>) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]>>;
+//#endregion
+export { WorkerInferActivities as A, WorkerInferWorkflowQueries as B, SignalInputValidationError as C, WorkflowInputValidationError as D, WorkerError as E, WorkerInferSignal as F, WorkerInferWorkflowUpdates as H, WorkerInferUpdate as I, WorkerInferWorkflow as L, WorkerInferInput as M, WorkerInferOutput as N, WorkflowOutputValidationError as O, WorkerInferQuery as P, WorkerInferWorkflowActivities as R, QueryOutputValidationError as S, UpdateOutputValidationError as T, WorkerInferWorkflows as U, WorkerInferWorkflowSignals as V, WorkflowActivityHandler as W, ActivityInputValidationError as _, DeclareWorkflowOptions as a, ChildWorkflowNotFoundError as b, TypedChildWorkflowHandle as c, WorkflowContext as d, WorkflowImplementation as f, ActivityError as g, ActivityDefinitionNotFoundError as h, DeclareActivitiesHandlerOptions as i, WorkerInferActivity as j, ActivityHandler as k, TypedChildWorkflowOptions as l, declareWorkflow as m, ActivityImplementations as n, QueryHandlerImplementation as o, declareActivitiesHandler as p, BoxedActivityImplementation as r, SignalHandlerImplementation as s, ActivitiesHandler as t, UpdateHandlerImplementation as u, ActivityOutputValidationError as v, UpdateInputValidationError as w, QueryInputValidationError as x, ChildWorkflowError as y, WorkerInferWorkflowContextActivities as z };