temporalio 1.5.0 → 1.6.0

data/rbi/temporalio/internal/bridge/runtime.rbi

@@ -0,0 +1,231 @@
+# typed: true
+
+class Temporalio::Internal::Bridge::Runtime
+  extend T::Sig
+
+  sig { params(options: Temporalio::Internal::Bridge::Runtime::Options).returns(Temporalio::Internal::Bridge::Runtime) }
+  def self.new(options); end
+
+  sig { void }
+  def run_command_loop; end
+
+  sig { params(durations_as_seconds: T::Boolean).returns(T::Array[Temporalio::Runtime::MetricBuffer::Update]) }
+  def retrieve_buffered_metrics(durations_as_seconds); end
+end
+
+class Temporalio::Internal::Bridge::Runtime::Options < ::Struct
+  extend T::Sig
+
+  sig do
+    params(
+      telemetry: Temporalio::Internal::Bridge::Runtime::TelemetryOptions,
+      worker_heartbeat_interval: T.nilable(T.any(Integer, Float))
+    ).void
+  end
+  def initialize(telemetry, worker_heartbeat_interval); end
+
+  sig { returns(Temporalio::Internal::Bridge::Runtime::TelemetryOptions) }
+  def telemetry; end
+
+  sig { params(_: Temporalio::Internal::Bridge::Runtime::TelemetryOptions).void }
+  def telemetry=(_); end
+
+  sig { returns(T.nilable(T.any(Integer, Float))) }
+  def worker_heartbeat_interval; end
+
+  sig { params(_: T.nilable(T.any(Integer, Float))).void }
+  def worker_heartbeat_interval=(_); end
+end
+
+class Temporalio::Internal::Bridge::Runtime::TelemetryOptions < ::Struct
+  extend T::Sig
+
+  sig do
+    params(
+      logging: T.nilable(Temporalio::Internal::Bridge::Runtime::LoggingOptions),
+      metrics: T.nilable(Temporalio::Internal::Bridge::Runtime::MetricsOptions)
+    ).void
+  end
+  def initialize(logging, metrics); end
+
+  sig { returns(T.nilable(Temporalio::Internal::Bridge::Runtime::LoggingOptions)) }
+  def logging; end
+
+  sig { params(_: T.nilable(Temporalio::Internal::Bridge::Runtime::LoggingOptions)).void }
+  def logging=(_); end
+
+  sig { returns(T.nilable(Temporalio::Internal::Bridge::Runtime::MetricsOptions)) }
+  def metrics; end
+
+  sig { params(_: T.nilable(Temporalio::Internal::Bridge::Runtime::MetricsOptions)).void }
+  def metrics=(_); end
+end
+
+class Temporalio::Internal::Bridge::Runtime::LoggingOptions < ::Struct
+  extend T::Sig
+
+  sig { params(log_filter: T.nilable(String)).void }
+  def initialize(log_filter); end
+
+  sig { returns(T.nilable(String)) }
+  def log_filter; end
+
+  sig { params(_: T.nilable(String)).void }
+  def log_filter=(_); end
+end
+
+class Temporalio::Internal::Bridge::Runtime::MetricsOptions < ::Struct
+  extend T::Sig
+
+  sig do
+    params(
+      opentelemetry: T.nilable(Temporalio::Internal::Bridge::Runtime::OpenTelemetryMetricsOptions),
+      prometheus: T.nilable(Temporalio::Internal::Bridge::Runtime::PrometheusMetricsOptions),
+      buffered_with_size: T.nilable(Integer),
+      attach_service_name: T::Boolean,
+      global_tags: T.nilable(T::Hash[String, String]),
+      metric_prefix: T.nilable(String)
+    ).void
+  end
+  def initialize(opentelemetry, prometheus, buffered_with_size, attach_service_name, global_tags, metric_prefix); end
+
+  sig { returns(T.nilable(Temporalio::Internal::Bridge::Runtime::OpenTelemetryMetricsOptions)) }
+  def opentelemetry; end
+
+  sig { params(_: T.nilable(Temporalio::Internal::Bridge::Runtime::OpenTelemetryMetricsOptions)).void }
+  def opentelemetry=(_); end
+
+  sig { returns(T.nilable(Temporalio::Internal::Bridge::Runtime::PrometheusMetricsOptions)) }
+  def prometheus; end
+
+  sig { params(_: T.nilable(Temporalio::Internal::Bridge::Runtime::PrometheusMetricsOptions)).void }
+  def prometheus=(_); end
+
+  sig { returns(T.nilable(Integer)) }
+  def buffered_with_size; end
+
+  sig { params(_: T.nilable(Integer)).void }
+  def buffered_with_size=(_); end
+
+  sig { returns(T::Boolean) }
+  def attach_service_name; end
+
+  sig { params(_: T::Boolean).void }
+  def attach_service_name=(_); end
+
+  sig { returns(T.nilable(T::Hash[String, String])) }
+  def global_tags; end
+
+  sig { params(_: T.nilable(T::Hash[String, String])).void }
+  def global_tags=(_); end
+
+  sig { returns(T.nilable(String)) }
+  def metric_prefix; end
+
+  sig { params(_: T.nilable(String)).void }
+  def metric_prefix=(_); end
+end
+
+class Temporalio::Internal::Bridge::Runtime::OpenTelemetryMetricsOptions < ::Struct
+  extend T::Sig
+
+  sig do
+    params(
+      url: String,
+      headers: T.nilable(T::Hash[String, String]),
+      metric_periodicity: T.nilable(T.any(Integer, Float)),
+      metric_temporality_delta: T::Boolean,
+      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, metric_periodicity, metric_temporality_delta, durations_as_seconds, http, histogram_bucket_overrides); end
+
+  sig { returns(String) }
+  def url; end
+
+  sig { params(_: String).void }
+  def url=(_); end
+
+  sig { returns(T.nilable(T::Hash[String, String])) }
+  def headers; end
+
+  sig { params(_: T.nilable(T::Hash[String, String])).void }
+  def headers=(_); end
+
+  sig { returns(T.nilable(T.any(Integer, Float))) }
+  def metric_periodicity; end
+
+  sig { params(_: T.nilable(T.any(Integer, Float))).void }
+  def metric_periodicity=(_); end
+
+  sig { returns(T::Boolean) }
+  def metric_temporality_delta; end
+
+  sig { params(_: T::Boolean).void }
+  def metric_temporality_delta=(_); end
+
+  sig { returns(T::Boolean) }
+  def durations_as_seconds; end
+
+  sig { params(_: T::Boolean).void }
+  def durations_as_seconds=(_); end
+
+  sig { returns(T::Boolean) }
+  def http; end
+
+  sig { params(_: T::Boolean).void }
+  def http=(_); end
+
+  sig { returns(T.nilable(T::Hash[String, T::Array[Numeric]])) }
+  def histogram_bucket_overrides; end
+
+  sig { params(_: T.nilable(T::Hash[String, T::Array[Numeric]])).void }
+  def histogram_bucket_overrides=(_); end
+end
+
+class Temporalio::Internal::Bridge::Runtime::PrometheusMetricsOptions < ::Struct
+  extend T::Sig
+
+  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, unit_suffix, durations_as_seconds, histogram_bucket_overrides); end
+
+  sig { returns(String) }
+  def bind_address; end
+
+  sig { params(_: String).void }
+  def bind_address=(_); end
+
+  sig { returns(T::Boolean) }
+  def counters_total_suffix; end
+
+  sig { params(_: T::Boolean).void }
+  def counters_total_suffix=(_); end
+
+  sig { returns(T::Boolean) }
+  def unit_suffix; end
+
+  sig { params(_: T::Boolean).void }
+  def unit_suffix=(_); end
+
+  sig { returns(T::Boolean) }
+  def durations_as_seconds; end
+
+  sig { params(_: T::Boolean).void }
+  def durations_as_seconds=(_); end
+
+  sig { returns(T.nilable(T::Hash[String, T::Array[Numeric]])) }
+  def histogram_bucket_overrides; end
+
+  sig { params(_: T.nilable(T::Hash[String, T::Array[Numeric]])).void }
+  def histogram_bucket_overrides=(_); end
+end

data/rbi/temporalio/internal/bridge/testing.rbi

@@ -0,0 +1,109 @@
+# typed: true
+
+module Temporalio::Internal::Bridge::Testing; end
+
+class Temporalio::Internal::Bridge::Testing::EphemeralServer
+  extend T::Sig
+
+  sig do
+    params(
+      runtime: Temporalio::Internal::Bridge::Runtime,
+      options: Temporalio::Internal::Bridge::Testing::EphemeralServer::StartDevServerOptions
+    ).returns(Temporalio::Internal::Bridge::Testing::EphemeralServer)
+  end
+  def self.start_dev_server(runtime, options); end
+
+  sig do
+    params(
+      runtime: Temporalio::Internal::Bridge::Runtime,
+      options: Temporalio::Internal::Bridge::Testing::EphemeralServer::StartTestServerOptions
+    ).returns(Temporalio::Internal::Bridge::Testing::EphemeralServer)
+  end
+  def self.start_test_server(runtime, options); end
+
+  sig { void }
+  def shutdown; end
+
+  sig do
+    params(
+      runtime: Temporalio::Internal::Bridge::Runtime,
+      options: Temporalio::Internal::Bridge::Testing::EphemeralServer::StartDevServerOptions,
+      queue: Queue
+    ).void
+  end
+  def self.async_start_dev_server(runtime, options, queue); end
+
+  sig do
+    params(
+      runtime: Temporalio::Internal::Bridge::Runtime,
+      options: Temporalio::Internal::Bridge::Testing::EphemeralServer::StartTestServerOptions,
+      queue: Queue
+    ).void
+  end
+  def self.async_start_test_server(runtime, options, queue); end
+
+  sig { returns(String) }
+  def target; end
+
+  sig { params(queue: Queue).void }
+  def async_shutdown(queue); end
+end
+
+class Temporalio::Internal::Bridge::Testing::EphemeralServer::StartDevServerOptions < ::Struct
+  extend T::Sig
+
+  sig do
+    params(
+      existing_path: T.nilable(String),
+      sdk_name: String,
+      sdk_version: String,
+      download_version: String,
+      download_dest_dir: T.nilable(String),
+      namespace: String,
+      ip: String,
+      port: T.nilable(Integer),
+      database_filename: T.nilable(String),
+      ui: T::Boolean,
+      ui_port: T.nilable(Integer),
+      log_format: String,
+      log_level: String,
+      extra_args: T::Array[String],
+      download_ttl: T.nilable(T.any(Integer, Float))
+    ).void
+  end
+  def initialize(
+    existing_path,
+    sdk_name,
+    sdk_version,
+    download_version,
+    download_dest_dir,
+    namespace,
+    ip,
+    port,
+    database_filename,
+    ui,
+    ui_port,
+    log_format,
+    log_level,
+    extra_args,
+    download_ttl
+  ); end
+end
+
+class Temporalio::Internal::Bridge::Testing::EphemeralServer::StartTestServerOptions < ::Struct
+  extend T::Sig
+
+  sig do
+    params(
+      existing_path: T.nilable(String),
+      sdk_name: String,
+      sdk_version: String,
+      download_version: String,
+      download_dest_dir: T.nilable(String),
+      port: T.nilable(Integer),
+      extra_args: T::Array[String],
+      download_ttl: T.nilable(T.any(Integer, Float))
+    ).void
+  end
+  def initialize(existing_path, sdk_name, sdk_version, download_version, download_dest_dir, port, extra_args, download_ttl); end
+end

data/rbi/temporalio/internal/bridge/worker.rbi

@@ -0,0 +1,250 @@
+# typed: true
+
+class Temporalio::Internal::Bridge::Worker
+  extend T::Sig
+
+  sig { params(workers: T::Array[Temporalio::Internal::Bridge::Worker]).void }
+  def self.finalize_shutdown_all(workers); end
+
+  sig { void }
+  def validate; end
+
+  sig { params(proto: Object).void }
+  def complete_activity_task(proto); end
+
+  sig { params(proto: Object).void }
+  def complete_activity_task_in_background(proto); end
+
+  sig do
+    params(
+      client: Temporalio::Internal::Bridge::Client,
+      options: Temporalio::Internal::Bridge::Worker::Options
+    ).returns(Temporalio::Internal::Bridge::Worker)
+  end
+  def self.new(client, options); end
+
+  sig { params(workers: T::Array[Temporalio::Internal::Bridge::Worker], queue: Queue).void }
+  def self.async_poll_all(workers, queue); end
+
+  sig { params(workers: T::Array[Temporalio::Internal::Bridge::Worker], queue: Queue).void }
+  def self.async_finalize_all(workers, queue); end
+
+  sig { params(queue: Queue).void }
+  def async_validate(queue); end
+
+  sig { params(proto: String, queue: Queue).void }
+  def async_complete_activity_task(proto, queue); end
+
+  sig { params(run_id: String, proto: String, queue: Queue).void }
+  def async_complete_workflow_activation(run_id, proto, queue); end
+
+  sig { params(proto: String).void }
+  def record_activity_heartbeat(proto); end
+
+  sig { params(client: Temporalio::Internal::Bridge::Client).void }
+  def replace_client(client); end
+
+  sig { void }
+  def initiate_shutdown; end
+end
+
+class Temporalio::Internal::Bridge::Worker::Options < ::Struct
+  extend T::Sig
+
+  sig do
+    params(
+      namespace: String,
+      task_queue: String,
+      tuner: Temporalio::Internal::Bridge::Worker::TunerOptions,
+      identity_override: T.nilable(String),
+      max_cached_workflows: Integer,
+      workflow_task_poller_behavior: T.any(
+        Temporalio::Internal::Bridge::Worker::PollerBehaviorSimpleMaximum,
+        Temporalio::Internal::Bridge::Worker::PollerBehaviorAutoscaling
+      ),
+      nonsticky_to_sticky_poll_ratio: T.any(Integer, Float),
+      activity_task_poller_behavior: T.any(
+        Temporalio::Internal::Bridge::Worker::PollerBehaviorSimpleMaximum,
+        Temporalio::Internal::Bridge::Worker::PollerBehaviorAutoscaling
+      ),
+      enable_workflows: T::Boolean,
+      enable_local_activities: T::Boolean,
+      enable_remote_activities: T::Boolean,
+      enable_nexus: T::Boolean,
+      sticky_queue_schedule_to_start_timeout: T.any(Integer, Float),
+      max_heartbeat_throttle_interval: T.any(Integer, Float),
+      default_heartbeat_throttle_interval: T.any(Integer, Float),
+      max_worker_activities_per_second: T.nilable(T.any(Integer, Float)),
+      max_task_queue_activities_per_second: T.nilable(T.any(Integer, Float)),
+      graceful_shutdown_period: T.any(Integer, Float),
+      nondeterminism_as_workflow_fail: T::Boolean,
+      nondeterminism_as_workflow_fail_for_types: T::Array[String],
+      deployment_options: T.nilable(Temporalio::Internal::Bridge::Worker::DeploymentOptions),
+      plugins: T::Array[String]
+    ).void
+  end
+  def initialize(
+    namespace,
+    task_queue,
+    tuner,
+    identity_override,
+    max_cached_workflows,
+    workflow_task_poller_behavior,
+    nonsticky_to_sticky_poll_ratio,
+    activity_task_poller_behavior,
+    enable_workflows,
+    enable_local_activities,
+    enable_remote_activities,
+    enable_nexus,
+    sticky_queue_schedule_to_start_timeout,
+    max_heartbeat_throttle_interval,
+    default_heartbeat_throttle_interval,
+    max_worker_activities_per_second,
+    max_task_queue_activities_per_second,
+    graceful_shutdown_period,
+    nondeterminism_as_workflow_fail,
+    nondeterminism_as_workflow_fail_for_types,
+    deployment_options,
+    plugins
+  ); end
+end
+
+class Temporalio::Internal::Bridge::Worker::TunerOptions < ::Struct
+  extend T::Sig
+
+  sig do
+    params(
+      workflow_slot_supplier: Temporalio::Internal::Bridge::Worker::TunerSlotSupplierOptions,
+      activity_slot_supplier: Temporalio::Internal::Bridge::Worker::TunerSlotSupplierOptions,
+      local_activity_slot_supplier: Temporalio::Internal::Bridge::Worker::TunerSlotSupplierOptions
+    ).void
+  end
+  def initialize(workflow_slot_supplier, activity_slot_supplier, local_activity_slot_supplier); end
+end
+
+class Temporalio::Internal::Bridge::Worker::TunerSlotSupplierOptions < ::Struct
+  extend T::Sig
+
+  sig do
+    params(
+      fixed_size: T.nilable(Integer),
+      resource_based: T.nilable(Temporalio::Internal::Bridge::Worker::TunerResourceBasedSlotSupplierOptions),
+      custom: T.nilable(Temporalio::Internal::Bridge::Worker::CustomSlotSupplier)
+    ).void
+  end
+  def initialize(fixed_size, resource_based, custom); end
+end
+
+class Temporalio::Internal::Bridge::Worker::TunerResourceBasedSlotSupplierOptions < ::Struct
+  extend T::Sig
+
+  sig do
+    params(
+      target_mem_usage: T.any(Integer, Float),
+      target_cpu_usage: T.any(Integer, Float),
+      min_slots: T.nilable(Integer),
+      max_slots: T.nilable(Integer),
+      ramp_throttle: T.nilable(T.any(Integer, Float))
+    ).void
+  end
+  def initialize(target_mem_usage, target_cpu_usage, min_slots, max_slots, ramp_throttle); end
+end
+
+class Temporalio::Internal::Bridge::Worker::CustomSlotSupplier
+  extend T::Sig
+
+  sig do
+    params(
+      slot_supplier: Temporalio::Worker::Tuner::SlotSupplier::Custom,
+      thread_pool: T.nilable(Temporalio::Worker::ThreadPool)
+    ).void
+  end
+  def initialize(slot_supplier:, thread_pool:); end
+
+  sig do
+    params(
+      context: Temporalio::Worker::Tuner::SlotSupplier::Custom::ReserveContext,
+      cancellation: Temporalio::Cancellation,
+      block: T.proc.params(arg0: Object).void
+    ).void
+  end
+  def reserve_slot(context, cancellation, &block); end
+
+  sig do
+    params(
+      context: Temporalio::Worker::Tuner::SlotSupplier::Custom::ReserveContext,
+      block: T.proc.params(arg0: Object).void
+    ).void
+  end
+  def try_reserve_slot(context, &block); end
+
+  sig do
+    params(
+      context: Temporalio::Worker::Tuner::SlotSupplier::Custom::MarkUsedContext,
+      block: T.proc.params(arg0: Object).void
+    ).void
+  end
+  def mark_slot_used(context, &block); end
+
+  sig do
+    params(
+      context: Temporalio::Worker::Tuner::SlotSupplier::Custom::ReleaseContext,
+      block: T.proc.params(arg0: Object).void
+    ).void
+  end
+  def release_slot(context, &block); end
+
+  private
+
+  sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+  def run_user_code(&block); end
+end
+
+class Temporalio::Internal::Bridge::Worker::WorkerDeploymentVersion < ::Struct
+  extend T::Sig
+
+  sig { params(deployment_name: String, build_id: String).void }
+  def initialize(deployment_name, build_id); end
+end
+
+class Temporalio::Internal::Bridge::Worker::DeploymentOptions < ::Struct
+  extend T::Sig
+
+  sig do
+    params(
+      version: Temporalio::Internal::Bridge::Worker::WorkerDeploymentVersion,
+      use_worker_versioning: T::Boolean,
+      default_versioning_behavior: Integer
+    ).void
+  end
+  def initialize(version, use_worker_versioning, default_versioning_behavior); end
+end
+
+class Temporalio::Internal::Bridge::Worker::PollerBehaviorSimpleMaximum < ::Struct
+  extend T::Sig
+
+  sig { params(simple_maximum: Integer).void }
+  def initialize(simple_maximum); end
+end
+
+class Temporalio::Internal::Bridge::Worker::PollerBehaviorAutoscaling < ::Struct
+  extend T::Sig
+
+  sig { params(minimum: Integer, maximum: Integer, initial: Integer).void }
+  def initialize(minimum, maximum, initial); end
+end
+
+class Temporalio::Internal::Bridge::Worker::WorkflowReplayer
+  extend T::Sig
+
+  sig do
+    params(
+      runtime: Temporalio::Internal::Bridge::Runtime,
+      options: Temporalio::Internal::Bridge::Worker::Options
+    ).returns([Temporalio::Internal::Bridge::Worker::WorkflowReplayer, Temporalio::Internal::Bridge::Worker])
+  end
+  def self.new(runtime, options); end
+
+  sig { params(workflow_id: String, proto: String).void }
+  def push_history(workflow_id, proto); end
+end

data/rbi/temporalio/internal/bridge.rbi

@@ -0,0 +1,47 @@
+# typed: true
+
+module Temporalio::Internal::Bridge
+  extend T::Sig
+
+  FIPS = T.let(T.unsafe(nil), T::Boolean)
+
+  sig { void }
+  def self.assert_fiber_compatibility!; end
+
+  sig { void }
+  def self.assert_fips_compatibility!; end
+
+  sig { returns(T::Boolean) }
+  def self.fibers_supported; end
+end
+
+module Temporalio::Internal::Bridge::EnvConfig
+  extend T::Sig
+
+  sig do
+    params(
+      profile: T.nilable(String),
+      path: T.nilable(String),
+      data: T.nilable(String),
+      disable_file: T::Boolean,
+      disable_env: T::Boolean,
+      config_file_strict: T::Boolean,
+      override_env_vars: T.nilable(T::Hash[String, String])
+    ).returns(T::Hash[Symbol, T.nilable(Object)])
+  end
+  def self.load_client_connect_config(profile, path, data, disable_file, disable_env, config_file_strict,
+                                      override_env_vars); end
+
+  sig do
+    params(
+      path: T.nilable(String),
+      data: T.nilable(String),
+      config_file_strict: T::Boolean,
+      override_env_vars: T.nilable(T::Hash[String, String])
+    ).returns(T::Hash[String, T::Hash[Symbol, T.nilable(Object)]])
+  end
+  def self.load_client_config(path, data, config_file_strict, override_env_vars); end
+end
+
+class Temporalio::Internal::Bridge::Error < StandardError
+end

data/rbi/temporalio/internal/client/implementation.rbi

@@ -0,0 +1,53 @@
+# typed: true
+
+class Temporalio::Internal::Client::Implementation < Temporalio::Client::Interceptor::Outbound
+  extend T::Sig
+
+  STANDALONE_ACTIVITY_RESOURCE_ID_PREFIX = T.let(T.unsafe(nil), String)
+
+  sig do
+    params(
+      ref: Temporalio::Client::ActivityIDReference
+    ).returns(T::Hash[Symbol, T.nilable(String)])
+  end
+  def self._activity_id_reference_request_fields(ref); end
+
+  sig do
+    params(
+      user_rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(Temporalio::Client::RPCOptions)
+  end
+  def self.with_default_rpc_options(user_rpc_options); end
+
+  sig { params(client: Temporalio::Client).void }
+  def initialize(client); end
+
+  sig do
+    params(
+      klass: Class,
+      start_options: Temporalio::Client::WithStartWorkflowOperation::Options
+    ).returns(Object)
+  end
+  def _start_workflow_request_from_with_start_options(klass, start_options); end
+
+  sig { params(input: Temporalio::Client::Interceptor::StartActivityInput).returns(Temporalio::Client::ActivityHandle) }
+  def start_activity(input); end
+
+  sig { params(input: Temporalio::Client::Interceptor::DescribeActivityInput).returns(Temporalio::Client::ActivityExecution::Description) }
+  def describe_activity(input); end
+
+  sig { params(input: Temporalio::Client::Interceptor::CancelActivityInput).void }
+  def cancel_activity(input); end
+
+  sig { params(input: Temporalio::Client::Interceptor::TerminateActivityInput).void }
+  def terminate_activity(input); end
+
+  sig { params(input: Temporalio::Client::Interceptor::ListActivitiesInput).returns(T::Enumerator[Temporalio::Client::ActivityExecution]) }
+  def list_activities(input); end
+
+  sig { params(input: Temporalio::Client::Interceptor::CountActivitiesInput).returns(Temporalio::Client::ActivityExecutionCount) }
+  def count_activities(input); end
+
+  sig { params(input: Temporalio::Client::Interceptor::FetchActivityOutcomeInput).returns(T.nilable(Temporalio::Api::Activity::V1::ActivityExecutionOutcome)) }
+  def fetch_activity_outcome(input); end
+end

data/rbi/temporalio/internal/google_protobuf.rbi

@@ -0,0 +1,8 @@
+# typed: true
+
+module Temporalio::Internal::GoogleProtobuf
+  extend T::Sig
+
+  sig { params(locations: T.nilable(T::Array[Thread::Backtrace::Location])).returns(T::Boolean) }
+  def self.in_call_stack?(locations); end
+end