temporalio 1.5.0 → 1.6.0

data/rbi/temporalio/runtime.rbi

@@ -0,0 +1,185 @@
+# typed: true
+
+class Temporalio::Runtime
+  extend T::Sig
+
+  sig { returns(Temporalio::Metric::Meter) }
+  attr_reader :metric_meter
+
+  sig { params(telemetry: Temporalio::Runtime::TelemetryOptions, worker_heartbeat_interval: T.nilable(Float)).void }
+  def initialize(telemetry: T.unsafe(nil), worker_heartbeat_interval: T.unsafe(nil)); end
+
+  class << self
+    extend T::Sig
+
+    sig { returns(Temporalio::Runtime) }
+    def default; end
+
+    sig { params(runtime: Temporalio::Runtime).void }
+    def default=(runtime); end
+  end
+end
+
+class Temporalio::Runtime::TelemetryOptions < ::Data
+  extend T::Sig
+
+  sig { returns(T.nilable(Temporalio::Runtime::LoggingOptions)) }
+  def logging; end
+
+  sig { returns(T.nilable(Temporalio::Runtime::MetricsOptions)) }
+  def metrics; end
+
+  sig { params(logging: T.nilable(Temporalio::Runtime::LoggingOptions), metrics: T.nilable(Temporalio::Runtime::MetricsOptions)).void }
+  def initialize(logging: T.unsafe(nil), metrics: T.unsafe(nil)); end
+end
+
+class Temporalio::Runtime::LoggingOptions < ::Data
+  extend T::Sig
+
+  sig { returns(T.any(Temporalio::Runtime::LoggingFilterOptions, String)) }
+  def log_filter; end
+
+  sig { params(log_filter: T.any(Temporalio::Runtime::LoggingFilterOptions, String)).void }
+  def initialize(log_filter: T.unsafe(nil)); end
+end
+
+class Temporalio::Runtime::LoggingFilterOptions < ::Data
+  extend T::Sig
+
+  sig { returns(String) }
+  def core_level; end
+
+  sig { returns(String) }
+  def other_level; end
+
+  sig { params(core_level: String, other_level: String).void }
+  def initialize(core_level: T.unsafe(nil), other_level: T.unsafe(nil)); end
+end
+
+class Temporalio::Runtime::MetricsOptions < ::Data
+  extend T::Sig
+
+  sig { returns(T.nilable(Temporalio::Runtime::OpenTelemetryMetricsOptions)) }
+  def opentelemetry; end
+
+  sig { returns(T.nilable(Temporalio::Runtime::PrometheusMetricsOptions)) }
+  def prometheus; end
+
+  sig { returns(T.nilable(Temporalio::Runtime::MetricBuffer)) }
+  def buffer; end
+
+  sig { returns(T::Boolean) }
+  def attach_service_name; end
+
+  sig { returns(T.nilable(T::Hash[String, String])) }
+  def global_tags; end
+
+  sig { returns(T.nilable(String)) }
+  def metric_prefix; end
+
+  sig do
+    params(
+      opentelemetry: T.nilable(Temporalio::Runtime::OpenTelemetryMetricsOptions),
+      prometheus: T.nilable(Temporalio::Runtime::PrometheusMetricsOptions),
+      buffer: T.nilable(Temporalio::Runtime::MetricBuffer),
+      attach_service_name: T::Boolean,
+      global_tags: T.nilable(T::Hash[String, String]),
+      metric_prefix: T.nilable(String)
+    ).void
+  end
+  def initialize(
+    opentelemetry: T.unsafe(nil),
+    prometheus: T.unsafe(nil),
+    buffer: T.unsafe(nil),
+    attach_service_name: T.unsafe(nil),
+    global_tags: T.unsafe(nil),
+    metric_prefix: T.unsafe(nil)
+  ); end
+end
+
+class Temporalio::Runtime::OpenTelemetryMetricsOptions < ::Data
+  extend T::Sig
+
+  sig { returns(String) }
+  def url; end
+
+  sig { returns(T.nilable(T::Hash[String, String])) }
+  def headers; end
+
+  sig { returns(T.nilable(Numeric)) }
+  def metric_periodicity; end
+
+  sig { returns(Integer) }
+  def metric_temporality; end
+
+  sig { returns(T::Boolean) }
+  def durations_as_seconds; end
+
+  sig { returns(T::Boolean) }
+  def http; end
+
+  sig { returns(T.nilable(T::Hash[String, T::Array[Numeric]])) }
+  def histogram_bucket_overrides; end
+
+  sig do
+    params(
+      url: String,
+      headers: T.nilable(T::Hash[String, String]),
+      metric_periodicity: T.nilable(Float),
+      metric_temporality: Integer,
+      durations_as_seconds: T::Boolean,
+      http: T::Boolean,
+      histogram_bucket_overrides: T.nilable(T::Hash[String, T::Array[Numeric]])
+    ).void
+  end
+  def initialize(
+    url:,
+    headers: T.unsafe(nil),
+    metric_periodicity: T.unsafe(nil),
+    metric_temporality: T.unsafe(nil),
+    durations_as_seconds: T.unsafe(nil),
+    http: T.unsafe(nil),
+    histogram_bucket_overrides: T.unsafe(nil)
+  ); end
+
+  module MetricTemporality
+    CUMULATIVE = T.let(T.unsafe(nil), Integer)
+    DELTA = T.let(T.unsafe(nil), Integer)
+  end
+end
+
+class Temporalio::Runtime::PrometheusMetricsOptions < ::Data
+  extend T::Sig
+
+  sig { returns(String) }
+  def bind_address; end
+
+  sig { returns(T::Boolean) }
+  def counters_total_suffix; end
+
+  sig { returns(T::Boolean) }
+  def unit_suffix; end
+
+  sig { returns(T::Boolean) }
+  def durations_as_seconds; end
+
+  sig { returns(T.nilable(T::Hash[String, T::Array[Numeric]])) }
+  def histogram_bucket_overrides; end
+
+  sig do
+    params(
+      bind_address: String,
+      counters_total_suffix: T::Boolean,
+      unit_suffix: T::Boolean,
+      durations_as_seconds: T::Boolean,
+      histogram_bucket_overrides: T.nilable(T::Hash[String, T::Array[Numeric]])
+    ).void
+  end
+  def initialize(
+    bind_address:,
+    counters_total_suffix: T.unsafe(nil),
+    unit_suffix: T.unsafe(nil),
+    durations_as_seconds: T.unsafe(nil),
+    histogram_bucket_overrides: T.unsafe(nil)
+  ); end
+end

data/rbi/temporalio/scoped_logger.rbi

@@ -0,0 +1,50 @@
+# typed: true
+
+class Temporalio::ScopedLogger < ::SimpleDelegator
+  sig { params(obj: ::Logger).void }
+  def initialize(obj); end
+
+  sig { returns(T.nilable(Proc)) }
+  attr_accessor :scoped_values_getter
+
+  sig { returns(T::Boolean) }
+  attr_accessor :disable_scoped_values
+
+  sig { params(severity: T.nilable(Integer), message: T.nilable(Object), progname: T.nilable(Object)).void }
+  def add(severity, message = nil, progname = nil); end
+
+  sig { params(severity: T.nilable(Integer), message: T.nilable(Object), progname: T.nilable(Object)).void }
+  def log(severity, message = nil, progname = nil); end
+
+  sig { params(progname: T.nilable(Object), blk: T.nilable(T.proc.returns(Object))).void }
+  def debug(progname = nil, &blk); end
+
+  sig { params(progname: T.nilable(Object), blk: T.nilable(T.proc.returns(Object))).void }
+  def info(progname = nil, &blk); end
+
+  sig { params(progname: T.nilable(Object), blk: T.nilable(T.proc.returns(Object))).void }
+  def warn(progname = nil, &blk); end
+
+  sig { params(progname: T.nilable(Object), blk: T.nilable(T.proc.returns(Object))).void }
+  def error(progname = nil, &blk); end
+
+  sig { params(progname: T.nilable(Object), blk: T.nilable(T.proc.returns(Object))).void }
+  def fatal(progname = nil, &blk); end
+
+  sig { params(progname: T.nilable(Object), blk: T.nilable(T.proc.returns(Object))).void }
+  def unknown(progname = nil, &blk); end
+end
+
+class Temporalio::ScopedLogger::LogMessage
+  sig { params(message: Object, scoped_values: Object).void }
+  def initialize(message, scoped_values); end
+
+  sig { returns(Object) }
+  attr_reader :message
+
+  sig { returns(Object) }
+  attr_reader :scoped_values
+
+  sig { returns(String) }
+  def inspect; end
+end

data/rbi/temporalio/search_attributes.rbi

@@ -0,0 +1,94 @@
+# typed: true
+
+class Temporalio::SearchAttributes
+  sig { params(existing: T.nilable(T.any(Temporalio::SearchAttributes, T::Hash[Temporalio::SearchAttributes::Key, Object]))).void }
+  def initialize(existing = nil); end
+
+  sig { params(key: T.any(Temporalio::SearchAttributes::Key, String, Symbol), value: T.nilable(Object)).void }
+  def []=(key, value); end
+
+  sig { params(key: Temporalio::SearchAttributes::Key).returns(T.nilable(Object)) }
+  def [](key); end
+
+  sig { params(key: T.any(Temporalio::SearchAttributes::Key, String, Symbol)).void }
+  def delete(key); end
+
+  sig { params(block: T.proc.params(key: Temporalio::SearchAttributes::Key, value: Object).void).returns(Temporalio::SearchAttributes) }
+  def each(&block); end
+
+  sig { returns(T::Hash[Temporalio::SearchAttributes::Key, Object]) }
+  def to_h; end
+
+  sig { returns(Temporalio::SearchAttributes) }
+  def dup; end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  sig { returns(Integer) }
+  def length; end
+
+  sig { returns(Integer) }
+  def size; end
+
+  sig { params(updates: Temporalio::SearchAttributes::Update).returns(Temporalio::SearchAttributes) }
+  def update(*updates); end
+
+  sig { params(updates: Temporalio::SearchAttributes::Update).void }
+  def update!(*updates); end
+
+  sig { params(other: Temporalio::SearchAttributes).returns(T::Boolean) }
+  def ==(other); end
+end
+
+class Temporalio::SearchAttributes::Key
+  sig { params(name: String, type: Integer).void }
+  def initialize(name, type); end
+
+  sig { returns(String) }
+  attr_reader :name
+
+  sig { returns(Integer) }
+  attr_reader :type
+
+  sig { params(value: Object).void }
+  def validate_value(value); end
+
+  sig { params(value: Object).returns(Temporalio::SearchAttributes::Update) }
+  def value_set(value); end
+
+  sig { returns(Temporalio::SearchAttributes::Update) }
+  def value_unset; end
+
+  sig { params(other: T.anything).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { params(other: T.anything).returns(T::Boolean) }
+  def eql?(other); end
+
+  sig { returns(Integer) }
+  def hash; end
+end
+
+class Temporalio::SearchAttributes::Update
+  sig { params(key: Temporalio::SearchAttributes::Key, value: T.nilable(Object)).void }
+  def initialize(key, value); end
+
+  sig { returns(Temporalio::SearchAttributes::Key) }
+  attr_reader :key
+
+  sig { returns(T.nilable(Object)) }
+  attr_reader :value
+end
+
+module Temporalio::SearchAttributes::IndexedValueType
+  TEXT = T.let(T.unsafe(nil), Integer)
+  KEYWORD = T.let(T.unsafe(nil), Integer)
+  INTEGER = T.let(T.unsafe(nil), Integer)
+  FLOAT = T.let(T.unsafe(nil), Integer)
+  BOOLEAN = T.let(T.unsafe(nil), Integer)
+  TIME = T.let(T.unsafe(nil), Integer)
+  KEYWORD_LIST = T.let(T.unsafe(nil), Integer)
+  PROTO_NAMES = T.let(T.unsafe(nil), T::Hash[Integer, String])
+  PROTO_VALUES = T.let(T.unsafe(nil), T::Hash[String, Integer])
+end

data/rbi/temporalio/simple_plugin.rbi

@@ -0,0 +1,41 @@
+# typed: true
+
+class Temporalio::SimplePlugin
+  include Temporalio::Client::Plugin
+  include Temporalio::Worker::Plugin
+
+  extend T::Sig
+
+  sig { returns(Temporalio::SimplePlugin::Options) }
+  attr_reader :options
+
+  sig do
+    params(
+      name: String,
+      data_converter: T.nilable(T.any(Temporalio::Converters::DataConverter, T.proc.params(arg0: Temporalio::Converters::DataConverter).returns(Temporalio::Converters::DataConverter))),
+      client_interceptors: T.nilable(T.any(T::Array[Temporalio::Client::Interceptor], T.proc.params(arg0: T::Array[Temporalio::Client::Interceptor]).returns(T::Array[Temporalio::Client::Interceptor]))),
+      activities: T.nilable(T.any(T::Array[T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info)], T.proc.params(arg0: T::Array[T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info)]).returns(T::Array[T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info)]))),
+      workflows: T.nilable(T.any(T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)], T.proc.params(arg0: T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)]).returns(T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)]))),
+      worker_interceptors: T.nilable(T.any(T::Array[T.any(Temporalio::Worker::Interceptor::Activity, Temporalio::Worker::Interceptor::Workflow)], T.proc.params(arg0: T::Array[T.any(Temporalio::Worker::Interceptor::Activity, Temporalio::Worker::Interceptor::Workflow)]).returns(T::Array[T.any(Temporalio::Worker::Interceptor::Activity, Temporalio::Worker::Interceptor::Workflow)]))),
+      workflow_failure_exception_types: T.nilable(T.any(T::Array[String], T.proc.params(arg0: T::Array[String]).returns(T::Array[String]))),
+      run_context: T.nilable(T.proc.params(arg0: T.any(Temporalio::Worker::Plugin::RunWorkerOptions, Temporalio::Worker::Plugin::WithWorkflowReplayWorkerOptions), arg1: T.proc.params(arg0: T.any(Temporalio::Worker::Plugin::RunWorkerOptions, Temporalio::Worker::Plugin::WithWorkflowReplayWorkerOptions)).returns(T.anything)).returns(T.anything))
+    ).void
+  end
+  def initialize(
+    name:,
+    data_converter: T.unsafe(nil),
+    client_interceptors: T.unsafe(nil),
+    activities: T.unsafe(nil),
+    workflows: T.unsafe(nil),
+    worker_interceptors: T.unsafe(nil),
+    workflow_failure_exception_types: T.unsafe(nil),
+    run_context: T.unsafe(nil)
+  ); end
+end
+
+class Temporalio::SimplePlugin::Options
+  extend T::Sig
+
+  sig { returns(String) }
+  def name; end
+end

data/rbi/temporalio/testing/activity_environment.rbi

@@ -0,0 +1,43 @@
+# typed: true
+
+class Temporalio::Testing::ActivityEnvironment
+  extend T::Sig
+
+  sig { returns(Temporalio::Activity::Info) }
+  def self.default_info; end
+
+  sig do
+    params(
+      info: Temporalio::Activity::Info,
+      on_heartbeat: T.nilable(Proc),
+      cancellation: Temporalio::Cancellation,
+      on_cancellation_details: T.nilable(Proc),
+      worker_shutdown_cancellation: Temporalio::Cancellation,
+      payload_converter: Temporalio::Converters::PayloadConverter,
+      logger: Logger,
+      activity_executors: T::Hash[Symbol, Temporalio::Worker::ActivityExecutor],
+      metric_meter: T.nilable(Temporalio::Metric::Meter),
+      client: T.nilable(Temporalio::Client)
+    ).void
+  end
+  def initialize(
+    info: T.unsafe(nil),
+    on_heartbeat: T.unsafe(nil),
+    cancellation: T.unsafe(nil),
+    on_cancellation_details: T.unsafe(nil),
+    worker_shutdown_cancellation: T.unsafe(nil),
+    payload_converter: T.unsafe(nil),
+    logger: T.unsafe(nil),
+    activity_executors: T.unsafe(nil),
+    metric_meter: T.unsafe(nil),
+    client: T.unsafe(nil)
+  ); end
+
+  sig do
+    params(
+      activity: T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info),
+      args: T.nilable(Object)
+    ).returns(T.anything)
+  end
+  def run(activity, *args); end
+end

data/rbi/temporalio/testing/workflow_environment.rbi

@@ -0,0 +1,116 @@
+# typed: true
+
+class Temporalio::Testing::WorkflowEnvironment
+  extend T::Sig
+
+  sig { returns(Temporalio::Client) }
+  attr_reader :client
+
+  sig { params(client: Temporalio::Client).void }
+  def initialize(client); end
+
+  sig { void }
+  def shutdown; end
+
+  sig { returns(T::Boolean) }
+  def supports_time_skipping?; end
+
+  sig { params(duration: T.any(Integer, Float)).void }
+  def sleep(duration); end
+
+  sig { returns(Time) }
+  def current_time; end
+
+  sig { params(name: String, task_queue: String).returns(Temporalio::Api::Nexus::V1::Endpoint) }
+  def create_nexus_endpoint(name:, task_queue:); end
+
+  sig { params(endpoint: Temporalio::Api::Nexus::V1::Endpoint).returns(NilClass) }
+  def delete_nexus_endpoint(endpoint); end
+
+  sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+  def auto_time_skipping_disabled(&block); end
+
+  class << self
+    extend T::Sig
+
+    sig do
+      type_parameters(:T)
+        .params(
+          namespace: String,
+          data_converter: Temporalio::Converters::DataConverter,
+          interceptors: T::Array[Temporalio::Client::Interceptor],
+          logger: Logger,
+          default_workflow_query_reject_condition: T.nilable(Integer),
+          ip: String,
+          port: T.nilable(Integer),
+          ui: T::Boolean,
+          ui_port: T.nilable(Integer),
+          search_attributes: T::Array[Temporalio::SearchAttributes::Key],
+          runtime: Temporalio::Runtime,
+          dev_server_existing_path: T.nilable(String),
+          dev_server_database_filename: T.nilable(String),
+          dev_server_log_format: String,
+          dev_server_log_level: String,
+          dev_server_download_version: String,
+          dev_server_download_dest_dir: T.nilable(String),
+          dev_server_extra_args: T::Array[String],
+          dev_server_download_ttl: T.nilable(Float),
+          block: T.nilable(T.proc.params(arg0: Temporalio::Testing::WorkflowEnvironment).returns(T.type_parameter(:T)))
+        ).returns(T.any(Temporalio::Testing::WorkflowEnvironment, T.type_parameter(:T)))
+    end
+    def start_local(
+      namespace: T.unsafe(nil),
+      data_converter: T.unsafe(nil),
+      interceptors: T.unsafe(nil),
+      logger: T.unsafe(nil),
+      default_workflow_query_reject_condition: T.unsafe(nil),
+      ip: T.unsafe(nil),
+      port: T.unsafe(nil),
+      ui: T.unsafe(nil),
+      ui_port: T.unsafe(nil),
+      search_attributes: T.unsafe(nil),
+      runtime: T.unsafe(nil),
+      dev_server_existing_path: T.unsafe(nil),
+      dev_server_database_filename: T.unsafe(nil),
+      dev_server_log_format: T.unsafe(nil),
+      dev_server_log_level: T.unsafe(nil),
+      dev_server_download_version: T.unsafe(nil),
+      dev_server_download_dest_dir: T.unsafe(nil),
+      dev_server_extra_args: T.unsafe(nil),
+      dev_server_download_ttl: T.unsafe(nil),
+      &block
+    ); end
+
+    sig do
+      type_parameters(:T)
+        .params(
+          data_converter: Temporalio::Converters::DataConverter,
+          interceptors: T::Array[Temporalio::Client::Interceptor],
+          logger: Logger,
+          default_workflow_query_reject_condition: T.nilable(Integer),
+          port: T.nilable(Integer),
+          runtime: Temporalio::Runtime,
+          test_server_existing_path: T.nilable(String),
+          test_server_download_version: String,
+          test_server_download_dest_dir: T.nilable(String),
+          test_server_extra_args: T::Array[String],
+          test_server_download_ttl: T.nilable(Float),
+          block: T.nilable(T.proc.params(arg0: Temporalio::Testing::WorkflowEnvironment).returns(T.type_parameter(:T)))
+        ).returns(T.any(Temporalio::Testing::WorkflowEnvironment, T.type_parameter(:T)))
+    end
+    def start_time_skipping(
+      data_converter: T.unsafe(nil),
+      interceptors: T.unsafe(nil),
+      logger: T.unsafe(nil),
+      default_workflow_query_reject_condition: T.unsafe(nil),
+      port: T.unsafe(nil),
+      runtime: T.unsafe(nil),
+      test_server_existing_path: T.unsafe(nil),
+      test_server_download_version: T.unsafe(nil),
+      test_server_download_dest_dir: T.unsafe(nil),
+      test_server_extra_args: T.unsafe(nil),
+      test_server_download_ttl: T.unsafe(nil),
+      &block
+    ); end
+  end
+end

data/rbi/temporalio/testing.rbi

@@ -0,0 +1,3 @@
+# typed: true
+
+module Temporalio::Testing; end

data/rbi/temporalio/version.rbi

@@ -0,0 +1,5 @@
+# typed: true
+
+module Temporalio
+  VERSION = T.let(T.unsafe(nil), String)
+end

data/rbi/temporalio/versioning_override.rbi

@@ -0,0 +1,13 @@
+# typed: true
+
+class Temporalio::VersioningOverride; end
+
+class Temporalio::VersioningOverride::Pinned < ::Temporalio::VersioningOverride
+  sig { params(version: Temporalio::WorkerDeploymentVersion).void }
+  def initialize(version); end
+
+  sig { returns(Temporalio::WorkerDeploymentVersion) }
+  attr_reader :version
+end
+
+class Temporalio::VersioningOverride::AutoUpgrade < ::Temporalio::VersioningOverride; end

data/rbi/temporalio/worker/activity_executor/fiber.rbi

@@ -0,0 +1,20 @@
+# typed: true
+
+class Temporalio::Worker::ActivityExecutor::Fiber < Temporalio::Worker::ActivityExecutor
+  extend T::Sig
+
+  sig { returns(Temporalio::Worker::ActivityExecutor::Fiber) }
+  def self.default; end
+
+  sig { params(defn: Temporalio::Activity::Definition::Info).void }
+  def initialize_activity(defn); end
+
+  sig { params(defn: Temporalio::Activity::Definition::Info, block: T.proc.void).void }
+  def execute_activity(defn, &block); end
+
+  sig { returns(T.nilable(Temporalio::Activity::Context)) }
+  def activity_context; end
+
+  sig { params(defn: Temporalio::Activity::Definition::Info, context: T.nilable(Temporalio::Activity::Context)).void }
+  def set_activity_context(defn, context); end
+end

data/rbi/temporalio/worker/activity_executor/thread_pool.rbi

@@ -0,0 +1,20 @@
+# typed: true
+
+class Temporalio::Worker::ActivityExecutor::ThreadPool < ::Temporalio::Worker::ActivityExecutor
+  extend T::Sig
+
+  sig { returns(Temporalio::Worker::ActivityExecutor::ThreadPool) }
+  def self.default; end
+
+  sig { params(thread_pool: Temporalio::Worker::ThreadPool).void }
+  def initialize(thread_pool = T.unsafe(nil)); end
+
+  sig { params(defn: Temporalio::Activity::Definition::Info, block: T.proc.void).void }
+  def execute_activity(defn, &block); end
+
+  sig { returns(T.nilable(Temporalio::Activity::Context)) }
+  def activity_context; end
+
+  sig { params(defn: Temporalio::Activity::Definition::Info, context: T.nilable(Temporalio::Activity::Context)).void }
+  def set_activity_context(defn, context); end
+end

data/rbi/temporalio/worker/activity_executor.rbi

@@ -0,0 +1,20 @@
+# typed: true
+
+class Temporalio::Worker::ActivityExecutor
+  extend T::Sig
+
+  sig { returns(T::Hash[Symbol, Temporalio::Worker::ActivityExecutor]) }
+  def self.defaults; end
+
+  sig { params(defn: Temporalio::Activity::Definition::Info).void }
+  def initialize_activity(defn); end
+
+  sig { params(defn: Temporalio::Activity::Definition::Info, block: T.proc.void).void }
+  def execute_activity(defn, &block); end
+
+  sig { returns(T.nilable(Temporalio::Activity::Context)) }
+  def activity_context; end
+
+  sig { params(defn: Temporalio::Activity::Definition::Info, context: T.nilable(Temporalio::Activity::Context)).void }
+  def set_activity_context(defn, context); end
+end

data/rbi/temporalio/worker/deployment_options.rbi

@@ -0,0 +1,23 @@
+# typed: true
+
+class Temporalio::Worker::DeploymentOptions < ::Data
+  extend T::Sig
+
+  sig { returns(Temporalio::WorkerDeploymentVersion) }
+  def version; end
+
+  sig { returns(T::Boolean) }
+  def use_worker_versioning; end
+
+  sig { returns(Integer) }
+  def default_versioning_behavior; end
+
+  sig do
+    params(
+      version: Temporalio::WorkerDeploymentVersion,
+      use_worker_versioning: T::Boolean,
+      default_versioning_behavior: Integer
+    ).void
+  end
+  def initialize(version:, use_worker_versioning: T.unsafe(nil), default_versioning_behavior: T.unsafe(nil)); end
+end

data/rbi/temporalio/worker/illegal_workflow_call_validator.rbi

@@ -0,0 +1,33 @@
+# typed: true
+
+class Temporalio::Worker::IllegalWorkflowCallValidator
+  extend T::Sig
+
+  sig { returns(T.nilable(Symbol)) }
+  attr_reader :method_name
+
+  sig { returns(T.proc.params(arg0: Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo).void) }
+  attr_reader :block
+
+  sig { params(method_name: T.nilable(Symbol), block: T.proc.params(arg0: Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo).void).void }
+  def initialize(method_name: T.unsafe(nil), &block); end
+
+  sig { returns(T::Array[Temporalio::Worker::IllegalWorkflowCallValidator]) }
+  def self.default_time_validators; end
+
+  sig { returns(Temporalio::Worker::IllegalWorkflowCallValidator) }
+  def self.known_safe_mutex_validator; end
+end
+
+class Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo < ::Data
+  extend T::Sig
+
+  sig { returns(String) }
+  def class_name; end
+
+  sig { returns(Symbol) }
+  def method_name; end
+
+  sig { returns(TracePoint) }
+  def trace_point; end
+end