@temporalio/client 1.11.2 → 1.11.4

package/src/task-queue-client.ts

@@ -1,6 +1,7 @@
 import { status } from '@grpc/grpc-js';
 import { filterNullAndUndefined } from '@temporalio/common/lib/internal-non-workflow';
 import { assertNever, SymbolBasedInstanceOfError, RequireAtLeastOne } from '@temporalio/common/lib/type-helpers';
+import { makeProtoEnumConverters } from '@temporalio/common/lib/internal-workflow';
 import { temporal } from '@temporalio/proto';
 import { BaseClient, BaseClientOptions, defaultBaseClientOptions, LoadedWithDefaults } from './base-client';
 import { WorkflowService } from './types';
@@ -148,7 +149,7 @@ export class TaskQueueClient extends BaseClient {
         namespace: this.options.namespace,
         taskQueues: options.taskQueues,
         buildIds,
-        reachability: reachabilityTypeToProto(options.reachability),
+        reachability: encodeTaskReachability(options.reachability),
       });
     } catch (e) {
       this.rethrowGrpcError(e, 'Unexpected error fetching Build Id reachability');
@@ -173,6 +174,20 @@ export class TaskQueueClient extends BaseClient {
  */
 export type ReachabilityOptions = RequireAtLeastOne<BaseReachabilityOptions, 'buildIds' | 'taskQueues'>;
 
+export const ReachabilityType = {
+  /** The Build Id might be used by new workflows. */
+  NEW_WORKFLOWS: 'NEW_WORKFLOWS',
+
+  /** The Build Id might be used by open workflows and/or closed workflows. */
+  EXISTING_WORKFLOWS: 'EXISTING_WORKFLOWS',
+
+  /** The Build Id might be used by open workflows. */
+  OPEN_WORKFLOWS: 'OPEN_WORKFLOWS',
+
+  /** The Build Id might be used by closed workflows. */
+  CLOSED_WORKFLOWS: 'CLOSED_WORKFLOWS',
+} as const;
+
 /**
  * There are different types of reachability:
  *   - `NEW_WORKFLOWS`: The Build Id might be used by new workflows
@@ -180,7 +195,24 @@ export type ReachabilityOptions = RequireAtLeastOne<BaseReachabilityOptions, 'bu
  *   - `OPEN_WORKFLOWS` The Build Id might be used by open workflows
  *   - `CLOSED_WORKFLOWS` The Build Id might be used by closed workflows
  */
-export type ReachabilityType = 'NEW_WORKFLOWS' | 'EXISTING_WORKFLOWS' | 'OPEN_WORKFLOWS' | 'CLOSED_WORKFLOWS';
+export type ReachabilityType = (typeof ReachabilityType)[keyof typeof ReachabilityType];
+
+export const [encodeTaskReachability, decodeTaskReachability] = makeProtoEnumConverters<
+  temporal.api.enums.v1.TaskReachability,
+  typeof temporal.api.enums.v1.TaskReachability,
+  keyof typeof temporal.api.enums.v1.TaskReachability,
+  typeof ReachabilityType,
+  'TASK_REACHABILITY_'
+>(
+  {
+    [ReachabilityType.NEW_WORKFLOWS]: 1,
+    [ReachabilityType.EXISTING_WORKFLOWS]: 2,
+    [ReachabilityType.OPEN_WORKFLOWS]: 3,
+    [ReachabilityType.CLOSED_WORKFLOWS]: 4,
+    UNSPECIFIED: 0,
+  } as const,
+  'TASK_REACHABILITY_'
+);
 
 /**
  * See {@link ReachabilityOptions}
@@ -215,24 +247,6 @@ export interface BuildIdReachability {
   taskQueueReachability: Record<string, ReachabilityTypeResponse[]>;
 }
 
-function reachabilityTypeToProto(type: ReachabilityType | undefined | null): temporal.api.enums.v1.TaskReachability {
-  switch (type) {
-    case null:
-    case undefined:
-      return temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_UNSPECIFIED;
-    case 'NEW_WORKFLOWS':
-      return temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_NEW_WORKFLOWS;
-    case 'EXISTING_WORKFLOWS':
-      return temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_EXISTING_WORKFLOWS;
-    case 'OPEN_WORKFLOWS':
-      return temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_OPEN_WORKFLOWS;
-    case 'CLOSED_WORKFLOWS':
-      return temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_CLOSED_WORKFLOWS;
-    default:
-      assertNever('Unknown Build Id reachability operation', type);
-  }
-}
-
 export function reachabilityResponseFromProto(resp: GetWorkerTaskReachabilityResponse): ReachabilityResponse {
   return {
     buildIdReachability: Object.fromEntries(
@@ -247,7 +261,9 @@ export function reachabilityResponseFromProto(resp: GetWorkerTaskReachabilityRes
               taskQueueReachability[tqr.taskQueue] = [];
               continue;
             }
-            taskQueueReachability[tqr.taskQueue] = tqr.reachability.map(reachabilityTypeFromProto);
+            taskQueueReachability[tqr.taskQueue] = tqr.reachability.map(
+              (x) => decodeTaskReachability(x) ?? 'NOT_FETCHED'
+            );
           }
         }
         let bid: string | UnversionedBuildIdType;
@@ -262,23 +278,6 @@ export function reachabilityResponseFromProto(resp: GetWorkerTaskReachabilityRes
   };
 }
 
-function reachabilityTypeFromProto(rtype: temporal.api.enums.v1.TaskReachability): ReachabilityTypeResponse {
-  switch (rtype) {
-    case temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_UNSPECIFIED:
-      return 'NOT_FETCHED';
-    case temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_NEW_WORKFLOWS:
-      return 'NEW_WORKFLOWS';
-    case temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_EXISTING_WORKFLOWS:
-      return 'EXISTING_WORKFLOWS';
-    case temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_OPEN_WORKFLOWS:
-      return 'OPEN_WORKFLOWS';
-    case temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_CLOSED_WORKFLOWS:
-      return 'CLOSED_WORKFLOWS';
-    default:
-      return assertNever('Unknown Build Id reachability operation', rtype);
-  }
-}
-
 /**
  * Thrown when one or more Build Ids are not found while using the {@link TaskQueueClient}.
  *

package/src/types.ts

@@ -1,5 +1,6 @@
 import type * as grpc from '@grpc/grpc-js';
 import type { SearchAttributes } from '@temporalio/common';
+import { makeProtoEnumConverters } from '@temporalio/common/lib/internal-workflow';
 import * as proto from '@temporalio/proto';
 import { Replace } from '@temporalio/common/lib/type-helpers';
 
@@ -96,8 +97,24 @@ export interface ConnectionLike {
   workflowService: WorkflowService;
   close(): Promise<void>;
   ensureConnected(): Promise<void>;
+
   /**
-   * Set the deadline for any service requests executed in `fn`'s scope.
+   * Set a deadline for any service requests executed in `fn`'s scope.
+   *
+   * The deadline is a point in time after which any pending gRPC request will be considered as failed;
+   * this will locally result in the request call throwing a {@link grpc.ServiceError|ServiceError}
+   * with code {@link grpc.status.DEADLINE_EXCEEDED|DEADLINE_EXCEEDED}; see {@link isGrpcDeadlineError}.
+   *
+   * It is stronly recommended to explicitly set deadlines. If no deadline is set, then it is
+   * possible for the client to end up waiting forever for a response.
+   *
+   * This method is only a convenience wrapper around {@link Connection.withDeadline}.
+   *
+   * @param deadline a point in time after which the request will be considered as failed; either a
+   *                 Date object, or a number of milliseconds since the Unix epoch (UTC).
+   * @returns the value returned from `fn`
+   *
+   * @see https://grpc.io/docs/guides/deadlines/
    */
   withDeadline<R>(deadline: number | Date, fn: () => Promise<R>): Promise<R>;
 
@@ -109,10 +126,48 @@ export interface ConnectionLike {
   withMetadata<R>(metadata: Metadata, fn: () => Promise<R>): Promise<R>;
 
   /**
-   * Set an {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} that, when aborted,
-   * cancels any ongoing requests executed in `fn`'s scope.
+   * Set an {@link AbortSignal} that, when aborted, cancels any ongoing service requests executed in
+   * `fn`'s scope. This will locally result in the request call throwing a {@link grpc.ServiceError|ServiceError}
+   * with code {@link grpc.status.CANCELLED|CANCELLED}; see {@link isGrpcCancelledError}.
    *
    * @returns value returned from `fn`
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
    */
   withAbortSignal<R>(abortSignal: AbortSignal, fn: () => Promise<R>): Promise<R>;
 }
+
+export const QueryRejectCondition = {
+  NONE: 'NONE',
+  NOT_OPEN: 'NOT_OPEN',
+  NOT_COMPLETED_CLEANLY: 'NOT_COMPLETED_CLEANLY',
+
+  /** @deprecated Use {@link NONE} instead. */
+  QUERY_REJECT_CONDITION_NONE: 'NONE', // eslint-disable-line deprecation/deprecation
+
+  /** @deprecated Use {@link NOT_OPEN} instead. */
+  QUERY_REJECT_CONDITION_NOT_OPEN: 'NOT_OPEN', // eslint-disable-line deprecation/deprecation
+
+  /** @deprecated Use {@link NOT_COMPLETED_CLEANLY} instead. */
+  QUERY_REJECT_CONDITION_NOT_COMPLETED_CLEANLY: 'NOT_COMPLETED_CLEANLY', // eslint-disable-line deprecation/deprecation
+
+  /** @deprecated Use `undefined` instead. */
+  QUERY_REJECT_CONDITION_UNSPECIFIED: undefined, // eslint-disable-line deprecation/deprecation
+} as const;
+export type QueryRejectCondition = (typeof QueryRejectCondition)[keyof typeof QueryRejectCondition];
+
+export const [encodeQueryRejectCondition, decodeQueryRejectCondition] = makeProtoEnumConverters<
+  proto.temporal.api.enums.v1.QueryRejectCondition,
+  typeof proto.temporal.api.enums.v1.QueryRejectCondition,
+  keyof typeof proto.temporal.api.enums.v1.QueryRejectCondition,
+  typeof QueryRejectCondition,
+  'QUERY_REJECT_CONDITION_'
+>(
+  {
+    [QueryRejectCondition.NONE]: 1,
+    [QueryRejectCondition.NOT_OPEN]: 2,
+    [QueryRejectCondition.NOT_COMPLETED_CLEANLY]: 3,
+    UNSPECIFIED: 0,
+  } as const,
+  'QUERY_REJECT_CONDITION_'
+);

package/src/workflow-client.ts

@@ -20,6 +20,9 @@ import {
   WorkflowNotFoundError,
   WorkflowResultType,
   extractWorkflowType,
+  encodeWorkflowIdReusePolicy,
+  decodeRetryState,
+  encodeWorkflowIdConflictPolicy,
 } from '@temporalio/common';
 import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import { History } from '@temporalio/common/lib/proto-utils';
@@ -56,7 +59,9 @@ import {
 } from './interceptors';
 import {
   DescribeWorkflowExecutionResponse,
+  encodeQueryRejectCondition,
   GetWorkflowExecutionHistoryRequest,
+  QueryRejectCondition,
   RequestCancelWorkflowExecutionResponse,
   StartWorkflowExecutionRequest,
   TerminateWorkflowExecutionResponse,
@@ -81,8 +86,9 @@ import {
   WithDefaults,
 } from './base-client';
 import { mapAsyncIterable } from './iterators-utils';
-import { WorkflowUpdateStage } from './workflow-update-stage';
-import * as workflowUpdateStage from './workflow-update-stage';
+import { WorkflowUpdateStage, encodeWorkflowUpdateStage } from './workflow-update-stage';
+
+const UpdateWorkflowExecutionLifecycleStage = temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage;
 
 /**
  * A client side handle to a single Workflow instance.
@@ -168,7 +174,7 @@ export interface WorkflowHandle<T extends Workflow = Workflow> extends BaseWorkf
    * ```ts
    * const updateHandle = await handle.startUpdate(incrementAndGetValueUpdate, {
    *   args: [2],
-   *   waitForStage: WorkflowUpdateStage.ACCEPTED,
+   *   waitForStage: 'ACCEPTED',
    * });
    * const updateResult = await updateHandle.result();
    * ```
@@ -177,7 +183,7 @@ export interface WorkflowHandle<T extends Workflow = Workflow> extends BaseWorkf
     def: UpdateDefinition<Ret, Args, Name> | string,
     options: WorkflowUpdateOptions & {
       args: Args;
-      waitForStage: WorkflowUpdateStage.ACCEPTED;
+      waitForStage: 'ACCEPTED';
     }
   ): Promise<WorkflowUpdateHandle<Ret>>;
 
@@ -185,7 +191,7 @@ export interface WorkflowHandle<T extends Workflow = Workflow> extends BaseWorkf
     def: UpdateDefinition<Ret, Args, Name> | string,
     options: WorkflowUpdateOptions & {
       args?: Args;
-      waitForStage: WorkflowUpdateStage.ACCEPTED;
+      waitForStage: typeof WorkflowUpdateStage.ACCEPTED;
     }
   ): Promise<WorkflowUpdateHandle<Ret>>;
 
@@ -280,9 +286,9 @@ export interface WorkflowClientOptions extends BaseClientOptions {
   /**
    * Should a query be rejected by closed and failed workflows
    *
-   * @default QUERY_REJECT_CONDITION_UNSPECIFIED which means that closed and failed workflows are still queryable
+   * @default `undefined` which means that closed and failed workflows are still queryable
    */
-  queryRejectCondition?: temporal.api.enums.v1.QueryRejectCondition;
+  queryRejectCondition?: QueryRejectCondition;
 }
 
 export type LoadedWorkflowClientOptions = LoadedWithDefaults<WorkflowClientOptions>;
@@ -291,7 +297,7 @@ function defaultWorkflowClientOptions(): WithDefaults<WorkflowClientOptions> {
   return {
     ...defaultBaseClientOptions(),
     interceptors: [],
-    queryRejectCondition: temporal.api.enums.v1.QueryRejectCondition.QUERY_REJECT_CONDITION_UNSPECIFIED,
+    queryRejectCondition: 'NONE',
   };
 }
 
@@ -308,7 +314,7 @@ function ensureArgs<W extends Workflow, T extends WorkflowStartOptions<W>>(
   opts: T
 ): Omit<T, 'args'> & { args: unknown[] } {
   const { args, ...rest } = opts;
-  return { args: args ?? [], ...rest };
+  return { args: (args as unknown[]) ?? [], ...rest };
 }
 
 /**
@@ -659,7 +665,7 @@ export class WorkflowClient extends BaseClient {
         throw new WorkflowFailedError(
           'Workflow execution failed',
           await decodeOptionalFailureToOptionalError(this.dataConverter, failure),
-          retryState ?? RetryState.RETRY_STATE_UNSPECIFIED
+          decodeRetryState(retryState)
         );
       } else if (ev.workflowExecutionCanceledEventAttributes) {
         const failure = new CancelledFailure(
@@ -670,11 +676,7 @@ export class WorkflowClient extends BaseClient {
           )
         );
         failure.stack = '';
-        throw new WorkflowFailedError(
-          'Workflow execution cancelled',
-          failure,
-          RetryState.RETRY_STATE_NON_RETRYABLE_FAILURE
-        );
+        throw new WorkflowFailedError('Workflow execution cancelled', failure, RetryState.NON_RETRYABLE_FAILURE);
       } else if (ev.workflowExecutionTerminatedEventAttributes) {
         const failure = new TerminatedFailure(
           ev.workflowExecutionTerminatedEventAttributes.reason || 'Workflow execution terminated'
@@ -683,7 +685,7 @@ export class WorkflowClient extends BaseClient {
         throw new WorkflowFailedError(
           ev.workflowExecutionTerminatedEventAttributes.reason || 'Workflow execution terminated',
           failure,
-          RetryState.RETRY_STATE_NON_RETRYABLE_FAILURE
+          RetryState.NON_RETRYABLE_FAILURE
         );
       } else if (ev.workflowExecutionTimedOutEventAttributes) {
         if (followRuns && ev.workflowExecutionTimedOutEventAttributes.newExecutionRunId) {
@@ -691,16 +693,12 @@ export class WorkflowClient extends BaseClient {
           req.nextPageToken = undefined;
           continue;
         }
-        const failure = new TimeoutFailure(
-          'Workflow execution timed out',
-          undefined,
-          TimeoutType.TIMEOUT_TYPE_START_TO_CLOSE
-        );
+        const failure = new TimeoutFailure('Workflow execution timed out', undefined, TimeoutType.START_TO_CLOSE);
         failure.stack = '';
         throw new WorkflowFailedError(
           'Workflow execution timed out',
           failure,
-          ev.workflowExecutionTimedOutEventAttributes.retryState || 0
+          decodeRetryState(ev.workflowExecutionTimedOutEventAttributes.retryState)
         );
       } else if (ev.workflowExecutionContinuedAsNewEventAttributes) {
         const { newExecutionRunId } = ev.workflowExecutionContinuedAsNewEventAttributes;
@@ -806,8 +804,15 @@ export class WorkflowClient extends BaseClient {
     waitForStage: WorkflowUpdateStage,
     input: WorkflowStartUpdateInput
   ): Promise<WorkflowStartUpdateOutput> {
-    waitForStage = waitForStage >= WorkflowUpdateStage.ACCEPTED ? waitForStage : WorkflowUpdateStage.ACCEPTED;
-    const waitForStageProto = workflowUpdateStage.toProtoEnum(waitForStage);
+    let waitForStageProto: temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage =
+      encodeWorkflowUpdateStage(waitForStage) ??
+      UpdateWorkflowExecutionLifecycleStage.UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED;
+
+    waitForStageProto =
+      waitForStageProto >= UpdateWorkflowExecutionLifecycleStage.UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED
+        ? waitForStageProto
+        : UpdateWorkflowExecutionLifecycleStage.UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED;
+
     const updateId = input.options?.updateId ?? uuid4();
     const req: temporal.api.workflowservice.v1.IUpdateWorkflowExecutionRequest = {
       namespace: this.options.namespace,
@@ -886,7 +891,7 @@ export class WorkflowClient extends BaseClient {
       updateRef: { workflowExecution, updateId },
       identity: this.options.identity,
       waitPolicy: {
-        lifecycleStage: workflowUpdateStage.toProtoEnum(WorkflowUpdateStage.COMPLETED),
+        lifecycleStage: encodeWorkflowUpdateStage(WorkflowUpdateStage.COMPLETED),
       },
     };
     for (;;) {
@@ -938,7 +943,8 @@ export class WorkflowClient extends BaseClient {
       identity,
       requestId: uuid4(),
       workflowId: options.workflowId,
-      workflowIdReusePolicy: options.workflowIdReusePolicy,
+      workflowIdReusePolicy: encodeWorkflowIdReusePolicy(options.workflowIdReusePolicy),
+      workflowIdConflictPolicy: encodeWorkflowIdConflictPolicy(options.workflowIdConflictPolicy),
       workflowType: { name: workflowType },
       input: { payloads: await encodeToPayloads(this.dataConverter, ...options.args) },
       signalName,
@@ -988,7 +994,8 @@ export class WorkflowClient extends BaseClient {
       identity,
       requestId: uuid4(),
       workflowId: opts.workflowId,
-      workflowIdReusePolicy: opts.workflowIdReusePolicy,
+      workflowIdReusePolicy: encodeWorkflowIdReusePolicy(opts.workflowIdReusePolicy),
+      workflowIdConflictPolicy: encodeWorkflowIdConflictPolicy(opts.workflowIdConflictPolicy),
       workflowType: { name: workflowType },
       input: { payloads: await encodeToPayloads(this.dataConverter, ...opts.args) },
       taskQueue: {
@@ -1178,7 +1185,7 @@ export class WorkflowClient extends BaseClient {
         def: UpdateDefinition<Ret, Args> | string,
         options: WorkflowUpdateOptions & {
           args?: Args;
-          waitForStage: WorkflowUpdateStage.ACCEPTED;
+          waitForStage: typeof WorkflowUpdateStage.ACCEPTED;
         }
       ): Promise<WorkflowUpdateHandle<Ret>> {
         return await _startUpdate(def, options.waitForStage, options);
@@ -1208,7 +1215,7 @@ export class WorkflowClient extends BaseClient {
         const fn = composeInterceptors(interceptors, 'query', next);
         return fn({
           workflowExecution: { workflowId, runId },
-          queryRejectCondition: this.client.options.queryRejectCondition,
+          queryRejectCondition: encodeQueryRejectCondition(this.client.options.queryRejectCondition),
           queryType: typeof def === 'string' ? def : def.name,
           args,
           headers: {},

package/src/workflow-options.ts

@@ -15,7 +15,8 @@ export interface WorkflowOptions extends CommonWorkflowOptions {
    *
    * Assign a meaningful business id.
    * This ID can be used to ensure starting Workflows is idempotent.
-   * Workflow IDs are unique, see also {@link WorkflowOptions.workflowIdReusePolicy}
+   * Workflow IDs are unique: see {@link WorkflowOptions.workflowIdReusePolicy}
+   * and {@link WorkflowOptions.workflowIdConflictPolicy}.
    */
   workflowId: string;
 

package/src/workflow-update-stage.ts

@@ -1,33 +1,41 @@
 import { temporal } from '@temporalio/proto';
-import { checkExtends } from '@temporalio/common/lib/type-helpers';
+import { makeProtoEnumConverters } from '@temporalio/common/lib/internal-workflow';
 
-export enum WorkflowUpdateStage {
-  /** This is not an allowed value. */
-  UNSPECIFIED = 0,
+export const WorkflowUpdateStage = {
   /** Admitted stage. This stage is reached when the server accepts the update request. It is not
    * allowed to wait for this stage when using startUpdate, since the update request has not yet
    * been durably persisted at this stage. */
-  ADMITTED = 1,
+  ADMITTED: 'ADMITTED',
+
   /** Accepted stage. This stage is reached when a workflow has received the update and either
    * accepted it (i.e. it has passed validation, or there was no validator configured on the update
    * handler) or rejected it. This is currently the only allowed value when using startUpdate. */
-  ACCEPTED = 2,
+  ACCEPTED: 'ACCEPTED',
+
   /** Completed stage. This stage is reached when a workflow has completed processing the
    * update with either a success or failure. */
-  COMPLETED = 3,
-}
+  COMPLETED: 'COMPLETED',
 
-checkExtends<
-  `UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_${keyof typeof WorkflowUpdateStage}`,
-  keyof typeof temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage
->();
-checkExtends<
-  keyof typeof temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage,
-  `UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_${keyof typeof WorkflowUpdateStage}`
->();
+  /**
+   * This is not an allowed value.
+   * @deprecated
+   */
+  UNSPECIFIED: undefined, // eslint-disable-line deprecation/deprecation
+} as const;
+export type WorkflowUpdateStage = (typeof WorkflowUpdateStage)[keyof typeof WorkflowUpdateStage];
 
-export function toProtoEnum(stage: WorkflowUpdateStage): temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage {
-  return temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage[
-    `UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_${WorkflowUpdateStage[stage] as keyof typeof WorkflowUpdateStage}`
-  ];
-}
+export const [encodeWorkflowUpdateStage] = makeProtoEnumConverters<
+  temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage,
+  typeof temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage,
+  keyof typeof temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage,
+  typeof WorkflowUpdateStage,
+  'UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_'
+>(
+  {
+    [WorkflowUpdateStage.ADMITTED]: 1,
+    [WorkflowUpdateStage.ACCEPTED]: 2,
+    [WorkflowUpdateStage.COMPLETED]: 3,
+    UNSPECIFIED: 0,
+  } as const,
+  'UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_'
+);