temporalio 1.5.0 → 1.6.0

data/rbi/temporalio/worker/tuner.rbi

@@ -0,0 +1,221 @@
+# typed: true
+
+class Temporalio::Worker::Tuner
+  extend T::Sig
+
+  sig { returns(SlotSupplier) }
+  attr_reader :workflow_slot_supplier
+
+  sig { returns(SlotSupplier) }
+  attr_reader :activity_slot_supplier
+
+  sig { returns(SlotSupplier) }
+  attr_reader :local_activity_slot_supplier
+
+  sig { returns(T.nilable(Temporalio::Worker::ThreadPool)) }
+  attr_reader :custom_slot_supplier_thread_pool
+
+  sig do
+    params(
+      workflow_slot_supplier: SlotSupplier,
+      activity_slot_supplier: SlotSupplier,
+      local_activity_slot_supplier: SlotSupplier,
+      custom_slot_supplier_thread_pool: T.nilable(Temporalio::Worker::ThreadPool)
+    ).void
+  end
+  def initialize(
+    workflow_slot_supplier:,
+    activity_slot_supplier:,
+    local_activity_slot_supplier:,
+    custom_slot_supplier_thread_pool: T.unsafe(nil)
+  ); end
+
+  class << self
+    extend T::Sig
+
+    sig do
+      params(
+        workflow_slots: Integer,
+        activity_slots: Integer,
+        local_activity_slots: Integer
+      ).returns(Temporalio::Worker::Tuner)
+    end
+    def create_fixed(workflow_slots: T.unsafe(nil), activity_slots: T.unsafe(nil), local_activity_slots: T.unsafe(nil)); end
+
+    sig do
+      params(
+        target_memory_usage: Float,
+        target_cpu_usage: Float,
+        workflow_options: ResourceBasedSlotOptions,
+        activity_options: ResourceBasedSlotOptions,
+        local_activity_options: ResourceBasedSlotOptions
+      ).returns(Temporalio::Worker::Tuner)
+    end
+    def create_resource_based(
+      target_memory_usage:,
+      target_cpu_usage:,
+      workflow_options: T.unsafe(nil),
+      activity_options: T.unsafe(nil),
+      local_activity_options: T.unsafe(nil)
+    ); end
+  end
+end
+
+class Temporalio::Worker::Tuner::SlotSupplier; end
+
+class Temporalio::Worker::Tuner::SlotSupplier::Fixed < ::Temporalio::Worker::Tuner::SlotSupplier
+  extend T::Sig
+
+  sig { returns(Integer) }
+  attr_reader :slots
+
+  sig { params(slots: Integer).void }
+  def initialize(slots); end
+end
+
+class Temporalio::Worker::Tuner::SlotSupplier::ResourceBased < ::Temporalio::Worker::Tuner::SlotSupplier
+  extend T::Sig
+
+  sig { returns(Temporalio::Worker::Tuner::ResourceBasedTunerOptions) }
+  attr_reader :tuner_options
+
+  sig { returns(Temporalio::Worker::Tuner::ResourceBasedSlotOptions) }
+  attr_reader :slot_options
+
+  sig do
+    params(
+      tuner_options: Temporalio::Worker::Tuner::ResourceBasedTunerOptions,
+      slot_options: Temporalio::Worker::Tuner::ResourceBasedSlotOptions
+    ).void
+  end
+  def initialize(tuner_options:, slot_options:); end
+end
+
+class Temporalio::Worker::Tuner::SlotSupplier::Custom < ::Temporalio::Worker::Tuner::SlotSupplier
+  extend T::Sig
+
+  sig do
+    params(
+      context: ReserveContext,
+      cancellation: Temporalio::Cancellation,
+      block: T.proc.params(arg0: Object).void
+    ).void
+  end
+  def reserve_slot(context, cancellation, &block); end
+
+  sig { params(context: ReserveContext).returns(Object) }
+  def try_reserve_slot(context); end
+
+  sig { params(context: MarkUsedContext).void }
+  def mark_slot_used(context); end
+
+  sig { params(context: ReleaseContext).void }
+  def release_slot(context); end
+end
+
+class Temporalio::Worker::Tuner::SlotSupplier::Custom::ReserveContext < ::Data
+  extend T::Sig
+
+  sig { returns(Symbol) }
+  def slot_type; end
+
+  sig { returns(String) }
+  def task_queue; end
+
+  sig { returns(String) }
+  def worker_identity; end
+
+  sig { returns(String) }
+  def worker_deployment_name; end
+
+  sig { returns(String) }
+  def worker_build_id; end
+
+  sig { returns(T::Boolean) }
+  def sticky?; end
+end
+
+class Temporalio::Worker::Tuner::SlotSupplier::Custom::MarkUsedContext < ::Data
+  extend T::Sig
+
+  sig { returns(T.any(Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Workflow, Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Activity, Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::LocalActivity, Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Nexus)) }
+  def slot_info; end
+
+  sig { returns(Object) }
+  def permit; end
+end
+
+class Temporalio::Worker::Tuner::SlotSupplier::Custom::ReleaseContext < ::Data
+  extend T::Sig
+
+  sig { returns(T.nilable(T.any(Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Workflow, Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Activity, Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::LocalActivity, Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Nexus))) }
+  def slot_info; end
+
+  sig { returns(Object) }
+  def permit; end
+end
+
+module Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo; end
+
+class Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Workflow < ::Data
+  extend T::Sig
+
+  sig { returns(String) }
+  def workflow_type; end
+
+  sig { returns(T::Boolean) }
+  def sticky?; end
+end
+
+class Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Activity < ::Data
+  extend T::Sig
+
+  sig { returns(String) }
+  def activity_type; end
+end
+
+class Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::LocalActivity < ::Data
+  extend T::Sig
+
+  sig { returns(String) }
+  def activity_type; end
+end
+
+class Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Nexus < ::Data
+  extend T::Sig
+
+  sig { returns(String) }
+  def service; end
+
+  sig { returns(String) }
+  def operation; end
+end
+
+class Temporalio::Worker::Tuner::ResourceBasedTunerOptions < ::Data
+  extend T::Sig
+
+  sig { returns(Float) }
+  def target_memory_usage; end
+
+  sig { returns(Float) }
+  def target_cpu_usage; end
+
+  sig { params(target_memory_usage: Float, target_cpu_usage: Float).void }
+  def initialize(target_memory_usage:, target_cpu_usage:); end
+end
+
+class Temporalio::Worker::Tuner::ResourceBasedSlotOptions < ::Data
+  extend T::Sig
+
+  sig { returns(T.nilable(Integer)) }
+  def min_slots; end
+
+  sig { returns(T.nilable(Integer)) }
+  def max_slots; end
+
+  sig { returns(T.nilable(Numeric)) }
+  def ramp_throttle; end
+
+  sig { params(min_slots: T.nilable(Integer), max_slots: T.nilable(Integer), ramp_throttle: T.nilable(Float)).void }
+  def initialize(min_slots:, max_slots:, ramp_throttle:); end
+end

data/rbi/temporalio/worker/workflow_executor/thread_pool.rbi

@@ -0,0 +1,15 @@
+# typed: true
+
+class Temporalio::Worker::WorkflowExecutor::ThreadPool < ::Temporalio::Worker::WorkflowExecutor
+  extend T::Sig
+
+  sig { returns(Temporalio::Worker::WorkflowExecutor::ThreadPool) }
+  def self.default; end
+
+  sig { params(max_threads: Integer, thread_pool: Temporalio::Worker::ThreadPool).void }
+  def initialize(max_threads: T.unsafe(nil), thread_pool: T.unsafe(nil)); end
+end
+
+class Temporalio::Worker::WorkflowExecutor::ThreadPool::DeadlockError < ::Exception
+  include Temporalio::Internal::WorkflowTaskFailureError
+end

data/rbi/temporalio/worker/workflow_executor.rbi

@@ -0,0 +1,8 @@
+# typed: true
+
+class Temporalio::Worker::WorkflowExecutor
+  extend T::Sig
+
+  sig { void }
+  def initialize; end
+end

data/rbi/temporalio/worker/workflow_replayer.rbi

@@ -0,0 +1,152 @@
+# typed: true
+
+class Temporalio::Worker::WorkflowReplayer
+  extend T::Sig
+
+  sig { returns(Temporalio::Worker::WorkflowReplayer::Options) }
+  attr_reader :options
+
+  sig do
+    params(
+      workflows: T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)],
+      namespace: String,
+      task_queue: String,
+      data_converter: Temporalio::Converters::DataConverter,
+      workflow_executor: Temporalio::Worker::WorkflowExecutor,
+      plugins: T::Array[Temporalio::Worker::Plugin],
+      interceptors: T::Array[Temporalio::Worker::Interceptor::Workflow],
+      identity: T.nilable(String),
+      logger: Logger,
+      illegal_workflow_calls: T::Hash[String, T.any(Symbol, T::Array[Symbol])],
+      workflow_failure_exception_types: T::Array[T.class_of(Exception)],
+      workflow_payload_codec_thread_pool: T.nilable(Temporalio::Worker::ThreadPool),
+      unsafe_workflow_io_enabled: T::Boolean,
+      debug_mode: T::Boolean,
+      runtime: Temporalio::Runtime,
+      block: T.nilable(T.proc.params(worker: Temporalio::Worker::WorkflowReplayer::ReplayWorker).returns(T.anything))
+    ).void
+  end
+  def initialize(
+    workflows:,
+    namespace: T.unsafe(nil),
+    task_queue: T.unsafe(nil),
+    data_converter: T.unsafe(nil),
+    workflow_executor: T.unsafe(nil),
+    plugins: T.unsafe(nil),
+    interceptors: T.unsafe(nil),
+    identity: T.unsafe(nil),
+    logger: T.unsafe(nil),
+    illegal_workflow_calls: T.unsafe(nil),
+    workflow_failure_exception_types: T.unsafe(nil),
+    workflow_payload_codec_thread_pool: T.unsafe(nil),
+    unsafe_workflow_io_enabled: T.unsafe(nil),
+    debug_mode: T.unsafe(nil),
+    runtime: T.unsafe(nil),
+    &block
+  ); end
+
+  sig do
+    params(
+      history: Temporalio::WorkflowHistory,
+      raise_on_replay_failure: T::Boolean
+    ).returns(Temporalio::Worker::WorkflowReplayer::ReplayResult)
+  end
+  def replay_workflow(history, raise_on_replay_failure: T.unsafe(nil)); end
+
+  sig do
+    params(
+      histories: T::Enumerable[Temporalio::WorkflowHistory],
+      raise_on_replay_failure: T::Boolean
+    ).returns(T::Array[Temporalio::Worker::WorkflowReplayer::ReplayResult])
+  end
+  def replay_workflows(histories, raise_on_replay_failure: T.unsafe(nil)); end
+
+  sig do
+    type_parameters(:T)
+      .params(block: T.proc.params(worker: Temporalio::Worker::WorkflowReplayer::ReplayWorker).returns(T.type_parameter(:T)))
+      .returns(T.type_parameter(:T))
+  end
+  def with_replay_worker(&block); end
+end
+
+class Temporalio::Worker::WorkflowReplayer::Options < ::Data
+  extend T::Sig
+
+  sig { returns(T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)]) }
+  def workflows; end
+
+  sig { returns(String) }
+  def namespace; end
+
+  sig { returns(String) }
+  def task_queue; end
+
+  sig { returns(Temporalio::Converters::DataConverter) }
+  def data_converter; end
+
+  sig { returns(Temporalio::Worker::WorkflowExecutor) }
+  def workflow_executor; end
+
+  sig { returns(T::Array[Temporalio::Worker::Plugin]) }
+  def plugins; end
+
+  sig { returns(T::Array[Temporalio::Worker::Interceptor::Workflow]) }
+  def interceptors; end
+
+  sig { returns(T.nilable(String)) }
+  def identity; end
+
+  sig { returns(Logger) }
+  def logger; end
+
+  sig { returns(T::Hash[String, T.any(Symbol, T::Array[Symbol])]) }
+  def illegal_workflow_calls; end
+
+  sig { returns(T::Array[T.class_of(Exception)]) }
+  def workflow_failure_exception_types; end
+
+  sig { returns(T.nilable(Temporalio::Worker::ThreadPool)) }
+  def workflow_payload_codec_thread_pool; end
+
+  sig { returns(T::Boolean) }
+  def unsafe_workflow_io_enabled; end
+
+  sig { returns(T::Boolean) }
+  def debug_mode; end
+
+  sig { returns(Temporalio::Runtime) }
+  def runtime; end
+
+  sig { params(kwargs: T.untyped).returns(Temporalio::Worker::WorkflowReplayer::Options) }
+  def with(**kwargs); end
+end
+
+class Temporalio::Worker::WorkflowReplayer::ReplayResult
+  extend T::Sig
+
+  sig { returns(Temporalio::WorkflowHistory) }
+  attr_reader :history
+
+  sig { returns(T.nilable(Exception)) }
+  attr_reader :replay_failure
+
+  sig { params(history: Temporalio::WorkflowHistory, replay_failure: T.nilable(Exception)).void }
+  def initialize(history:, replay_failure:); end
+end
+
+class Temporalio::Worker::WorkflowReplayer::ReplayWorker
+  extend T::Sig
+
+  sig do
+    params(
+      history: Temporalio::WorkflowHistory,
+      raise_on_replay_failure: T::Boolean
+    ).returns(Temporalio::Worker::WorkflowReplayer::ReplayResult)
+  end
+  def replay_workflow(history, raise_on_replay_failure: T.unsafe(nil)); end
+
+  private
+
+  sig { returns(T::Boolean) }
+  def workflow_activation_work_drained?; end
+end

data/rbi/temporalio/worker.rbi

@@ -0,0 +1,258 @@
+# typed: true
+
+class Temporalio::Worker
+  extend T::Sig
+
+  sig { returns(Options) }
+  attr_reader :options
+
+  sig do
+    params(
+      client: Temporalio::Client,
+      task_queue: String,
+      activities: T::Array[T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info)],
+      workflows: T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)],
+      tuner: Temporalio::Worker::Tuner,
+      activity_executors: T::Hash[Symbol, Temporalio::Worker::ActivityExecutor],
+      workflow_executor: Temporalio::Worker::WorkflowExecutor,
+      plugins: T::Array[Temporalio::Worker::Plugin],
+      interceptors: T::Array[T.any(Temporalio::Worker::Interceptor::Activity, Temporalio::Worker::Interceptor::Workflow)],
+      identity: T.nilable(String),
+      logger: Logger,
+      max_cached_workflows: Integer,
+      max_concurrent_workflow_task_polls: Integer,
+      nonsticky_to_sticky_poll_ratio: Numeric,
+      max_concurrent_activity_task_polls: Integer,
+      no_remote_activities: T::Boolean,
+      sticky_queue_schedule_to_start_timeout: Numeric,
+      max_heartbeat_throttle_interval: Numeric,
+      default_heartbeat_throttle_interval: Numeric,
+      max_activities_per_second: T.nilable(Numeric),
+      max_task_queue_activities_per_second: T.nilable(Numeric),
+      graceful_shutdown_period: Numeric,
+      disable_eager_activity_execution: T::Boolean,
+      illegal_workflow_calls: T::Hash[String, T.any(Symbol, T::Array[T.any(Symbol, Temporalio::Worker::IllegalWorkflowCallValidator)], Temporalio::Worker::IllegalWorkflowCallValidator)],
+      workflow_failure_exception_types: T::Array[T.class_of(Exception)],
+      workflow_payload_codec_thread_pool: T.nilable(Temporalio::Worker::ThreadPool),
+      unsafe_workflow_io_enabled: T::Boolean,
+      deployment_options: Temporalio::Worker::DeploymentOptions,
+      patch_activation_callback: T.nilable(T.proc.params(input: Temporalio::Worker::PatchActivationInput).returns(T::Boolean)),
+      workflow_task_poller_behavior: Temporalio::Worker::PollerBehavior,
+      activity_task_poller_behavior: Temporalio::Worker::PollerBehavior,
+      debug_mode: T::Boolean
+    ).void
+  end
+  def initialize(
+    client:,
+    task_queue:,
+    activities: T.unsafe(nil),
+    workflows: T.unsafe(nil),
+    tuner: T.unsafe(nil),
+    activity_executors: T.unsafe(nil),
+    workflow_executor: T.unsafe(nil),
+    plugins: T.unsafe(nil),
+    interceptors: T.unsafe(nil),
+    identity: T.unsafe(nil),
+    logger: T.unsafe(nil),
+    max_cached_workflows: T.unsafe(nil),
+    max_concurrent_workflow_task_polls: T.unsafe(nil),
+    nonsticky_to_sticky_poll_ratio: T.unsafe(nil),
+    max_concurrent_activity_task_polls: T.unsafe(nil),
+    no_remote_activities: T.unsafe(nil),
+    sticky_queue_schedule_to_start_timeout: T.unsafe(nil),
+    max_heartbeat_throttle_interval: T.unsafe(nil),
+    default_heartbeat_throttle_interval: T.unsafe(nil),
+    max_activities_per_second: T.unsafe(nil),
+    max_task_queue_activities_per_second: T.unsafe(nil),
+    graceful_shutdown_period: T.unsafe(nil),
+    disable_eager_activity_execution: T.unsafe(nil),
+    illegal_workflow_calls: T.unsafe(nil),
+    workflow_failure_exception_types: T.unsafe(nil),
+    workflow_payload_codec_thread_pool: T.unsafe(nil),
+    unsafe_workflow_io_enabled: T.unsafe(nil),
+    deployment_options: T.unsafe(nil),
+    patch_activation_callback: T.unsafe(nil),
+    workflow_task_poller_behavior: T.unsafe(nil),
+    activity_task_poller_behavior: T.unsafe(nil),
+    debug_mode: T.unsafe(nil)
+  ); end
+
+  sig { returns(String) }
+  def task_queue; end
+
+  sig { returns(Temporalio::Client) }
+  def client; end
+
+  sig { params(new_client: Temporalio::Client).void }
+  def client=(new_client); end
+
+  sig do
+    type_parameters(:T)
+      .params(
+        cancellation: Temporalio::Cancellation,
+        shutdown_signals: T::Array[T.any(String, Integer)],
+        raise_in_block_on_shutdown: T.nilable(Exception),
+        wait_block_complete: T::Boolean,
+        block: T.nilable(T.proc.returns(T.type_parameter(:T)))
+      ).returns(T.type_parameter(:T))
+  end
+  def run(
+    cancellation: T.unsafe(nil),
+    shutdown_signals: T.unsafe(nil),
+    raise_in_block_on_shutdown: T.unsafe(nil),
+    wait_block_complete: T.unsafe(nil),
+    &block
+  ); end
+
+  class << self
+    extend T::Sig
+
+    sig { returns(String) }
+    def default_build_id; end
+
+    sig { returns(Temporalio::Worker::DeploymentOptions) }
+    def default_deployment_options; end
+
+    sig do
+      type_parameters(:T)
+        .params(
+          workers: Temporalio::Worker,
+          cancellation: Temporalio::Cancellation,
+          shutdown_signals: T::Array[T.any(String, Integer)],
+          raise_in_block_on_shutdown: T.nilable(Exception),
+          wait_block_complete: T::Boolean,
+          block: T.nilable(T.proc.returns(T.type_parameter(:T)))
+        ).returns(T.type_parameter(:T))
+    end
+    def run_all(
+      *workers,
+      cancellation: T.unsafe(nil),
+      shutdown_signals: T.unsafe(nil),
+      raise_in_block_on_shutdown: T.unsafe(nil),
+      wait_block_complete: T.unsafe(nil),
+      &block
+    ); end
+
+    sig { returns(T::Hash[String, T.any(Symbol, T::Array[T.any(Symbol, IllegalWorkflowCallValidator)], IllegalWorkflowCallValidator)]) }
+    def default_illegal_workflow_calls; end
+  end
+end
+
+class Temporalio::Worker::PatchActivationInput < ::Data
+  extend T::Sig
+
+  sig { returns(Temporalio::Workflow::Info) }
+  def workflow_info; end
+
+  sig { returns(String) }
+  def patch_id; end
+
+  sig { params(workflow_info: Temporalio::Workflow::Info, patch_id: String).void }
+  def initialize(workflow_info:, patch_id:); end
+
+  sig { params(kwargs: T.untyped).returns(Temporalio::Worker::PatchActivationInput) }
+  def with(**kwargs); end
+end
+
+class Temporalio::Worker::Options < ::Data
+  extend T::Sig
+
+  sig { returns(Temporalio::Client) }
+  def client; end
+
+  sig { returns(String) }
+  def task_queue; end
+
+  sig { returns(T::Array[T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info)]) }
+  def activities; end
+
+  sig { returns(T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)]) }
+  def workflows; end
+
+  sig { returns(Temporalio::Worker::Tuner) }
+  def tuner; end
+
+  sig { returns(T::Hash[Symbol, Temporalio::Worker::ActivityExecutor]) }
+  def activity_executors; end
+
+  sig { returns(Temporalio::Worker::WorkflowExecutor) }
+  def workflow_executor; end
+
+  sig { returns(T::Array[Temporalio::Worker::Plugin]) }
+  def plugins; end
+
+  sig { returns(T::Array[T.any(Temporalio::Worker::Interceptor::Activity, Temporalio::Worker::Interceptor::Workflow)]) }
+  def interceptors; end
+
+  sig { returns(T.nilable(String)) }
+  def identity; end
+
+  sig { returns(Logger) }
+  def logger; end
+
+  sig { returns(Integer) }
+  def max_cached_workflows; end
+
+  sig { returns(Integer) }
+  def max_concurrent_workflow_task_polls; end
+
+  sig { returns(Numeric) }
+  def nonsticky_to_sticky_poll_ratio; end
+
+  sig { returns(Integer) }
+  def max_concurrent_activity_task_polls; end
+
+  sig { returns(T::Boolean) }
+  def no_remote_activities; end
+
+  sig { returns(Numeric) }
+  def sticky_queue_schedule_to_start_timeout; end
+
+  sig { returns(Numeric) }
+  def max_heartbeat_throttle_interval; end
+
+  sig { returns(Numeric) }
+  def default_heartbeat_throttle_interval; end
+
+  sig { returns(T.nilable(Numeric)) }
+  def max_activities_per_second; end
+
+  sig { returns(T.nilable(Numeric)) }
+  def max_task_queue_activities_per_second; end
+
+  sig { returns(Numeric) }
+  def graceful_shutdown_period; end
+
+  sig { returns(T::Boolean) }
+  def disable_eager_activity_execution; end
+
+  sig { returns(T::Hash[String, T.any(Symbol, T::Array[T.any(Symbol, Temporalio::Worker::IllegalWorkflowCallValidator)], Temporalio::Worker::IllegalWorkflowCallValidator)]) }
+  def illegal_workflow_calls; end
+
+  sig { returns(T::Array[T.class_of(Exception)]) }
+  def workflow_failure_exception_types; end
+
+  sig { returns(T.nilable(Temporalio::Worker::ThreadPool)) }
+  def workflow_payload_codec_thread_pool; end
+
+  sig { returns(T::Boolean) }
+  def unsafe_workflow_io_enabled; end
+
+  sig { returns(T.nilable(T.proc.params(input: Temporalio::Worker::PatchActivationInput).returns(T::Boolean))) }
+  def patch_activation_callback; end
+
+  sig { returns(Temporalio::Worker::PollerBehavior) }
+  def workflow_task_poller_behavior; end
+
+  sig { returns(Temporalio::Worker::PollerBehavior) }
+  def activity_task_poller_behavior; end
+
+  sig { returns(Temporalio::Worker::DeploymentOptions) }
+  def deployment_options; end
+
+  sig { returns(T::Boolean) }
+  def debug_mode; end
+
+  sig { params(kwargs: T.untyped).returns(Temporalio::Worker::Options) }
+  def with(**kwargs); end
+end

data/rbi/temporalio/worker_deployment_version.rbi

@@ -0,0 +1,29 @@
+# typed: true
+
+class Temporalio::WorkerDeploymentVersion < ::Data
+  sig { params(deployment_name: String, build_id: String).void }
+  def initialize(deployment_name:, build_id:); end
+
+  sig { params(canonical: String).returns(Temporalio::WorkerDeploymentVersion) }
+  def self.from_canonical_string(canonical); end
+
+  sig { returns(String) }
+  def deployment_name; end
+
+  sig { returns(String) }
+  def build_id; end
+
+  sig { returns(String) }
+  def to_canonical_string; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::WorkerDeploymentVersion) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+
+    sig { params(args: T.untyped).returns(Temporalio::WorkerDeploymentVersion) }
+    def new(*args); end
+  end
+end

data/rbi/temporalio/workflow/activity_cancellation_type.rbi

@@ -0,0 +1,7 @@
+# typed: true
+
+module Temporalio::Workflow::ActivityCancellationType
+  TRY_CANCEL = T.let(T.unsafe(nil), Integer)
+  WAIT_CANCELLATION_COMPLETED = T.let(T.unsafe(nil), Integer)
+  ABANDON = T.let(T.unsafe(nil), Integer)
+end

data/rbi/temporalio/workflow/child_workflow_cancellation_type.rbi

@@ -0,0 +1,8 @@
+# typed: true
+
+module Temporalio::Workflow::ChildWorkflowCancellationType
+  ABANDON = T.let(T.unsafe(nil), Integer)
+  TRY_CANCEL = T.let(T.unsafe(nil), Integer)
+  WAIT_CANCELLATION_COMPLETED = T.let(T.unsafe(nil), Integer)
+  WAIT_CANCELLATION_REQUESTED = T.let(T.unsafe(nil), Integer)
+end