@temporalio/client 1.11.3 → 1.11.5

package/src/errors.ts

@@ -1,4 +1,4 @@
-import { ServiceError as GrpcServiceError } from '@grpc/grpc-js';
+import { ServiceError as GrpcServiceError, status } from '@grpc/grpc-js';
 import { RetryState, TemporalFailure } from '@temporalio/common';
 import { isError, isRecord, SymbolBasedInstanceOfError } from '@temporalio/common/lib/type-helpers';
 
@@ -79,6 +79,9 @@ export class WorkflowContinuedAsNewError extends Error {
   }
 }
 
+/**
+ * Returns true if the provided error is a {@link GrpcServiceError}.
+ */
 export function isGrpcServiceError(err: unknown): err is GrpcServiceError {
   return (
     isError(err) &&
@@ -87,6 +90,36 @@ export function isGrpcServiceError(err: unknown): err is GrpcServiceError {
   );
 }
 
+/**
+ * Returns true if the provided error or its cause is a {@link GrpcServiceError} with code DEADLINE_EXCEEDED.
+ *
+ * @see {@link Connection.withDeadline}
+ */
+export function isGrpcDeadlineError(err: unknown): err is Error {
+  while (isError(err)) {
+    if (isGrpcServiceError(err) && (err as GrpcServiceError).code === status.DEADLINE_EXCEEDED) {
+      return true;
+    }
+    err = (err as any).cause;
+  }
+  return false;
+}
+
+/**
+ * Returns true if the provided error or its cause is a {@link GrpcServiceError} with code CANCELLED.
+ *
+ * @see {@link Connection.withAbortSignal}
+ */
+export function isGrpcCancelledError(err: unknown): err is Error {
+  while (isError(err)) {
+    if (isGrpcServiceError(err) && (err as GrpcServiceError).code === status.CANCELLED) {
+      return true;
+    }
+    err = (err as any).cause;
+  }
+  return false;
+}
+
 /**
  * @deprecated Use `isGrpcServiceError` instead
  */

package/src/schedule-client.ts

@@ -29,17 +29,17 @@ import {
   ScheduleUpdateOptions,
   ScheduleOptionsAction,
   ScheduleOptionsStartWorkflowAction,
+  encodeScheduleOverlapPolicy,
+  decodeScheduleOverlapPolicy,
 } from './schedule-types';
 import {
   compileScheduleOptions,
   compileUpdatedScheduleOptions,
-  decodeOverlapPolicy,
   decodeScheduleAction,
   decodeScheduleRecentActions,
   decodeScheduleRunningActions,
   decodeScheduleSpec,
   decodeSearchAttributes,
-  encodeOverlapPolicy,
   encodeScheduleAction,
   encodeSchedulePolicies,
   encodeScheduleSpec,
@@ -251,7 +251,7 @@ export class ScheduleClient extends BaseClient {
           ? opts.state.backfill.map((x) => ({
               startTime: optionalDateToTs(x.start),
               endTime: optionalDateToTs(x.end),
-              overlapPolicy: x.overlap ? encodeOverlapPolicy(x.overlap) : undefined,
+              overlapPolicy: x.overlap ? encodeScheduleOverlapPolicy(x.overlap) : undefined,
             }))
           : undefined,
       },
@@ -427,7 +427,8 @@ export class ScheduleClient extends BaseClient {
           memo: await decodeMapFromPayloads(this.client.dataConverter, raw.memo?.fields),
           searchAttributes: decodeSearchAttributes(raw.searchAttributes),
           policies: {
-            overlap: decodeOverlapPolicy(raw.schedule.policies?.overlapPolicy),
+            // 'overlap' should never be missing on describe, as the server will replace UNSPECIFIED by an actual value
+            overlap: decodeScheduleOverlapPolicy(raw.schedule.policies?.overlapPolicy) ?? ScheduleOverlapPolicy.SKIP,
             catchupWindow: optionalTsToMs(raw.schedule.policies?.catchupWindow) ?? 60_000,
             pauseOnFailure: raw.schedule.policies?.pauseOnFailure === true,
           },
@@ -485,7 +486,7 @@ export class ScheduleClient extends BaseClient {
         await this.client._patchSchedule(this.scheduleId, {
           triggerImmediately: {
             overlapPolicy: overlap
-              ? encodeOverlapPolicy(overlap)
+              ? encodeScheduleOverlapPolicy(overlap)
               : temporal.api.enums.v1.ScheduleOverlapPolicy.SCHEDULE_OVERLAP_POLICY_ALLOW_ALL,
           },
         });
@@ -497,7 +498,7 @@ export class ScheduleClient extends BaseClient {
           backfillRequest: backfills.map((x) => ({
             startTime: optionalDateToTs(x.start),
             endTime: optionalDateToTs(x.end),
-            overlapPolicy: x.overlap ? encodeOverlapPolicy(x.overlap) : undefined,
+            overlapPolicy: x.overlap ? encodeScheduleOverlapPolicy(x.overlap) : undefined,
           })),
         });
       },

package/src/schedule-helpers.ts

@@ -32,7 +32,6 @@ import {
   CompiledScheduleUpdateOptions,
   Range,
   ScheduleOptions,
-  ScheduleOverlapPolicy,
   ScheduleUpdateOptions,
   DayOfWeek,
   DAYS_OF_WEEK,
@@ -47,6 +46,7 @@ import {
   ScheduleExecutionActionResult,
   ScheduleExecutionResult,
   ScheduleExecutionStartWorkflowActionResult,
+  encodeScheduleOverlapPolicy,
 } from './schedule-types';
 
 const [encodeSecond, decodeSecond] = makeCalendarSpecFieldCoders(
@@ -192,21 +192,6 @@ export function decodeOptionalStructuredCalendarSpecs(
   );
 }
 
-export function encodeOverlapPolicy(input: ScheduleOverlapPolicy): temporal.api.enums.v1.ScheduleOverlapPolicy {
-  return temporal.api.enums.v1.ScheduleOverlapPolicy[
-    `SCHEDULE_OVERLAP_POLICY_${ScheduleOverlapPolicy[input] as keyof typeof ScheduleOverlapPolicy}`
-  ];
-}
-
-export function decodeOverlapPolicy(input?: temporal.api.enums.v1.ScheduleOverlapPolicy | null): ScheduleOverlapPolicy {
-  if (!input) return ScheduleOverlapPolicy.UNSPECIFIED;
-  const encodedPolicyName = temporal.api.enums.v1.ScheduleOverlapPolicy[input];
-  const decodedPolicyName = encodedPolicyName.substring(
-    'SCHEDULE_OVERLAP_POLICY_'.length
-  ) as keyof typeof ScheduleOverlapPolicy;
-  return ScheduleOverlapPolicy[decodedPolicyName];
-}
-
 export function compileScheduleOptions(options: ScheduleOptions): CompiledScheduleOptions {
   const workflowTypeOrFunc = options.action.workflowType;
   const workflowType = extractWorkflowType(workflowTypeOrFunc);
@@ -290,7 +275,7 @@ export function encodeSchedulePolicies(
 ): temporal.api.schedule.v1.ISchedulePolicies {
   return {
     catchupWindow: msOptionalToTs(policies?.catchupWindow),
-    overlapPolicy: policies?.overlap ? encodeOverlapPolicy(policies.overlap) : undefined,
+    overlapPolicy: policies?.overlap ? encodeScheduleOverlapPolicy(policies.overlap) : undefined,
     pauseOnFailure: policies?.pauseOnFailure,
   };
 }

package/src/schedule-types.ts

@@ -1,5 +1,6 @@
 import { checkExtends, Replace } from '@temporalio/common/lib/type-helpers';
 import { Duration, SearchAttributes, Workflow } from '@temporalio/common';
+import { makeProtoEnumConverters } from '@temporalio/common/lib/internal-workflow';
 import type { temporal } from '@temporalio/proto';
 import { WorkflowStartOptions } from './workflow-options';
 
@@ -795,57 +796,69 @@ export type CompiledScheduleAction = Replace<
 /**
  * Policy for overlapping Actions.
  */
-export enum ScheduleOverlapPolicy {
-  /**
-   * Use server default (currently SKIP).
-   *
-   * FIXME: remove this field if this issue is implemented: https://github.com/temporalio/temporal/issues/3240
-   */
-  UNSPECIFIED = 0,
-
+export const ScheduleOverlapPolicy = {
   /**
    * Don't start a new Action.
+   * @default
    */
-  SKIP,
+  SKIP: 'SKIP',
 
   /**
    * Start another Action as soon as the current Action completes, but only buffer one Action in this way. If another
    * Action is supposed to start, but one Action is running and one is already buffered, then only the buffered one will
    * be started after the running Action finishes.
    */
-  BUFFER_ONE,
+  BUFFER_ONE: 'BUFFER_ONE',
 
   /**
    * Allows an unlimited number of Actions to buffer. They are started sequentially.
    */
-  BUFFER_ALL,
+  BUFFER_ALL: 'BUFFER_ALL',
 
   /**
    * Cancels the running Action, and then starts the new Action once the cancelled one completes.
    */
-  CANCEL_OTHER,
+  CANCEL_OTHER: 'CANCEL_OTHER',
 
   /**
    * Terminate the running Action and start the new Action immediately.
    */
-  TERMINATE_OTHER,
+  TERMINATE_OTHER: 'TERMINATE_OTHER',
 
   /**
    * Allow any number of Actions to start immediately.
    *
    * This is the only policy under which multiple Actions can run concurrently.
    */
-  ALLOW_ALL,
-}
+  ALLOW_ALL: 'ALLOW_ALL',
 
-checkExtends<
+  /**
+   * Use server default (currently SKIP).
+   *
+   * @deprecated Either leave property `undefined`, or use {@link SKIP} instead.
+   */
+  UNSPECIFIED: undefined, // eslint-disable-line deprecation/deprecation
+} as const;
+export type ScheduleOverlapPolicy = (typeof ScheduleOverlapPolicy)[keyof typeof ScheduleOverlapPolicy];
+
+export const [encodeScheduleOverlapPolicy, decodeScheduleOverlapPolicy] = makeProtoEnumConverters<
+  temporal.api.enums.v1.ScheduleOverlapPolicy,
+  typeof temporal.api.enums.v1.ScheduleOverlapPolicy,
   keyof typeof temporal.api.enums.v1.ScheduleOverlapPolicy,
-  `SCHEDULE_OVERLAP_POLICY_${keyof typeof ScheduleOverlapPolicy}`
->();
-checkExtends<
-  `SCHEDULE_OVERLAP_POLICY_${keyof typeof ScheduleOverlapPolicy}`,
-  keyof typeof temporal.api.enums.v1.ScheduleOverlapPolicy
->();
+  typeof ScheduleOverlapPolicy,
+  'SCHEDULE_OVERLAP_POLICY_'
+>(
+  {
+    [ScheduleOverlapPolicy.SKIP]: 1,
+    [ScheduleOverlapPolicy.BUFFER_ONE]: 2,
+    [ScheduleOverlapPolicy.BUFFER_ALL]: 3,
+    [ScheduleOverlapPolicy.CANCEL_OTHER]: 4,
+    [ScheduleOverlapPolicy.TERMINATE_OTHER]: 5,
+    [ScheduleOverlapPolicy.ALLOW_ALL]: 6,
+    UNSPECIFIED: 0,
+  } as const,
+  'SCHEDULE_OVERLAP_POLICY_'
+);
 
 export interface Backfill {
   /**

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';
 
@@ -102,7 +103,7 @@ export interface ConnectionLike {
    *
    * 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}.
+   * 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.
@@ -127,7 +128,7 @@ export interface ConnectionLike {
   /**
    * 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}.
+   * with code {@link grpc.status.CANCELLED|CANCELLED}; see {@link isGrpcCancelledError}.
    *
    * @returns value returned from `fn`
    *
@@ -135,3 +136,38 @@ export interface ConnectionLike {
    */
   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',
   };
 }
 
@@ -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;