temporalio 1.5.0 → 1.6.0

data/rbi/temporalio/workflow.rbi

@@ -0,0 +1,393 @@
+# typed: true
+
+module Temporalio::Workflow
+  class << self
+    extend T::Sig
+
+    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(T.nilable(Temporalio::WorkerDeploymentVersion)) }
+    def current_deployment_version; end
+
+    sig { returns(Integer) }
+    def current_history_size; 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 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: T.unsafe(nil),
+      summary: T.unsafe(nil),
+      schedule_to_close_timeout: T.unsafe(nil),
+      schedule_to_start_timeout: T.unsafe(nil),
+      start_to_close_timeout: T.unsafe(nil),
+      heartbeat_timeout: T.unsafe(nil),
+      retry_policy: T.unsafe(nil),
+      cancellation: T.unsafe(nil),
+      cancellation_type: T.unsafe(nil),
+      activity_id: T.unsafe(nil),
+      disable_eager_execution: T.unsafe(nil),
+      priority: T.unsafe(nil),
+      arg_hints: T.unsafe(nil),
+      result_hint: T.unsafe(nil)
+    ); 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(T.nilable(Object))
+    end
+    def execute_child_workflow(
+      workflow,
+      *args,
+      id: T.unsafe(nil),
+      task_queue: T.unsafe(nil),
+      static_summary: T.unsafe(nil),
+      static_details: T.unsafe(nil),
+      cancellation: T.unsafe(nil),
+      cancellation_type: T.unsafe(nil),
+      parent_close_policy: T.unsafe(nil),
+      execution_timeout: T.unsafe(nil),
+      run_timeout: T.unsafe(nil),
+      task_timeout: T.unsafe(nil),
+      id_reuse_policy: T.unsafe(nil),
+      retry_policy: T.unsafe(nil),
+      cron_schedule: T.unsafe(nil),
+      memo: T.unsafe(nil),
+      search_attributes: T.unsafe(nil),
+      priority: T.unsafe(nil),
+      arg_hints: T.unsafe(nil),
+      result_hint: T.unsafe(nil)
+    ); 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: T.unsafe(nil),
+      schedule_to_close_timeout: T.unsafe(nil),
+      schedule_to_start_timeout: T.unsafe(nil),
+      start_to_close_timeout: T.unsafe(nil),
+      retry_policy: T.unsafe(nil),
+      local_retry_threshold: T.unsafe(nil),
+      cancellation: T.unsafe(nil),
+      cancellation_type: T.unsafe(nil),
+      activity_id: T.unsafe(nil),
+      arg_hints: T.unsafe(nil),
+      result_hint: T.unsafe(nil)
+    ); end
+
+    sig { params(workflow_id: String, run_id: T.nilable(String)).returns(Temporalio::Workflow::ExternalWorkflowHandle) }
+    def external_workflow_handle(workflow_id, run_id: T.unsafe(nil)); end
+
+    sig { returns(T::Boolean) }
+    def in_workflow?; end
+
+    sig { returns(Temporalio::Workflow::Info) }
+    def info; end
+
+    sig { returns(T.nilable(Temporalio::Workflow::Definition)) }
+    def instance; end
+
+    sig { returns(Temporalio::ScopedLogger) }
+    def logger; end
+
+    sig { returns(T::Hash[String, T.nilable(Object)]) }
+    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(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Query]) }
+    def query_handlers; end
+
+    sig { returns(Random) }
+    def random; end
+
+    sig { returns(Temporalio::SearchAttributes) }
+    def search_attributes; end
+
+    sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Signal]) }
+    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: T.unsafe(nil), cancellation: T.unsafe(nil)); 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::Workflow::ChildWorkflowHandle)
+    end
+    def start_child_workflow(
+      workflow,
+      *args,
+      id: T.unsafe(nil),
+      task_queue: T.unsafe(nil),
+      static_summary: T.unsafe(nil),
+      static_details: T.unsafe(nil),
+      cancellation: T.unsafe(nil),
+      cancellation_type: T.unsafe(nil),
+      parent_close_policy: T.unsafe(nil),
+      execution_timeout: T.unsafe(nil),
+      run_timeout: T.unsafe(nil),
+      task_timeout: T.unsafe(nil),
+      id_reuse_policy: T.unsafe(nil),
+      retry_policy: T.unsafe(nil),
+      cron_schedule: T.unsafe(nil),
+      memo: T.unsafe(nil),
+      search_attributes: T.unsafe(nil),
+      priority: T.unsafe(nil),
+      arg_hints: T.unsafe(nil),
+      result_hint: T.unsafe(nil)
+    ); 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),
+          message: String,
+          summary: T.nilable(String),
+          block: T.proc.returns(T.type_parameter(:T))
+        ).returns(T.type_parameter(:T))
+    end
+    def timeout(duration, exception_class = T.unsafe(nil), message = T.unsafe(nil), summary: T.unsafe(nil), &block); end
+
+    sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Update]) }
+    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: T.unsafe(nil), &block); end
+  end
+end
+
+module Temporalio::Workflow::Unsafe
+  class << self
+    extend T::Sig
+
+    sig { returns(T::Boolean) }
+    def replaying?; end
+
+    sig { returns(T::Boolean) }
+    def replaying_history_events?; 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 { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    def io_enabled(&block); 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
+  end
+end
+
+class Temporalio::Workflow::ContinueAsNewError < ::Temporalio::Error
+  extend T::Sig
+
+  sig do
+    params(
+      args: T.nilable(Object),
+      workflow: T.nilable(T.any(T.class_of(Temporalio::Workflow::Definition), String, Symbol)),
+      task_queue: T.nilable(String),
+      run_timeout: T.nilable(T.any(Integer, Float)),
+      task_timeout: T.nilable(T.any(Integer, Float)),
+      backoff_start_interval: T.nilable(T.any(Integer, Float)),
+      retry_policy: T.nilable(Temporalio::RetryPolicy),
+      memo: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]),
+      search_attributes: T.nilable(Temporalio::SearchAttributes),
+      arg_hints: T.nilable(T::Array[Object]),
+      headers: T::Hash[String, T.nilable(Object)],
+      initial_versioning_behavior: T.nilable(Integer)
+    ).void
+  end
+  def initialize(
+    *args,
+    workflow: T.unsafe(nil),
+    task_queue: T.unsafe(nil),
+    run_timeout: T.unsafe(nil),
+    task_timeout: T.unsafe(nil),
+    backoff_start_interval: T.unsafe(nil),
+    retry_policy: T.unsafe(nil),
+    memo: T.unsafe(nil),
+    search_attributes: T.unsafe(nil),
+    arg_hints: T.unsafe(nil),
+    headers: T.unsafe(nil),
+    initial_versioning_behavior: T.unsafe(nil)
+  ); end
+
+  sig { returns(T::Array[T.nilable(Object)]) }
+  attr_accessor :args
+
+  sig { returns(T.nilable(T.any(T.class_of(Temporalio::Workflow::Definition), String, Symbol))) }
+  attr_accessor :workflow
+
+  sig { returns(T.nilable(String)) }
+  attr_accessor :task_queue
+
+  sig { returns(T.nilable(T.any(Integer, Float))) }
+  attr_accessor :run_timeout
+
+  sig { returns(T.nilable(T.any(Integer, Float))) }
+  attr_accessor :task_timeout
+
+  sig { returns(T.nilable(T.any(Integer, Float))) }
+  attr_accessor :backoff_start_interval
+
+  sig { returns(T.nilable(Temporalio::RetryPolicy)) }
+  attr_accessor :retry_policy
+
+  sig { returns(T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)])) }
+  attr_accessor :memo
+
+  sig { returns(T.nilable(Temporalio::SearchAttributes)) }
+  attr_accessor :search_attributes
+
+  sig { returns(T.nilable(T::Array[Object])) }
+  attr_accessor :arg_hints
+
+  sig { returns(T::Hash[String, T.nilable(Object)]) }
+  attr_accessor :headers
+
+  sig { returns(T.nilable(Integer)) }
+  attr_accessor :initial_versioning_behavior
+
+end
+
+class Temporalio::Workflow::InvalidWorkflowStateError < ::Temporalio::Error; end
+
+class Temporalio::Workflow::NondeterminismError < ::Temporalio::Error; end
+
+class Temporalio::Workflow::Mutex < ::Mutex; end
+
+class Temporalio::Workflow::Queue < ::Queue; end
+
+class Temporalio::Workflow::SizedQueue < ::SizedQueue; end

data/rbi/temporalio/workflow_history.rbi

@@ -0,0 +1,21 @@
+# typed: true
+
+class Temporalio::WorkflowHistory
+  sig { params(events: T::Array[Temporalio::Api::History::V1::HistoryEvent]).void }
+  def initialize(events); end
+
+  sig { params(json: String).returns(Temporalio::WorkflowHistory) }
+  def self.from_history_json(json); end
+
+  sig { returns(T::Array[Temporalio::Api::History::V1::HistoryEvent]) }
+  attr_reader :events
+
+  sig { returns(String) }
+  def workflow_id; end
+
+  sig { returns(String) }
+  def to_history_json; end
+
+  sig { params(other: Temporalio::WorkflowHistory).returns(T::Boolean) }
+  def ==(other); end
+end

data/rbi/temporalio.rbi

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

data/sig/common.rbs

@@ -0,0 +1 @@
+type duration = Integer | Float

data/sig/google/protobuf_compat.rbs

@@ -0,0 +1,17 @@
+module Google
+  module Protobuf
+    class AbstractMessage
+      def self.decode: (String proto, ?Hash[untyped, untyped] options) -> instance
+      def self.decode_json: (String json, ?Hash[untyped, untyped] options) -> instance
+      def self.encode: (AbstractMessage msg, ?Hash[untyped, untyped] options) -> String
+      def self.encode_json: (AbstractMessage msg, ?Hash[untyped, untyped] options) -> String
+    end
+
+    class Empty < AbstractMessage
+    end
+
+    class DoubleValue < AbstractMessage
+      attr_accessor value(): Float
+    end
+  end
+end

data/sig/open_telemetry.rbs

@@ -0,0 +1,47 @@
+module OpenTelemetry
+  module Context
+    def self.current: -> untyped
+    def self.attach: (untyped context) -> untyped
+    def self.detach: (untyped token) -> void
+
+    module Propagation
+      class CompositeTextMapPropagator
+        def self.compose_propagators: (Array[untyped] propagators) -> untyped
+      end
+    end
+  end
+
+  module Baggage
+    module Propagation
+      class TextMapPropagator
+        def initialize: -> void
+      end
+    end
+  end
+
+  module Trace
+    def self.with_span: [T] (untyped span) { -> T } -> T
+    def self.current_span: (?untyped context) -> untyped
+    def self.context_with_span: (untyped span) -> untyped
+
+    class Link
+      def initialize: (untyped context) -> void
+    end
+
+    module Status
+      def self.error: (String description) -> untyped
+    end
+
+    module Propagation
+      module TraceContext
+        class TextMapPropagator
+          def initialize: -> void
+        end
+      end
+    end
+
+    class Span
+      INVALID: untyped
+    end
+  end
+end

data/sig/temporalio/activity/cancellation_details.rbs

@@ -0,0 +1,21 @@
+module Temporalio
+  module Activity
+    class CancellationDetails
+      def initialize: (
+        ?gone_from_server: bool,
+        ?cancel_requested: bool,
+        ?timed_out: bool,
+        ?worker_shutdown: bool,
+        ?paused: bool,
+        ?reset: bool
+      ) -> void
+
+      def gone_from_server?: -> bool
+      def cancel_requested?: -> bool
+      def timed_out?: -> bool
+      def worker_shutdown?: -> bool
+      def paused?: -> bool
+      def reset?: -> bool
+    end
+  end
+end

data/sig/temporalio/activity/complete_async_error.rbs

@@ -0,0 +1,6 @@
+module Temporalio
+  module Activity
+    class CompleteAsyncError < Error
+    end
+  end
+end

data/sig/temporalio/activity/context.rbs

@@ -0,0 +1,26 @@
+module Temporalio
+  module Activity
+    class Context
+      def self.current: -> Context
+      def self.current_or_nil: -> Context?
+      def self.exist?: -> bool
+
+      def self._current_executor: -> Worker::ActivityExecutor?
+      def self._current_executor=: (Worker::ActivityExecutor? executor) -> void
+
+      def info: -> Info
+      def instance: -> Definition?
+      def heartbeat: (*Object? details, ?detail_hints: Array[Object]?) -> void
+      def cancellation: -> Cancellation
+      def cancellation_details: -> CancellationDetails?
+      def worker_shutdown_cancellation: -> Cancellation
+      def payload_converter: -> Converters::PayloadConverter
+      def logger: -> ScopedLogger
+
+      def _scoped_logger_info: -> Hash[Symbol, Object]
+
+      def metric_meter: -> Metric::Meter
+      def client: -> Client
+    end
+  end
+end

data/sig/temporalio/activity/definition.rbs

@@ -0,0 +1,60 @@
+module Temporalio
+  module Activity
+    class Definition
+      def self.activity_name: (String | Symbol name) -> void
+      def self.activity_executor: (Symbol executor_name) -> void
+      def self.activity_cancel_raise: (bool cancel_raise) -> void
+      def self.activity_dynamic: (?bool value) -> void
+      def self.activity_raw_args: (?bool value) -> void
+      def self.activity_arg_hint: (*Object hints) -> void
+      def self.activity_result_hint: (Object? hint) -> void
+  
+      def self._activity_definition_details: -> {
+        activity_name: String | Symbol | nil,
+        activity_executor: Symbol,
+        activity_cancel_raise: bool,
+        activity_raw_args: bool,
+        activity_arg_hints: Array[Object]?,
+        activity_result_hint: Object?
+      }
+  
+      def execute: (*untyped) -> untyped
+
+      def _activity_definition_details: -> {
+        activity_name: String | Symbol | nil,
+        activity_executor: Symbol,
+        activity_cancel_raise: bool,
+        activity_raw_args: bool,
+        activity_arg_hints: Array[Object]?,
+        activity_result_hint: Object?
+      }
+
+      class Info
+        attr_reader name: String | Symbol | nil
+        attr_reader instance: Object | Proc | nil
+        attr_reader proc: Proc
+        attr_reader executor: Symbol
+        attr_reader cancel_raise: bool
+        attr_reader raw_args: bool
+        attr_reader arg_hints: Array[Object]?
+        attr_reader result_hint: Object?
+
+        def self.from_activity: (Definition | singleton(Definition) | Info activity) -> Info
+
+        def self._type_and_hints_from_parameter: (
+          singleton(Definition) | Definition | Info | Symbol | String activity
+        ) -> [String, Array[Object]?, Object?]
+
+        def initialize: (
+          name: String | Symbol | nil,
+          ?instance: Object | Proc | nil,
+          ?executor: Symbol,
+          ?cancel_raise: bool,
+          ?raw_args: bool,
+          ?arg_hints: Array[Object]?,
+          ?result_hint: Object?
+        ) { (?) -> untyped } -> void
+      end
+    end
+  end
+end

data/sig/temporalio/activity/info.rbs

@@ -0,0 +1,57 @@
+module Temporalio
+  module Activity
+    class Info
+      attr_reader activity_id: String
+      attr_reader activity_run_id: String?
+      attr_reader activity_type: String
+      attr_reader attempt: Integer
+      attr_reader current_attempt_scheduled_time: Time
+      attr_reader heartbeat_timeout: Float?
+      attr_reader local?: bool
+      attr_reader namespace: String
+      attr_reader priority: Temporalio::Priority
+      attr_reader raw_heartbeat_details: Array[Converters::RawValue]
+      attr_reader retry_policy: RetryPolicy?
+      attr_reader schedule_to_close_timeout: Float?
+      attr_reader scheduled_time: Time
+      attr_reader start_to_close_timeout: Float?
+      attr_reader started_time: Time
+      attr_reader task_queue: String
+      attr_reader task_token: String
+      attr_reader workflow_id: String?
+      attr_reader workflow_namespace: String?
+      attr_reader workflow_run_id: String?
+      attr_reader workflow_type: String?
+
+      def initialize: (
+        activity_id: String,
+        activity_run_id: String?,
+        activity_type: String,
+        attempt: Integer,
+        current_attempt_scheduled_time: Time,
+        heartbeat_timeout: Float?,
+        local?: bool,
+        namespace: String,
+        priority: Temporalio::Priority?,
+        raw_heartbeat_details: Array[Converters::RawValue],
+        retry_policy: RetryPolicy?,
+        schedule_to_close_timeout: Float?,
+        scheduled_time: Time,
+        start_to_close_timeout: Float?,
+        started_time: Time,
+        task_queue: String,
+        task_token: String,
+        workflow_id: String?,
+        workflow_namespace: String?,
+        workflow_run_id: String?,
+        workflow_type: String?
+      ) -> void
+
+      def in_workflow?: -> bool
+
+      def heartbeat_details: (?hints: Array[Object]?) -> Array[Object?]
+
+      def with: (**untyped) -> Info
+    end
+  end
+end

data/sig/temporalio/activity.rbs

@@ -0,0 +1,4 @@
+module Temporalio
+  module Activity
+  end
+end