temporalio 1.5.0 → 1.6.0

data/rbi/temporalio/internal/worker/workflow_instance/context.rbi

@@ -0,0 +1,290 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::Context
+  extend T::Sig
+
+  sig { params(instance: Temporalio::Internal::Worker::WorkflowInstance).void }
+  def initialize(instance); end
+
+  sig { returns(T::Boolean) }
+  def all_handlers_finished?; end
+
+  sig { returns(Temporalio::Cancellation) }
+  def cancellation; end
+
+  sig { returns(T::Boolean) }
+  def continue_as_new_suggested; end
+
+  sig { params(endpoint: T.any(Symbol, String), service: T.any(Symbol, String)).returns(Temporalio::Workflow::NexusClient) }
+  def create_nexus_client(endpoint:, service:); end
+
+  sig { returns(T::Array[Integer]) }
+  def suggest_continue_as_new_reasons; end
+
+  sig { returns(T::Boolean) }
+  def target_worker_deployment_version_changed?; end
+
+  sig { returns(String) }
+  def current_details; end
+
+  sig { params(details: T.nilable(String)).void }
+  def current_details=(details); end
+
+  sig { returns(Integer) }
+  def current_history_length; end
+
+  sig { returns(Integer) }
+  def current_history_size; end
+
+  sig { returns(T.nilable(Temporalio::WorkerDeploymentVersion)) }
+  def current_deployment_version; end
+
+  sig { returns(T.nilable(Temporalio::Workflow::UpdateInfo)) }
+  def current_update_info; end
+
+  sig { params(patch_id: T.any(Symbol, String)).void }
+  def deprecate_patch(patch_id); end
+
+  sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+  def durable_scheduler_disabled(&block); end
+
+  sig do
+    params(
+      activity: T.any(T.class_of(Temporalio::Activity::Definition), Symbol, String),
+      args: T.nilable(Object),
+      task_queue: String,
+      summary: T.nilable(String),
+      schedule_to_close_timeout: T.nilable(T.any(Integer, Float)),
+      schedule_to_start_timeout: T.nilable(T.any(Integer, Float)),
+      start_to_close_timeout: T.nilable(T.any(Integer, Float)),
+      heartbeat_timeout: T.nilable(T.any(Integer, Float)),
+      retry_policy: T.nilable(Temporalio::RetryPolicy),
+      cancellation: Temporalio::Cancellation,
+      cancellation_type: Integer,
+      activity_id: T.nilable(String),
+      disable_eager_execution: T::Boolean,
+      priority: Temporalio::Priority,
+      arg_hints: T.nilable(T::Array[Object]),
+      result_hint: T.nilable(Object)
+    ).returns(T.nilable(Object))
+  end
+  def execute_activity(
+    activity,
+    *args,
+    task_queue:,
+    summary:,
+    schedule_to_close_timeout:,
+    schedule_to_start_timeout:,
+    start_to_close_timeout:,
+    heartbeat_timeout:,
+    retry_policy:,
+    cancellation:,
+    cancellation_type:,
+    activity_id:,
+    disable_eager_execution:,
+    priority:,
+    arg_hints:,
+    result_hint:
+  ); end
+
+  sig do
+    params(
+      activity: T.any(T.class_of(Temporalio::Activity::Definition), Symbol, String),
+      args: T.nilable(Object),
+      summary: T.nilable(String),
+      schedule_to_close_timeout: T.nilable(T.any(Integer, Float)),
+      schedule_to_start_timeout: T.nilable(T.any(Integer, Float)),
+      start_to_close_timeout: T.nilable(T.any(Integer, Float)),
+      retry_policy: T.nilable(Temporalio::RetryPolicy),
+      local_retry_threshold: T.nilable(T.any(Integer, Float)),
+      cancellation: Temporalio::Cancellation,
+      cancellation_type: Integer,
+      activity_id: T.nilable(String),
+      arg_hints: T.nilable(T::Array[Object]),
+      result_hint: T.nilable(Object)
+    ).returns(T.nilable(Object))
+  end
+  def execute_local_activity(
+    activity,
+    *args,
+    summary:,
+    schedule_to_close_timeout:,
+    schedule_to_start_timeout:,
+    start_to_close_timeout:,
+    retry_policy:,
+    local_retry_threshold:,
+    cancellation:,
+    cancellation_type:,
+    activity_id:,
+    arg_hints:,
+    result_hint:
+  ); end
+
+  sig do
+    params(workflow_id: String, run_id: T.nilable(String))
+      .returns(Temporalio::Internal::Worker::WorkflowInstance::ExternalWorkflowHandle)
+  end
+  def external_workflow_handle(workflow_id, run_id: T.unsafe(nil)); end
+
+  sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+  def illegal_call_tracing_disabled(&block); end
+
+  sig { returns(Temporalio::Workflow::Info) }
+  def info; end
+
+  sig { returns(Temporalio::Workflow::Definition) }
+  def instance; end
+
+  sig { params(error: Temporalio::Workflow::ContinueAsNewError).void }
+  def initialize_continue_as_new_error(error); end
+
+  sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+  def io_enabled(&block); end
+
+  sig { returns(Temporalio::Internal::Worker::WorkflowInstance::ReplaySafeLogger) }
+  def logger; end
+
+  sig { returns(Temporalio::Internal::Worker::WorkflowInstance::ExternallyImmutableHash) }
+  def memo; end
+
+  sig { returns(Temporalio::Metric::Meter) }
+  def metric_meter; end
+
+  sig { returns(Time) }
+  def now; end
+
+  sig { params(patch_id: T.any(Symbol, String)).returns(T::Boolean) }
+  def patched(patch_id); end
+
+  sig { returns(Temporalio::Converters::PayloadConverter) }
+  def payload_converter; end
+
+  sig { returns(Temporalio::Internal::Worker::WorkflowInstance::HandlerHash) }
+  def query_handlers; end
+
+  sig { returns(Random) }
+  def random; end
+
+  sig { returns(T::Boolean) }
+  def replaying?; end
+
+  sig { returns(T::Boolean) }
+  def replaying_history_events?; end
+
+  sig { returns(Temporalio::SearchAttributes) }
+  def search_attributes; end
+
+  sig { returns(Temporalio::Internal::Worker::WorkflowInstance::HandlerHash) }
+  def signal_handlers; end
+
+  sig { params(duration: T.nilable(T.any(Integer, Float)), summary: T.nilable(String), cancellation: Temporalio::Cancellation).void }
+  def sleep(duration, summary:, cancellation:); end
+
+  sig do
+    params(
+      workflow: T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info, Symbol, String),
+      args: T.nilable(Object),
+      id: String,
+      task_queue: String,
+      static_summary: T.nilable(String),
+      static_details: T.nilable(String),
+      cancellation: Temporalio::Cancellation,
+      cancellation_type: Integer,
+      parent_close_policy: Integer,
+      execution_timeout: T.nilable(T.any(Integer, Float)),
+      run_timeout: T.nilable(T.any(Integer, Float)),
+      task_timeout: T.nilable(T.any(Integer, Float)),
+      id_reuse_policy: Integer,
+      retry_policy: T.nilable(Temporalio::RetryPolicy),
+      cron_schedule: T.nilable(String),
+      memo: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]),
+      search_attributes: T.nilable(Temporalio::SearchAttributes),
+      priority: Temporalio::Priority,
+      arg_hints: T.nilable(T::Array[Object]),
+      result_hint: T.nilable(Object)
+    ).returns(Temporalio::Internal::Worker::WorkflowInstance::ChildWorkflowHandle)
+  end
+  def start_child_workflow(
+    workflow,
+    *args,
+    id:,
+    task_queue:,
+    static_summary:,
+    static_details:,
+    cancellation:,
+    cancellation_type:,
+    parent_close_policy:,
+    execution_timeout:,
+    run_timeout:,
+    task_timeout:,
+    id_reuse_policy:,
+    retry_policy:,
+    cron_schedule:,
+    memo:,
+    search_attributes:,
+    priority:,
+    arg_hints:,
+    result_hint:
+  ); end
+
+  sig { returns(T::Hash[Object, Object]) }
+  def storage; end
+
+  sig do
+    type_parameters(:T)
+      .params(
+        duration: T.nilable(T.any(Integer, Float)),
+        exception_class: T.class_of(Exception),
+        exception_args: T.nilable(Object),
+        summary: T.nilable(String),
+        block: T.proc.returns(T.type_parameter(:T))
+      )
+      .returns(T.type_parameter(:T))
+  end
+  def timeout(duration, exception_class, *exception_args, summary:, &block); end
+
+  sig { returns(Temporalio::Internal::Worker::WorkflowInstance::HandlerHash) }
+  def update_handlers; end
+
+  sig { params(hash: T::Hash[T.any(Symbol, String), T.nilable(Object)]).void }
+  def upsert_memo(hash); end
+
+  sig { params(updates: Temporalio::SearchAttributes::Update).void }
+  def upsert_search_attributes(*updates); end
+
+  sig do
+    type_parameters(:T)
+      .params(cancellation: T.nilable(Temporalio::Cancellation), block: T.proc.returns(T.type_parameter(:T)))
+      .returns(T.type_parameter(:T))
+  end
+  def wait_condition(cancellation:, &block); end
+
+  sig { params(id: String, run_id: T.nilable(String)).void }
+  def _cancel_external_workflow(id:, run_id:); end
+
+  sig { params(outbound: Temporalio::Worker::Interceptor::Workflow::Outbound).void }
+  def _outbound=(outbound); end
+
+  sig do
+    params(
+      id: String,
+      signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String),
+      args: T::Array[T.nilable(Object)],
+      cancellation: Temporalio::Cancellation,
+      arg_hints: T.nilable(T::Array[Object])
+    ).void
+  end
+  def _signal_child_workflow(id:, signal:, args:, cancellation:, arg_hints:); end
+
+  sig do
+    params(
+      id: String,
+      run_id: T.nilable(String),
+      signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String),
+      args: T::Array[T.nilable(Object)],
+      cancellation: Temporalio::Cancellation,
+      arg_hints: T.nilable(T::Array[Object])
+    ).void
+  end
+  def _signal_external_workflow(id:, run_id:, signal:, args:, cancellation:, arg_hints:); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/details.rbi

@@ -0,0 +1,87 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::Details
+  extend T::Sig
+
+  sig { returns(String) }
+  attr_reader :namespace
+
+  sig { returns(String) }
+  attr_reader :task_queue
+
+  sig { returns(Temporalio::Workflow::Definition::Info) }
+  attr_reader :definition
+
+  sig { returns(Object) }
+  attr_reader :initial_activation
+
+  sig { returns(Logger) }
+  attr_reader :logger
+
+  sig { returns(Temporalio::Metric::Meter) }
+  attr_reader :metric_meter
+
+  sig { returns(Temporalio::Converters::PayloadConverter) }
+  attr_reader :payload_converter
+
+  sig { returns(Temporalio::Converters::FailureConverter) }
+  attr_reader :failure_converter
+
+  sig { returns(T::Array[Temporalio::Worker::Interceptor::Workflow]) }
+  attr_reader :interceptors
+
+  sig { returns(T::Boolean) }
+  attr_reader :disable_eager_activity_execution
+
+  sig { returns(T::Hash[String, Object]) }
+  attr_reader :illegal_calls
+
+  sig { returns(T::Array[T.class_of(Exception)]) }
+  attr_reader :workflow_failure_exception_types
+
+  sig { returns(T::Boolean) }
+  attr_reader :unsafe_workflow_io_enabled
+
+  sig { returns(T.nilable(T.proc.params(input: Temporalio::Worker::PatchActivationInput).returns(T::Boolean))) }
+  attr_reader :patch_activation_callback
+
+  sig { returns(T.proc.params(arg0: String).void) }
+  attr_reader :assert_valid_local_activity
+
+  sig do
+    params(
+      namespace: String,
+      task_queue: String,
+      definition: Temporalio::Workflow::Definition::Info,
+      initial_activation: Object,
+      logger: Logger,
+      metric_meter: Temporalio::Metric::Meter,
+      payload_converter: Temporalio::Converters::PayloadConverter,
+      failure_converter: Temporalio::Converters::FailureConverter,
+      interceptors: T::Array[Temporalio::Worker::Interceptor::Workflow],
+      disable_eager_activity_execution: T::Boolean,
+      illegal_calls: T::Hash[String, Object],
+      workflow_failure_exception_types: T::Array[T.class_of(Exception)],
+      unsafe_workflow_io_enabled: T::Boolean,
+      patch_activation_callback: T.nilable(T.proc.params(input: Temporalio::Worker::PatchActivationInput).returns(T::Boolean)),
+      assert_valid_local_activity: T.proc.params(arg0: String).void
+    ).void
+  end
+  def initialize(
+    namespace:,
+    task_queue:,
+    definition:,
+    initial_activation:,
+    logger:,
+    metric_meter:,
+    payload_converter:,
+    failure_converter:,
+    interceptors:,
+    disable_eager_activity_execution:,
+    illegal_calls:,
+    workflow_failure_exception_types:,
+    unsafe_workflow_io_enabled:,
+    patch_activation_callback:,
+    assert_valid_local_activity:
+  ); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/external_workflow_handle.rbi

@@ -0,0 +1,14 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::ExternalWorkflowHandle < Temporalio::Workflow::ExternalWorkflowHandle
+  extend T::Sig
+
+  sig do
+    params(
+      id: String,
+      run_id: T.nilable(String),
+      instance: Object
+    ).void
+  end
+  def initialize(id:, run_id:, instance:); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/externally_immutable_hash.rbi

@@ -0,0 +1,17 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::ExternallyImmutableHash < Hash
+  extend T::Sig
+
+  sig { params(initial_hash: T::Hash[Object, Object]).void }
+  def initialize(initial_hash); end
+
+  sig { params(block: T.proc.params(arg0: T::Hash[Object, Object]).void).void }
+  def _update(&block); end
+
+  sig { returns(T::Hash[Object, Object]) }
+  def __getobj__; end
+
+  sig { params(obj: T::Hash[Object, Object]).void }
+  def __setobj__(obj); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/handler_execution.rbi

@@ -0,0 +1,17 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::HandlerExecution
+  extend T::Sig
+
+  sig { returns(String) }
+  attr_reader :name
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :update_id
+
+  sig { returns(Integer) }
+  attr_reader :unfinished_policy
+
+  sig { params(name: String, update_id: T.nilable(String), unfinished_policy: Integer).void }
+  def initialize(name:, update_id:, unfinished_policy:); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/handler_hash.rbi

@@ -0,0 +1,24 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::HandlerHash < Hash
+  extend T::Sig
+
+  sig do
+    params(
+      initial_frozen_hash: T::Hash[T.nilable(String), Object],
+      definition_class: T.any(
+        T.class_of(Temporalio::Workflow::Definition::Signal),
+        T.class_of(Temporalio::Workflow::Definition::Query),
+        T.class_of(Temporalio::Workflow::Definition::Update)
+      ),
+      on_new_definition: T.nilable(T.proc.params(arg0: Object).void)
+    ).void
+  end
+  def initialize(initial_frozen_hash, definition_class, &on_new_definition); end
+
+  sig { params(name: T.nilable(String), definition: Object).returns(Object) }
+  def []=(name, definition); end
+
+  sig { params(name: T.nilable(String), definition: Object).returns(Object) }
+  def store(name, definition); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/illegal_call_tracer.rbi

@@ -0,0 +1,17 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::IllegalCallTracer
+  extend T::Sig
+
+  sig { params(illegal_calls: T::Hash[String, Object]).returns(T::Hash[String, Object]) }
+  def self.frozen_validated_illegal_calls(illegal_calls); end
+
+  sig { params(illegal_calls: T::Hash[String, Object]).void }
+  def initialize(illegal_calls); end
+
+  sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+  def enable(&block); end
+
+  sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+  def disable_temporarily(&block); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/inbound_implementation.rbi

@@ -0,0 +1,21 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::InboundImplementation < Temporalio::Worker::Interceptor::Workflow::Inbound
+  extend T::Sig
+
+  sig { params(instance: Temporalio::Internal::Worker::WorkflowInstance).void }
+  def initialize(instance); end
+
+  sig do
+    params(
+      name: String,
+      input: T.any(
+        Temporalio::Worker::Interceptor::Workflow::HandleSignalInput,
+        Temporalio::Worker::Interceptor::Workflow::HandleQueryInput,
+        Temporalio::Worker::Interceptor::Workflow::HandleUpdateInput
+      ),
+      to_invoke: T.nilable(T.any(Symbol, Proc))
+    ).returns(T.nilable(Object))
+  end
+  def invoke_handler(name, input, to_invoke: T.unsafe(nil)); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/nexus_client.rbi

@@ -0,0 +1,47 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::NexusClient < Temporalio::Workflow::NexusClient
+  extend T::Sig
+
+  sig { returns(String) }
+  attr_reader :endpoint
+
+  sig { returns(String) }
+  attr_reader :service
+
+  sig do
+    params(
+      endpoint: T.any(Symbol, String),
+      service: T.any(Symbol, String),
+      outbound: Object
+    ).void
+  end
+  def initialize(endpoint:, service:, outbound:); end
+
+  sig do
+    params(
+      operation: T.any(Symbol, String),
+      arg: T.nilable(Object),
+      schedule_to_close_timeout: T.nilable(T.any(Integer, Float)),
+      schedule_to_start_timeout: T.nilable(T.any(Integer, Float)),
+      start_to_close_timeout: T.nilable(T.any(Integer, Float)),
+      cancellation_type: Integer,
+      summary: T.nilable(String),
+      cancellation: Temporalio::Cancellation,
+      arg_hint: T.nilable(Object),
+      result_hint: T.nilable(Object)
+    ).returns(Temporalio::Workflow::NexusOperationHandle)
+  end
+  def start_operation(
+    operation,
+    arg,
+    schedule_to_close_timeout: T.unsafe(nil),
+    schedule_to_start_timeout: T.unsafe(nil),
+    start_to_close_timeout: T.unsafe(nil),
+    cancellation_type: T.unsafe(nil),
+    summary: T.unsafe(nil),
+    cancellation: T.unsafe(nil),
+    arg_hint: T.unsafe(nil),
+    result_hint: T.unsafe(nil)
+  ); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/nexus_operation_handle.rbi

@@ -0,0 +1,19 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::NexusOperationHandle < Temporalio::Workflow::NexusOperationHandle
+  extend T::Sig
+
+  sig do
+    params(
+      operation_token: T.nilable(String),
+      instance: Temporalio::Internal::Worker::WorkflowInstance,
+      cancellation: Temporalio::Cancellation,
+      cancel_callback_key: Object,
+      result_hint: T.nilable(Object)
+    ).void
+  end
+  def initialize(operation_token:, instance:, cancellation:, cancel_callback_key:, result_hint:); end
+
+  sig { params(resolution: Object).void }
+  def _resolve(resolution); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/outbound_implementation.rbi

@@ -0,0 +1,43 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::OutboundImplementation < Temporalio::Worker::Interceptor::Workflow::Outbound
+  extend T::Sig
+
+  sig { params(instance: Temporalio::Internal::Worker::WorkflowInstance).void }
+  def initialize(instance); end
+
+  sig do
+    params(
+      local: T::Boolean,
+      cancellation: Temporalio::Cancellation,
+      result_hint: T.nilable(Object),
+      block: T.proc.params(arg0: T.nilable(Object)).returns(Integer)
+    ).returns(T.nilable(Object))
+  end
+  def execute_activity_with_local_backoffs(local:, cancellation:, result_hint:, &block); end
+
+  sig do
+    params(
+      local: T::Boolean,
+      cancellation: Temporalio::Cancellation,
+      last_local_backoff: T.nilable(Object),
+      result_hint: T.nilable(Object),
+      block: T.proc.params(arg0: T.nilable(Object)).returns(Integer)
+    ).returns(T.nilable(Object))
+  end
+  def execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &block); end
+
+  sig do
+    params(
+      id: String,
+      run_id: T.nilable(String),
+      child: T::Boolean,
+      signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String),
+      args: T::Array[T.nilable(Object)],
+      cancellation: Temporalio::Cancellation,
+      arg_hints: T.nilable(T::Array[Object]),
+      headers: T::Hash[String, T.nilable(Object)]
+    ).void
+  end
+  def _signal_external_workflow(id:, run_id:, child:, signal:, args:, cancellation:, arg_hints:, headers:); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/replay_safe_logger.rbi

@@ -0,0 +1,11 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::ReplaySafeLogger < Temporalio::ScopedLogger
+  extend T::Sig
+
+  sig { params(logger: Logger, instance: Temporalio::Internal::Worker::WorkflowInstance).void }
+  def initialize(logger:, instance:); end
+
+  sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+  def replay_safety_disabled(&block); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/replay_safe_metric.rbi

@@ -0,0 +1,15 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::ReplaySafeMetric < Temporalio::Metric
+  extend T::Sig
+
+  sig { params(obj: Temporalio::Metric).void }
+  def initialize(obj); end
+end
+
+class Temporalio::Internal::Worker::WorkflowInstance::ReplaySafeMetric::Meter < Temporalio::Metric::Meter
+  extend T::Sig
+
+  sig { params(obj: Temporalio::Metric::Meter).void }
+  def initialize(obj); end
+end

data/rbi/temporalio/internal/worker/workflow_instance/scheduler.rbi

@@ -0,0 +1,36 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::Scheduler
+  extend T::Sig
+
+  sig { params(instance: Temporalio::Internal::Worker::WorkflowInstance).void }
+  def initialize(instance); end
+
+  sig { returns(Temporalio::Internal::Worker::WorkflowInstance::Context) }
+  def context; end
+
+  sig { void }
+  def run_until_all_yielded; end
+
+  sig do
+    type_parameters(:T)
+      .params(cancellation: T.nilable(Temporalio::Cancellation), block: T.proc.returns(T.type_parameter(:T)))
+      .returns(T.type_parameter(:T))
+  end
+  def wait_condition(cancellation:, &block); end
+
+  sig { returns(String) }
+  def stack_trace; end
+
+  sig do
+    type_parameters(:T)
+      .params(
+        duration: T.nilable(T.any(Integer, Float)),
+        exception_class: T.class_of(Exception),
+        exception_arguments: T.nilable(Object),
+        block: T.proc.returns(T.type_parameter(:T))
+      )
+      .returns(T.type_parameter(:T))
+  end
+  def timeout_after(duration, exception_class, *exception_arguments, &block); end
+end