@temporalio/proto/src/payload-visitor.generated.ts

Temporal.io SDK compiled protobuf definitions

// Code generated by packages/proto/scripts/gen-payload-visitor.ts. DO NOT EDIT.

import type { coresdk, temporal } from '../protos/root';

type Payload = temporal.api.common.v1.IPayload;

export interface WalkEnv<Ctx> {
  transformPayload(payload: Payload, context: Ctx): Promise<Payload>;
  transformPayloads(payloads: Payload[], context: Ctx): Promise<Payload[]>;
  deriveContext?(message: object, typeName: string, context: Ctx): Ctx;
  skipHeaders: boolean;
  skipSearchAttributes: boolean;
}

export function walkActivityExecutionResult<Ctx>(
  root: coresdk.activity_result.IActivityExecutionResult,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_activity_result_ActivityExecutionResult(root, env, context, pending);
  return pending;
}

export function walkActivityResolution<Ctx>(
  root: coresdk.activity_result.IActivityResolution,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_activity_result_ActivityResolution(root, env, context, pending);
  return pending;
}

export function walkCoresdkActivityResultCancellation<Ctx>(
  root: coresdk.activity_result.ICancellation,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_activity_result_Cancellation(root, env, context, pending);
  return pending;
}

export function walkCoresdkActivityResultFailure<Ctx>(
  root: coresdk.activity_result.IFailure,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_activity_result_Failure(root, env, context, pending);
  return pending;
}

export function walkCoresdkActivityResultSuccess<Ctx>(
  root: coresdk.activity_result.ISuccess,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_activity_result_Success(root, env, context, pending);
  return pending;
}

export function walkActivityTask<Ctx>(
  root: coresdk.activity_task.IActivityTask,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_activity_task_ActivityTask(root, env, context, pending);
  return pending;
}

export function walkStart<Ctx>(
  root: coresdk.activity_task.IStart,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_activity_task_Start(root, env, context, pending);
  return pending;
}

export function walkActivityHeartbeat<Ctx>(
  root: coresdk.IActivityHeartbeat,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_ActivityHeartbeat(root, env, context, pending);
  return pending;
}

export function walkActivityTaskCompletion<Ctx>(
  root: coresdk.IActivityTaskCompletion,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_ActivityTaskCompletion(root, env, context, pending);
  return pending;
}

export function walkCoresdkChildWorkflowCancellation<Ctx>(
  root: coresdk.child_workflow.ICancellation,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_child_workflow_Cancellation(root, env, context, pending);
  return pending;
}

export function walkChildWorkflowResult<Ctx>(
  root: coresdk.child_workflow.IChildWorkflowResult,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_child_workflow_ChildWorkflowResult(root, env, context, pending);
  return pending;
}

export function walkCoresdkChildWorkflowFailure<Ctx>(
  root: coresdk.child_workflow.IFailure,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_child_workflow_Failure(root, env, context, pending);
  return pending;
}

export function walkCoresdkChildWorkflowSuccess<Ctx>(
  root: coresdk.child_workflow.ISuccess,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_child_workflow_Success(root, env, context, pending);
  return pending;
}

export function walkNexusOperationResult<Ctx>(
  root: coresdk.nexus.INexusOperationResult,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_nexus_NexusOperationResult(root, env, context, pending);
  return pending;
}

export function walkNexusTask<Ctx>(
  root: coresdk.nexus.INexusTask,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_nexus_NexusTask(root, env, context, pending);
  return pending;
}

export function walkNexusTaskCompletion<Ctx>(
  root: coresdk.nexus.INexusTaskCompletion,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_nexus_NexusTaskCompletion(root, env, context, pending);
  return pending;
}

export function walkDoUpdate<Ctx>(
  root: coresdk.workflow_activation.IDoUpdate,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_DoUpdate(root, env, context, pending);
  return pending;
}

export function walkInitializeWorkflow<Ctx>(
  root: coresdk.workflow_activation.IInitializeWorkflow,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_InitializeWorkflow(root, env, context, pending);
  return pending;
}

export function walkQueryWorkflow<Ctx>(
  root: coresdk.workflow_activation.IQueryWorkflow,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_QueryWorkflow(root, env, context, pending);
  return pending;
}

export function walkResolveActivity<Ctx>(
  root: coresdk.workflow_activation.IResolveActivity,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_ResolveActivity(root, env, context, pending);
  return pending;
}

export function walkResolveChildWorkflowExecution<Ctx>(
  root: coresdk.workflow_activation.IResolveChildWorkflowExecution,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_ResolveChildWorkflowExecution(root, env, context, pending);
  return pending;
}

export function walkResolveChildWorkflowExecutionStart<Ctx>(
  root: coresdk.workflow_activation.IResolveChildWorkflowExecutionStart,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_ResolveChildWorkflowExecutionStart(root, env, context, pending);
  return pending;
}

export function walkResolveChildWorkflowExecutionStartCancelled<Ctx>(
  root: coresdk.workflow_activation.IResolveChildWorkflowExecutionStartCancelled,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_ResolveChildWorkflowExecutionStartCancelled(root, env, context, pending);
  return pending;
}

export function walkResolveNexusOperation<Ctx>(
  root: coresdk.workflow_activation.IResolveNexusOperation,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_ResolveNexusOperation(root, env, context, pending);
  return pending;
}

export function walkResolveNexusOperationStart<Ctx>(
  root: coresdk.workflow_activation.IResolveNexusOperationStart,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_ResolveNexusOperationStart(root, env, context, pending);
  return pending;
}

export function walkResolveRequestCancelExternalWorkflow<Ctx>(
  root: coresdk.workflow_activation.IResolveRequestCancelExternalWorkflow,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_ResolveRequestCancelExternalWorkflow(root, env, context, pending);
  return pending;
}

export function walkResolveSignalExternalWorkflow<Ctx>(
  root: coresdk.workflow_activation.IResolveSignalExternalWorkflow,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_ResolveSignalExternalWorkflow(root, env, context, pending);
  return pending;
}

export function walkSignalWorkflow<Ctx>(
  root: coresdk.workflow_activation.ISignalWorkflow,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_SignalWorkflow(root, env, context, pending);
  return pending;
}

export function walkWorkflowActivation<Ctx>(
  root: coresdk.workflow_activation.IWorkflowActivation,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_WorkflowActivation(root, env, context, pending);
  return pending;
}

export function walkWorkflowActivationJob<Ctx>(
  root: coresdk.workflow_activation.IWorkflowActivationJob,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_activation_WorkflowActivationJob(root, env, context, pending);
  return pending;
}

export function walkCompleteWorkflowExecution<Ctx>(
  root: coresdk.workflow_commands.ICompleteWorkflowExecution,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_CompleteWorkflowExecution(root, env, context, pending);
  return pending;
}

export function walkContinueAsNewWorkflowExecution<Ctx>(
  root: coresdk.workflow_commands.IContinueAsNewWorkflowExecution,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_ContinueAsNewWorkflowExecution(root, env, context, pending);
  return pending;
}

export function walkFailWorkflowExecution<Ctx>(
  root: coresdk.workflow_commands.IFailWorkflowExecution,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_FailWorkflowExecution(root, env, context, pending);
  return pending;
}

export function walkModifyWorkflowProperties<Ctx>(
  root: coresdk.workflow_commands.IModifyWorkflowProperties,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_ModifyWorkflowProperties(root, env, context, pending);
  return pending;
}

export function walkQueryResult<Ctx>(
  root: coresdk.workflow_commands.IQueryResult,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_QueryResult(root, env, context, pending);
  return pending;
}

export function walkQuerySuccess<Ctx>(
  root: coresdk.workflow_commands.IQuerySuccess,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_QuerySuccess(root, env, context, pending);
  return pending;
}

export function walkScheduleActivity<Ctx>(
  root: coresdk.workflow_commands.IScheduleActivity,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_ScheduleActivity(root, env, context, pending);
  return pending;
}

export function walkScheduleLocalActivity<Ctx>(
  root: coresdk.workflow_commands.IScheduleLocalActivity,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_ScheduleLocalActivity(root, env, context, pending);
  return pending;
}

export function walkScheduleNexusOperation<Ctx>(
  root: coresdk.workflow_commands.IScheduleNexusOperation,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_ScheduleNexusOperation(root, env, context, pending);
  return pending;
}

export function walkSignalExternalWorkflowExecution<Ctx>(
  root: coresdk.workflow_commands.ISignalExternalWorkflowExecution,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_SignalExternalWorkflowExecution(root, env, context, pending);
  return pending;
}

export function walkStartChildWorkflowExecution<Ctx>(
  root: coresdk.workflow_commands.IStartChildWorkflowExecution,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_StartChildWorkflowExecution(root, env, context, pending);
  return pending;
}

export function walkUpdateResponse<Ctx>(
  root: coresdk.workflow_commands.IUpdateResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_UpdateResponse(root, env, context, pending);
  return pending;
}

export function walkUpsertWorkflowSearchAttributes<Ctx>(
  root: coresdk.workflow_commands.IUpsertWorkflowSearchAttributes,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_UpsertWorkflowSearchAttributes(root, env, context, pending);
  return pending;
}

export function walkWorkflowCommand<Ctx>(
  root: coresdk.workflow_commands.IWorkflowCommand,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_commands_WorkflowCommand(root, env, context, pending);
  return pending;
}

export function walkCoresdkWorkflowCompletionFailure<Ctx>(
  root: coresdk.workflow_completion.IFailure,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_completion_Failure(root, env, context, pending);
  return pending;
}

export function walkCoresdkWorkflowCompletionSuccess<Ctx>(
  root: coresdk.workflow_completion.ISuccess,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_completion_Success(root, env, context, pending);
  return pending;
}

export function walkWorkflowActivationCompletion<Ctx>(
  root: coresdk.workflow_completion.IWorkflowActivationCompletion,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_coresdk_workflow_completion_WorkflowActivationCompletion(root, env, context, pending);
  return pending;
}

export function walkCountActivityExecutionsResponse<Ctx>(
  root: temporal.api.workflowservice.v1.ICountActivityExecutionsResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_CountActivityExecutionsResponse(root, env, context, pending);
  return pending;
}

export function walkTemporalApiWorkflowserviceV1CountActivityExecutionsResponseAggregationGroup<Ctx>(
  root: temporal.api.workflowservice.v1.CountActivityExecutionsResponse.IAggregationGroup,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_CountActivityExecutionsResponse_AggregationGroup(root, env, context, pending);
  return pending;
}

export function walkCountNexusOperationExecutionsResponse<Ctx>(
  root: temporal.api.workflowservice.v1.ICountNexusOperationExecutionsResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_CountNexusOperationExecutionsResponse(root, env, context, pending);
  return pending;
}

export function walkTemporalApiWorkflowserviceV1CountNexusOperationExecutionsResponseAggregationGroup<Ctx>(
  root: temporal.api.workflowservice.v1.CountNexusOperationExecutionsResponse.IAggregationGroup,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_CountNexusOperationExecutionsResponse_AggregationGroup(
    root,
    env,
    context,
    pending
  );
  return pending;
}

export function walkCountSchedulesResponse<Ctx>(
  root: temporal.api.workflowservice.v1.ICountSchedulesResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_CountSchedulesResponse(root, env, context, pending);
  return pending;
}

export function walkTemporalApiWorkflowserviceV1CountSchedulesResponseAggregationGroup<Ctx>(
  root: temporal.api.workflowservice.v1.CountSchedulesResponse.IAggregationGroup,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_CountSchedulesResponse_AggregationGroup(root, env, context, pending);
  return pending;
}

export function walkCountWorkflowExecutionsResponse<Ctx>(
  root: temporal.api.workflowservice.v1.ICountWorkflowExecutionsResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_CountWorkflowExecutionsResponse(root, env, context, pending);
  return pending;
}

export function walkTemporalApiWorkflowserviceV1CountWorkflowExecutionsResponseAggregationGroup<Ctx>(
  root: temporal.api.workflowservice.v1.CountWorkflowExecutionsResponse.IAggregationGroup,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_CountWorkflowExecutionsResponse_AggregationGroup(root, env, context, pending);
  return pending;
}

export function walkCreateScheduleRequest<Ctx>(
  root: temporal.api.workflowservice.v1.ICreateScheduleRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_CreateScheduleRequest(root, env, context, pending);
  return pending;
}

export function walkCreateWorkerDeploymentVersionRequest<Ctx>(
  root: temporal.api.workflowservice.v1.ICreateWorkerDeploymentVersionRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_CreateWorkerDeploymentVersionRequest(root, env, context, pending);
  return pending;
}

export function walkDescribeActivityExecutionResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IDescribeActivityExecutionResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_DescribeActivityExecutionResponse(root, env, context, pending);
  return pending;
}

export function walkDescribeDeploymentResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IDescribeDeploymentResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_DescribeDeploymentResponse(root, env, context, pending);
  return pending;
}

export function walkDescribeNexusOperationExecutionResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IDescribeNexusOperationExecutionResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_DescribeNexusOperationExecutionResponse(root, env, context, pending);
  return pending;
}

export function walkDescribeScheduleResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IDescribeScheduleResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_DescribeScheduleResponse(root, env, context, pending);
  return pending;
}

export function walkDescribeWorkerDeploymentVersionResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IDescribeWorkerDeploymentVersionResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_DescribeWorkerDeploymentVersionResponse(root, env, context, pending);
  return pending;
}

export function walkDescribeWorkflowExecutionResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IDescribeWorkflowExecutionResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_DescribeWorkflowExecutionResponse(root, env, context, pending);
  return pending;
}

export function walkExecuteMultiOperationRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IExecuteMultiOperationRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ExecuteMultiOperationRequest(root, env, context, pending);
  return pending;
}

export function walkOperation<Ctx>(
  root: temporal.api.workflowservice.v1.ExecuteMultiOperationRequest.IOperation,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ExecuteMultiOperationRequest_Operation(root, env, context, pending);
  return pending;
}

export function walkExecuteMultiOperationResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IExecuteMultiOperationResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ExecuteMultiOperationResponse(root, env, context, pending);
  return pending;
}

export function walkResponse<Ctx>(
  root: temporal.api.workflowservice.v1.ExecuteMultiOperationResponse.IResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ExecuteMultiOperationResponse_Response(root, env, context, pending);
  return pending;
}

export function walkGetCurrentDeploymentResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IGetCurrentDeploymentResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_GetCurrentDeploymentResponse(root, env, context, pending);
  return pending;
}

export function walkGetDeploymentReachabilityResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IGetDeploymentReachabilityResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_GetDeploymentReachabilityResponse(root, env, context, pending);
  return pending;
}

export function walkGetWorkflowExecutionHistoryResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IGetWorkflowExecutionHistoryResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_GetWorkflowExecutionHistoryResponse(root, env, context, pending);
  return pending;
}

export function walkGetWorkflowExecutionHistoryReverseResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IGetWorkflowExecutionHistoryReverseResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_GetWorkflowExecutionHistoryReverseResponse(root, env, context, pending);
  return pending;
}

export function walkListActivityExecutionsResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IListActivityExecutionsResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ListActivityExecutionsResponse(root, env, context, pending);
  return pending;
}

export function walkListArchivedWorkflowExecutionsResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IListArchivedWorkflowExecutionsResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ListArchivedWorkflowExecutionsResponse(root, env, context, pending);
  return pending;
}

export function walkListClosedWorkflowExecutionsResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IListClosedWorkflowExecutionsResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ListClosedWorkflowExecutionsResponse(root, env, context, pending);
  return pending;
}

export function walkListNexusOperationExecutionsResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IListNexusOperationExecutionsResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ListNexusOperationExecutionsResponse(root, env, context, pending);
  return pending;
}

export function walkListOpenWorkflowExecutionsResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IListOpenWorkflowExecutionsResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ListOpenWorkflowExecutionsResponse(root, env, context, pending);
  return pending;
}

export function walkListSchedulesResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IListSchedulesResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ListSchedulesResponse(root, env, context, pending);
  return pending;
}

export function walkListWorkflowExecutionsResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IListWorkflowExecutionsResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ListWorkflowExecutionsResponse(root, env, context, pending);
  return pending;
}

export function walkPollActivityExecutionResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IPollActivityExecutionResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_PollActivityExecutionResponse(root, env, context, pending);
  return pending;
}

export function walkPollActivityTaskQueueResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IPollActivityTaskQueueResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_PollActivityTaskQueueResponse(root, env, context, pending);
  return pending;
}

export function walkPollNexusOperationExecutionResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IPollNexusOperationExecutionResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_PollNexusOperationExecutionResponse(root, env, context, pending);
  return pending;
}

export function walkPollNexusTaskQueueResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IPollNexusTaskQueueResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_PollNexusTaskQueueResponse(root, env, context, pending);
  return pending;
}

export function walkPollWorkflowExecutionUpdateResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IPollWorkflowExecutionUpdateResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_PollWorkflowExecutionUpdateResponse(root, env, context, pending);
  return pending;
}

export function walkPollWorkflowTaskQueueResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IPollWorkflowTaskQueueResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_PollWorkflowTaskQueueResponse(root, env, context, pending);
  return pending;
}

export function walkQueryWorkflowRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IQueryWorkflowRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_QueryWorkflowRequest(root, env, context, pending);
  return pending;
}

export function walkQueryWorkflowResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IQueryWorkflowResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_QueryWorkflowResponse(root, env, context, pending);
  return pending;
}

export function walkRecordActivityTaskHeartbeatByIdRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRecordActivityTaskHeartbeatByIdRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RecordActivityTaskHeartbeatByIdRequest(root, env, context, pending);
  return pending;
}

export function walkRecordActivityTaskHeartbeatRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRecordActivityTaskHeartbeatRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RecordActivityTaskHeartbeatRequest(root, env, context, pending);
  return pending;
}

export function walkResetWorkflowExecutionRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IResetWorkflowExecutionRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ResetWorkflowExecutionRequest(root, env, context, pending);
  return pending;
}

export function walkRespondActivityTaskCanceledByIdRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondActivityTaskCanceledByIdRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondActivityTaskCanceledByIdRequest(root, env, context, pending);
  return pending;
}

export function walkRespondActivityTaskCanceledRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondActivityTaskCanceledRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondActivityTaskCanceledRequest(root, env, context, pending);
  return pending;
}

export function walkRespondActivityTaskCompletedByIdRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondActivityTaskCompletedByIdRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondActivityTaskCompletedByIdRequest(root, env, context, pending);
  return pending;
}

export function walkRespondActivityTaskCompletedRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondActivityTaskCompletedRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondActivityTaskCompletedRequest(root, env, context, pending);
  return pending;
}

export function walkRespondActivityTaskFailedByIdRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondActivityTaskFailedByIdRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondActivityTaskFailedByIdRequest(root, env, context, pending);
  return pending;
}

export function walkRespondActivityTaskFailedByIdResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondActivityTaskFailedByIdResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondActivityTaskFailedByIdResponse(root, env, context, pending);
  return pending;
}

export function walkRespondActivityTaskFailedRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondActivityTaskFailedRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondActivityTaskFailedRequest(root, env, context, pending);
  return pending;
}

export function walkRespondActivityTaskFailedResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondActivityTaskFailedResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondActivityTaskFailedResponse(root, env, context, pending);
  return pending;
}

export function walkRespondNexusTaskCompletedRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondNexusTaskCompletedRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondNexusTaskCompletedRequest(root, env, context, pending);
  return pending;
}

export function walkRespondNexusTaskFailedRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondNexusTaskFailedRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondNexusTaskFailedRequest(root, env, context, pending);
  return pending;
}

export function walkRespondQueryTaskCompletedRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondQueryTaskCompletedRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondQueryTaskCompletedRequest(root, env, context, pending);
  return pending;
}

export function walkRespondWorkflowTaskCompletedRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondWorkflowTaskCompletedRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondWorkflowTaskCompletedRequest(root, env, context, pending);
  return pending;
}

export function walkRespondWorkflowTaskCompletedResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondWorkflowTaskCompletedResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondWorkflowTaskCompletedResponse(root, env, context, pending);
  return pending;
}

export function walkRespondWorkflowTaskFailedRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IRespondWorkflowTaskFailedRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_RespondWorkflowTaskFailedRequest(root, env, context, pending);
  return pending;
}

export function walkScanWorkflowExecutionsResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IScanWorkflowExecutionsResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ScanWorkflowExecutionsResponse(root, env, context, pending);
  return pending;
}

export function walkSetCurrentDeploymentRequest<Ctx>(
  root: temporal.api.workflowservice.v1.ISetCurrentDeploymentRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_SetCurrentDeploymentRequest(root, env, context, pending);
  return pending;
}

export function walkSetCurrentDeploymentResponse<Ctx>(
  root: temporal.api.workflowservice.v1.ISetCurrentDeploymentResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_SetCurrentDeploymentResponse(root, env, context, pending);
  return pending;
}

export function walkSignalWithStartWorkflowExecutionRequest<Ctx>(
  root: temporal.api.workflowservice.v1.ISignalWithStartWorkflowExecutionRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_SignalWithStartWorkflowExecutionRequest(root, env, context, pending);
  return pending;
}

export function walkSignalWorkflowExecutionRequest<Ctx>(
  root: temporal.api.workflowservice.v1.ISignalWorkflowExecutionRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_SignalWorkflowExecutionRequest(root, env, context, pending);
  return pending;
}

export function walkStartActivityExecutionRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IStartActivityExecutionRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_StartActivityExecutionRequest(root, env, context, pending);
  return pending;
}

export function walkStartBatchOperationRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IStartBatchOperationRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_StartBatchOperationRequest(root, env, context, pending);
  return pending;
}

export function walkStartNexusOperationExecutionRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IStartNexusOperationExecutionRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_StartNexusOperationExecutionRequest(root, env, context, pending);
  return pending;
}

export function walkStartWorkflowExecutionRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IStartWorkflowExecutionRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_StartWorkflowExecutionRequest(root, env, context, pending);
  return pending;
}

export function walkStartWorkflowExecutionResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IStartWorkflowExecutionResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_StartWorkflowExecutionResponse(root, env, context, pending);
  return pending;
}

export function walkTerminateWorkflowExecutionRequest<Ctx>(
  root: temporal.api.workflowservice.v1.ITerminateWorkflowExecutionRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_TerminateWorkflowExecutionRequest(root, env, context, pending);
  return pending;
}

export function walkUpdateScheduleRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IUpdateScheduleRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_UpdateScheduleRequest(root, env, context, pending);
  return pending;
}

export function walkUpdateWorkerDeploymentVersionComputeConfigRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IUpdateWorkerDeploymentVersionComputeConfigRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_UpdateWorkerDeploymentVersionComputeConfigRequest(root, env, context, pending);
  return pending;
}

export function walkUpdateWorkerDeploymentVersionMetadataRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IUpdateWorkerDeploymentVersionMetadataRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_UpdateWorkerDeploymentVersionMetadataRequest(root, env, context, pending);
  return pending;
}

export function walkUpdateWorkerDeploymentVersionMetadataResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IUpdateWorkerDeploymentVersionMetadataResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_UpdateWorkerDeploymentVersionMetadataResponse(root, env, context, pending);
  return pending;
}

export function walkUpdateWorkflowExecutionRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IUpdateWorkflowExecutionRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_UpdateWorkflowExecutionRequest(root, env, context, pending);
  return pending;
}

export function walkUpdateWorkflowExecutionResponse<Ctx>(
  root: temporal.api.workflowservice.v1.IUpdateWorkflowExecutionResponse,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_UpdateWorkflowExecutionResponse(root, env, context, pending);
  return pending;
}

export function walkValidateWorkerDeploymentVersionComputeConfigRequest<Ctx>(
  root: temporal.api.workflowservice.v1.IValidateWorkerDeploymentVersionComputeConfigRequest,
  env: WalkEnv<Ctx>,
  context: Ctx
): Promise<unknown>[] {
  const pending: Promise<unknown>[] = [];
  walk_temporal_api_workflowservice_v1_ValidateWorkerDeploymentVersionComputeConfigRequest(root, env, context, pending);
  return pending;
}

function walk_coresdk_activity_result_ActivityExecutionResult<Ctx>(
  o: coresdk.activity_result.IActivityExecutionResult,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext
    ? env.deriveContext(o, 'coresdk.activity_result.ActivityExecutionResult', context)
    : context;
  {
    const c = o.completed;
    if (c != null) walk_coresdk_activity_result_Success(c, env, ctx, pending);
  }
  {
    const c = o.failed;
    if (c != null) walk_coresdk_activity_result_Failure(c, env, ctx, pending);
  }
  {
    const c = o.cancelled;
    if (c != null) walk_coresdk_activity_result_Cancellation(c, env, ctx, pending);
  }
}

function walk_coresdk_activity_result_ActivityResolution<Ctx>(
  o: coresdk.activity_result.IActivityResolution,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.activity_result.ActivityResolution', context) : context;
  {
    const c = o.completed;
    if (c != null) walk_coresdk_activity_result_Success(c, env, ctx, pending);
  }
  {
    const c = o.failed;
    if (c != null) walk_coresdk_activity_result_Failure(c, env, ctx, pending);
  }
  {
    const c = o.cancelled;
    if (c != null) walk_coresdk_activity_result_Cancellation(c, env, ctx, pending);
  }
}

function walk_coresdk_activity_result_Cancellation<Ctx>(
  o: coresdk.activity_result.ICancellation,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.activity_result.Cancellation', context) : context;
  {
    const c = o.failure;
    if (c != null) walk_temporal_api_failure_v1_Failure(c, env, ctx, pending);
  }
}

function walk_coresdk_activity_result_Failure<Ctx>(
  o: coresdk.activity_result.IFailure,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.activity_result.Failure', context) : context;
  {
    const c = o.failure;
    if (c != null) walk_temporal_api_failure_v1_Failure(c, env, ctx, pending);
  }
}

function walk_coresdk_activity_result_Success<Ctx>(
  o: coresdk.activity_result.ISuccess,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.activity_result.Success', context) : context;
  {
    const p = o.result;
    if (p != null)
      pending.push(
        env.transformPayload(p, ctx).then((r) => {
          o.result = r;
        })
      );
  }
}

function walk_coresdk_activity_task_ActivityTask<Ctx>(
  o: coresdk.activity_task.IActivityTask,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.activity_task.ActivityTask', context) : context;
  {
    const c = o.start;
    if (c != null) walk_coresdk_activity_task_Start(c, env, ctx, pending);
  }
}

function walk_coresdk_activity_task_Start<Ctx>(
  o: coresdk.activity_task.IStart,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.activity_task.Start', context) : context;
  {
    const m = o.headerFields;
    if (m)
      for (const [k, v] of Object.entries(m))
        pending.push(
          env.transformPayload(v, ctx).then((r) => {
            m[k] = r;
          })
        );
  }
  {
    const a = o.input;
    if (a && a.length)
      pending.push(
        env.transformPayloads(a, ctx).then((r) => {
          o.input = r;
        })
      );
  }
  {
    const a = o.heartbeatDetails;
    if (a && a.length)
      pending.push(
        env.transformPayloads(a, ctx).then((r) => {
          o.heartbeatDetails = r;
        })
      );
  }
}

function walk_coresdk_ActivityHeartbeat<Ctx>(
  o: coresdk.IActivityHeartbeat,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.ActivityHeartbeat', context) : context;
  {
    const a = o.details;
    if (a && a.length)
      pending.push(
        env.transformPayloads(a, ctx).then((r) => {
          o.details = r;
        })
      );
  }
}

function walk_coresdk_ActivityTaskCompletion<Ctx>(
  o: coresdk.IActivityTaskCompletion,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.ActivityTaskCompletion', context) : context;
  {
    const c = o.result;
    if (c != null) walk_coresdk_activity_result_ActivityExecutionResult(c, env, ctx, pending);
  }
}

function walk_coresdk_child_workflow_Cancellation<Ctx>(
  o: coresdk.child_workflow.ICancellation,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.child_workflow.Cancellation', context) : context;
  {
    const c = o.failure;
    if (c != null) walk_temporal_api_failure_v1_Failure(c, env, ctx, pending);
  }
}

function walk_coresdk_child_workflow_ChildWorkflowResult<Ctx>(
  o: coresdk.child_workflow.IChildWorkflowResult,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.child_workflow.ChildWorkflowResult', context) : context;
  {
    const c = o.completed;
    if (c != null) walk_coresdk_child_workflow_Success(c, env, ctx, pending);
  }
  {
    const c = o.failed;
    if (c != null) walk_coresdk_child_workflow_Failure(c, env, ctx, pending);
  }
  {
    const c = o.cancelled;
    if (c != null) walk_coresdk_child_workflow_Cancellation(c, env, ctx, pending);
  }
}

function walk_coresdk_child_workflow_Failure<Ctx>(
  o: coresdk.child_workflow.IFailure,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.child_workflow.Failure', context) : context;
  {
    const c = o.failure;
    if (c != null) walk_temporal_api_failure_v1_Failure(c, env, ctx, pending);
  }
}

function walk_coresdk_child_workflow_Success<Ctx>(
  o: coresdk.child_workflow.ISuccess,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.child_workflow.Success', context) : context;
  {
    const p = o.result;
    if (p != null)
      pending.push(
        env.transformPayload(p, ctx).then((r) => {
          o.result = r;
        })
      );
  }
}

function walk_coresdk_nexus_NexusOperationResult<Ctx>(
  o: coresdk.nexus.INexusOperationResult,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.nexus.NexusOperationResult', context) : context;
  {
    const p = o.completed;
    if (p != null)
      pending.push(
        env.transformPayload(p, ctx).then((r) => {
          o.completed = r;
        })
      );
  }
  {
    const c = o.failed;
    if (c != null) walk_temporal_api_failure_v1_Failure(c, env, ctx, pending);
  }
  {
    const c = o.cancelled;
    if (c != null) walk_temporal_api_failure_v1_Failure(c, env, ctx, pending);
  }
  {
    const c = o.timedOut;
    if (c != null) walk_temporal_api_failure_v1_Failure(c, env, ctx, pending);
  }
}

function walk_coresdk_nexus_NexusTask<Ctx>(
  o: coresdk.nexus.INexusTask,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.nexus.NexusTask', context) : context;
  {
    const c = o.task;
    if (c != null) walk_temporal_api_workflowservice_v1_PollNexusTaskQueueResponse(c, env, ctx, pending);
  }
}

function walk_coresdk_nexus_NexusTaskCompletion<Ctx>(
  o: coresdk.nexus.INexusTaskCompletion,
  env: WalkEnv<Ctx>,
  context: Ctx,
  pending: Promise<unknown>[]
): void {
  const ctx = env.deriveContext ? env.deriveContext(o, 'coresdk.nexus.NexusTaskCompletion', context) : context;
  {
    const c = o.completed;
    if (c !=