temporalio 1.5.0 → 1.6.0

data/rbi/temporalio/internal/metric.rbi

@@ -0,0 +1,55 @@
+# typed: true
+
+class Temporalio::Internal::Metric < Temporalio::Metric
+  extend T::Sig
+
+  sig do
+    params(
+      metric_type: Symbol,
+      name: String,
+      description: T.nilable(String),
+      unit: T.nilable(String),
+      value_type: Symbol,
+      bridge: Temporalio::Internal::Bridge::Metric,
+      bridge_attrs: Temporalio::Internal::Bridge::Metric::Attributes
+    ).void
+  end
+  def initialize(metric_type:, name:, description:, unit:, value_type:, bridge:, bridge_attrs:); end
+end
+
+class Temporalio::Internal::Metric::Meter < Temporalio::Metric::Meter
+  extend T::Sig
+
+  sig { params(runtime: Temporalio::Runtime).returns(T.nilable(Temporalio::Internal::Metric::Meter)) }
+  def self.create_from_runtime(runtime); end
+
+  sig do
+    params(
+      bridge: Temporalio::Internal::Bridge::Metric::Meter,
+      bridge_attrs: Temporalio::Internal::Bridge::Metric::Attributes
+    ).void
+  end
+  def initialize(bridge, bridge_attrs); end
+end
+
+class Temporalio::Internal::Metric::NullMeter < Temporalio::Metric::Meter
+  extend T::Sig
+
+  sig { returns(Temporalio::Internal::Metric::NullMeter) }
+  def self.instance; end
+end
+
+class Temporalio::Internal::Metric::NullMetric < Temporalio::Metric
+  extend T::Sig
+
+  sig do
+    params(
+      metric_type: Symbol,
+      name: String,
+      description: T.nilable(String),
+      unit: T.nilable(String),
+      value_type: Symbol
+    ).void
+  end
+  def initialize(metric_type:, name:, description:, unit:, value_type:); end
+end

data/rbi/temporalio/internal/proto_utils.rbi

@@ -0,0 +1,148 @@
+# typed: true
+
+module Temporalio::Internal::ProtoUtils
+  extend T::Sig
+
+  sig { params(seconds_numeric: T.nilable(T.any(Integer, Float))).returns(T.nilable(Google::Protobuf::Duration)) }
+  def self.seconds_to_duration(seconds_numeric); end
+
+  sig { params(duration: T.nilable(Google::Protobuf::Duration)).returns(T.nilable(Float)) }
+  def self.duration_to_seconds(duration); end
+
+  sig { params(time: T.nilable(Time)).returns(T.nilable(Google::Protobuf::Timestamp)) }
+  def self.time_to_timestamp(time); end
+
+  sig { params(timestamp: T.nilable(Google::Protobuf::Timestamp)).returns(T.nilable(Time)) }
+  def self.timestamp_to_time(timestamp); end
+
+  sig do
+    params(
+      hash: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]),
+      converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)
+    ).returns(T.nilable(Temporalio::Api::Common::V1::Memo))
+  end
+  def self.memo_to_proto(hash, converter); end
+
+  sig do
+    params(
+      hash: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]),
+      converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)
+    ).returns(T.nilable(T::Hash[String, Temporalio::Api::Common::V1::Payload]))
+  end
+  def self.memo_to_proto_hash(hash, converter); end
+
+  sig do
+    params(
+      memo: T.nilable(Temporalio::Api::Common::V1::Memo),
+      converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)
+    ).returns(T.nilable(T::Hash[String, T.nilable(Object)]))
+  end
+  def self.memo_from_proto(memo, converter); end
+
+  sig do
+    params(
+      headers: T.nilable(T::Hash[String, T.nilable(Object)]),
+      converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)
+    ).returns(T.nilable(Temporalio::Api::Common::V1::Header))
+  end
+  def self.headers_to_proto(headers, converter); end
+
+  sig do
+    params(
+      headers: T.nilable(T::Hash[String, T.nilable(Object)]),
+      converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)
+    ).returns(T.nilable(T::Hash[String, Temporalio::Api::Common::V1::Payload]))
+  end
+  def self.headers_to_proto_hash(headers, converter); end
+
+  sig do
+    params(
+      headers: T.nilable(Temporalio::Api::Common::V1::Header),
+      converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)
+    ).returns(T.nilable(T::Hash[String, T.nilable(Object)]))
+  end
+  def self.headers_from_proto(headers, converter); end
+
+  sig do
+    params(
+      headers: T.nilable(Google::Protobuf::Map),
+      converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)
+    ).returns(T.nilable(T::Hash[String, Temporalio::Api::Common::V1::Payload]))
+  end
+  def self.headers_from_proto_map(headers, converter); end
+
+  sig { params(str: T.nilable(String), default: T.nilable(String)).returns(T.nilable(String)) }
+  def self.string_or(str, default = nil); end
+
+  sig do
+    params(enum_mod: Module, enum_val: T.any(Symbol, Integer, Float), zero_means_nil: T::Boolean)
+      .returns(T.nilable(Integer))
+  end
+  def self.enum_to_int(enum_mod, enum_val, zero_means_nil: false); end
+
+  sig do
+    params(
+      converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter),
+      payloads: T::Array[Temporalio::Api::Common::V1::Payload],
+      hints: T.nilable(T::Array[Object])
+    ).returns(T::Array[T.nilable(Object)])
+  end
+  def self.convert_from_payload_array(converter, payloads, hints:); end
+
+  sig do
+    params(
+      converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter),
+      values: T::Array[T.nilable(Object)],
+      hints: T.nilable(T::Array[Object])
+    ).returns(T::Array[Temporalio::Api::Common::V1::Payload])
+  end
+  def self.convert_to_payload_array(converter, values, hints:); end
+
+  sig { params(name: T.nilable(T.any(String, Symbol))).void }
+  def self.assert_non_reserved_name(name); end
+
+  sig { params(name: T.nilable(T.any(String, Symbol))).returns(T::Boolean) }
+  def self.reserved_name?(name); end
+
+  sig do
+    params(
+      summary: T.nilable(String),
+      details: T.nilable(String),
+      converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)
+    ).returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata))
+  end
+  def self.to_user_metadata(summary, details, converter); end
+
+  sig do
+    params(
+      metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata),
+      converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)
+    ).returns(T::Array[T.nilable(String)])
+  end
+  def self.from_user_metadata(metadata, converter); end
+end
+
+class Temporalio::Internal::ProtoUtils::LazyMemo
+  extend T::Sig
+
+  sig do
+    params(
+      raw_memo: T.nilable(Temporalio::Api::Common::V1::Memo),
+      converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)
+    ).void
+  end
+  def initialize(raw_memo, converter); end
+
+  sig { returns(T.nilable(T::Hash[String, T.nilable(Object)])) }
+  def get; end
+end
+
+class Temporalio::Internal::ProtoUtils::LazySearchAttributes
+  extend T::Sig
+
+  sig { params(raw_search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void }
+  def initialize(raw_search_attributes); end
+
+  sig { returns(T.nilable(Temporalio::SearchAttributes)) }
+  def get; end
+end

data/rbi/temporalio/internal/worker/activity_worker.rbi

@@ -0,0 +1,108 @@
+# typed: true
+
+class Temporalio::Internal::Worker::ActivityWorker
+  extend T::Sig
+
+  LOG_TASKS = T.let(T.unsafe(nil), T::Boolean)
+
+  sig { returns(Temporalio::Worker) }
+  attr_reader :worker
+
+  sig { returns(Temporalio::Internal::Bridge::Worker) }
+  attr_reader :bridge_worker
+
+  sig { params(worker: Temporalio::Worker, bridge_worker: Temporalio::Internal::Bridge::Worker).void }
+  def initialize(worker:, bridge_worker:); end
+
+  sig do
+    params(
+      task_token: String,
+      activity: T.nilable(Temporalio::Internal::Worker::ActivityWorker::RunningActivity)
+    ).void
+  end
+  def set_running_activity(task_token, activity); end
+
+  sig { params(task_token: String).returns(T.nilable(Temporalio::Internal::Worker::ActivityWorker::RunningActivity)) }
+  def get_running_activity(task_token); end
+
+  sig { params(task_token: String).void }
+  def remove_running_activity(task_token); end
+
+  sig { void }
+  def wait_all_complete; end
+
+  sig { params(task: Object).void }
+  def handle_task(task); end
+
+  sig { params(task_token: String, start: Object).void }
+  def handle_start_task(task_token, start); end
+
+  sig { params(task_token: String, cancel: Object).void }
+  def handle_cancel_task(task_token, cancel); end
+
+  sig { params(task_token: String, defn: Temporalio::Activity::Definition::Info, start: Object).void }
+  def execute_activity(task_token, defn, start); end
+
+  sig do
+    params(
+      defn: Temporalio::Activity::Definition::Info,
+      activity: Temporalio::Internal::Worker::ActivityWorker::RunningActivity,
+      input: Temporalio::Worker::Interceptor::Activity::ExecuteInput
+    ).void
+  end
+  def run_activity(defn, activity, input); end
+
+  sig { params(activity: String).void }
+  def assert_valid_activity(activity); end
+end
+
+class Temporalio::Internal::Worker::ActivityWorker::RunningActivity < Temporalio::Activity::Context
+  extend T::Sig
+
+  sig { returns(T::Boolean) }
+  attr_reader :_server_requested_cancel
+
+  sig { returns(T.nilable(Temporalio::Activity::Definition)) }
+  attr_accessor :instance
+
+  sig { returns(T.nilable(Temporalio::Worker::Interceptor::Activity::Outbound)) }
+  attr_accessor :_outbound_impl
+
+  sig do
+    params(
+      worker: Temporalio::Worker,
+      info: Temporalio::Activity::Info,
+      cancellation: Temporalio::Cancellation,
+      worker_shutdown_cancellation: Temporalio::Cancellation,
+      payload_converter: Temporalio::Converters::PayloadConverter,
+      logger: Temporalio::ScopedLogger,
+      runtime_metric_meter: Temporalio::Metric::Meter
+    ).void
+  end
+  def initialize(
+    worker:,
+    info:,
+    cancellation:,
+    worker_shutdown_cancellation:,
+    payload_converter:,
+    logger:,
+    runtime_metric_meter:
+  ); end
+
+  sig { params(reason: String, details: Temporalio::Activity::CancellationDetails).void }
+  def _cancel(reason:, details:); end
+end
+
+class Temporalio::Internal::Worker::ActivityWorker::InboundImplementation < Temporalio::Worker::Interceptor::Activity::Inbound
+  extend T::Sig
+
+  sig { params(worker: Temporalio::Internal::Worker::ActivityWorker).void }
+  def initialize(worker); end
+end
+
+class Temporalio::Internal::Worker::ActivityWorker::OutboundImplementation < Temporalio::Worker::Interceptor::Activity::Outbound
+  extend T::Sig
+
+  sig { params(worker: Temporalio::Internal::Worker::ActivityWorker, task_token: String).void }
+  def initialize(worker, task_token); end
+end

data/rbi/temporalio/internal/worker/multi_runner.rbi

@@ -0,0 +1,175 @@
+# typed: true
+
+class Temporalio::Internal::Worker::MultiRunner
+  extend T::Sig
+
+  sig { params(workers: T::Array[Object], shutdown_signals: T::Array[T.any(String, Integer)]).void }
+  def initialize(workers:, shutdown_signals:); end
+
+  sig { params(block: T.nilable(T.proc.returns(Object))).void }
+  def apply_thread_or_fiber_block(&block); end
+
+  sig { params(workflow_worker: Temporalio::Internal::Worker::WorkflowWorker, activation: Object).void }
+  def apply_workflow_activation_decoded(workflow_worker:, activation:); end
+
+  sig do
+    params(
+      workflow_worker: Temporalio::Internal::Worker::WorkflowWorker,
+      activation_completion: Object,
+      encoded: T::Boolean
+    ).void
+  end
+  def apply_workflow_activation_complete(workflow_worker:, activation_completion:, encoded:); end
+
+  sig { params(error: Exception).void }
+  def raise_in_thread_or_fiber_block(error); end
+
+  sig { void }
+  def initiate_shutdown; end
+
+  sig { void }
+  def wait_complete_and_finalize_shutdown; end
+
+  sig { returns(Temporalio::Internal::Worker::MultiRunner::Event) }
+  def next_event; end
+end
+
+class Temporalio::Internal::Worker::MultiRunner::Event
+end
+
+class Temporalio::Internal::Worker::MultiRunner::Event::PollSuccess < Temporalio::Internal::Worker::MultiRunner::Event
+  extend T::Sig
+
+  sig { returns(Object) }
+  attr_reader :worker
+
+  sig { returns(Symbol) }
+  attr_reader :worker_type
+
+  sig { returns(String) }
+  attr_reader :bytes
+
+  sig { params(worker: Object, worker_type: Symbol, bytes: String).void }
+  def initialize(worker:, worker_type:, bytes:); end
+end
+
+class Temporalio::Internal::Worker::MultiRunner::Event::PollFailure < Temporalio::Internal::Worker::MultiRunner::Event
+  extend T::Sig
+
+  sig { returns(Object) }
+  attr_reader :worker
+
+  sig { returns(Symbol) }
+  attr_reader :worker_type
+
+  sig { returns(Exception) }
+  attr_reader :error
+
+  sig { params(worker: Object, worker_type: Symbol, error: Exception).void }
+  def initialize(worker:, worker_type:, error:); end
+end
+
+class Temporalio::Internal::Worker::MultiRunner::Event::WorkflowActivationDecoded < Temporalio::Internal::Worker::MultiRunner::Event
+  extend T::Sig
+
+  sig { returns(Temporalio::Internal::Worker::WorkflowWorker) }
+  attr_reader :workflow_worker
+
+  sig { returns(Object) }
+  attr_reader :activation
+
+  sig { params(workflow_worker: Temporalio::Internal::Worker::WorkflowWorker, activation: Object).void }
+  def initialize(workflow_worker:, activation:); end
+end
+
+class Temporalio::Internal::Worker::MultiRunner::Event::WorkflowActivationComplete < Temporalio::Internal::Worker::MultiRunner::Event
+  extend T::Sig
+
+  sig { returns(Temporalio::Internal::Worker::WorkflowWorker) }
+  attr_reader :workflow_worker
+
+  sig { returns(Object) }
+  attr_reader :activation_completion
+
+  sig { returns(T::Boolean) }
+  attr_reader :encoded
+
+  sig { returns(Queue) }
+  attr_reader :completion_complete_queue
+
+  sig do
+    params(
+      workflow_worker: Temporalio::Internal::Worker::WorkflowWorker,
+      activation_completion: Object,
+      encoded: T::Boolean,
+      completion_complete_queue: Queue
+    ).void
+  end
+  def initialize(workflow_worker:, activation_completion:, encoded:, completion_complete_queue:); end
+end
+
+class Temporalio::Internal::Worker::MultiRunner::Event::WorkflowActivationCompletionComplete < Temporalio::Internal::Worker::MultiRunner::Event
+  extend T::Sig
+
+  sig { returns(String) }
+  attr_reader :run_id
+
+  sig { returns(T.nilable(Exception)) }
+  attr_reader :error
+
+  sig { params(run_id: String, error: T.nilable(Exception)).void }
+  def initialize(run_id:, error:); end
+end
+
+class Temporalio::Internal::Worker::MultiRunner::Event::PollerShutDown < Temporalio::Internal::Worker::MultiRunner::Event
+  extend T::Sig
+
+  sig { returns(Object) }
+  attr_reader :worker
+
+  sig { returns(Symbol) }
+  attr_reader :worker_type
+
+  sig { params(worker: Object, worker_type: Symbol).void }
+  def initialize(worker:, worker_type:); end
+end
+
+class Temporalio::Internal::Worker::MultiRunner::Event::AllPollersShutDown < Temporalio::Internal::Worker::MultiRunner::Event
+  extend T::Sig
+
+  sig { returns(Temporalio::Internal::Worker::MultiRunner::Event::AllPollersShutDown) }
+  def self.instance; end
+end
+
+class Temporalio::Internal::Worker::MultiRunner::Event::BlockSuccess < Temporalio::Internal::Worker::MultiRunner::Event
+  extend T::Sig
+
+  sig { returns(T.nilable(Object)) }
+  attr_reader :result
+
+  sig { params(result: T.nilable(Object)).void }
+  def initialize(result:); end
+end
+
+class Temporalio::Internal::Worker::MultiRunner::Event::BlockFailure < Temporalio::Internal::Worker::MultiRunner::Event
+  extend T::Sig
+
+  sig { returns(Exception) }
+  attr_reader :error
+
+  sig { params(error: Exception).void }
+  def initialize(error:); end
+end
+
+class Temporalio::Internal::Worker::MultiRunner::Event::ShutdownSignalReceived < Temporalio::Internal::Worker::MultiRunner::Event
+end
+
+class Temporalio::Internal::Worker::MultiRunner::InjectEventForTesting < Temporalio::Error
+  extend T::Sig
+
+  sig { returns(Temporalio::Internal::Worker::MultiRunner::Event) }
+  attr_reader :event
+
+  sig { params(event: Temporalio::Internal::Worker::MultiRunner::Event).void }
+  def initialize(event); end
+end

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

@@ -0,0 +1,20 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance::ChildWorkflowHandle < Temporalio::Workflow::ChildWorkflowHandle
+  extend T::Sig
+
+  sig do
+    params(
+      id: String,
+      first_execution_run_id: String,
+      instance: Temporalio::Internal::Worker::WorkflowInstance,
+      cancellation: Temporalio::Cancellation,
+      cancel_callback_key: Object,
+      result_hint: T.nilable(Object)
+    ).void
+  end
+  def initialize(id:, first_execution_run_id:, instance:, cancellation:, cancel_callback_key:, result_hint:); end
+
+  sig { params(resolution: Temporalio::Internal::Bridge::Api::ChildWorkflow::ChildWorkflowResult).void }
+  def _resolve(resolution); end
+end