temporalio 1.5.0 → 1.6.0

data/rbi/temporalio/workflow/child_workflow_handle.rbi

@@ -0,0 +1,27 @@
+# typed: true
+
+class Temporalio::Workflow::ChildWorkflowHandle
+  extend T::Sig
+
+  sig { returns(String) }
+  def id; end
+
+  sig { returns(String) }
+  def first_execution_run_id; end
+
+  sig { returns(T.nilable(Object)) }
+  def result_hint; end
+
+  sig { params(result_hint: T.nilable(Object)).returns(T.nilable(Object)) }
+  def result(result_hint: T.unsafe(nil)); end
+
+  sig do
+    params(
+      signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String),
+      args: T.nilable(Object),
+      cancellation: Temporalio::Cancellation,
+      arg_hints: T.nilable(T::Array[Object])
+    ).void
+  end
+  def signal(signal, *args, cancellation: T.unsafe(nil), arg_hints: T.unsafe(nil)); end
+end

data/rbi/temporalio/workflow/definition.rbi

@@ -0,0 +1,305 @@
+# typed: true
+
+class Temporalio::Workflow::Definition
+  extend T::Sig
+
+  sig { params(args: T.nilable(Object)).returns(T.nilable(Object)) }
+  def execute(*args); end
+
+  class << self
+    extend T::Sig
+
+    sig { params(workflow_name: T.any(String, Symbol)).void }
+    def workflow_name(workflow_name); end
+
+    sig { params(value: T::Boolean).void }
+    def workflow_dynamic(value = T.unsafe(nil)); end
+
+    sig { params(value: T::Boolean).void }
+    def workflow_raw_args(value = T.unsafe(nil)); end
+
+    sig { params(hints: Object).void }
+    def workflow_arg_hint(*hints); end
+
+    sig { params(hint: Object).void }
+    def workflow_result_hint(hint); end
+
+    sig { params(types: T.class_of(Exception)).void }
+    def workflow_failure_exception_type(*types); end
+
+    sig { params(attr_names: Symbol, description: T.nilable(String)).void }
+    def workflow_query_attr_reader(*attr_names, description: T.unsafe(nil)); end
+
+    sig { params(behavior: Integer).void }
+    def workflow_versioning_behavior(behavior); end
+
+    sig { params(value: T::Boolean).void }
+    def workflow_init(value = T.unsafe(nil)); end
+
+    sig do
+      params(
+        name: T.nilable(T.any(String, Symbol)),
+        description: T.nilable(String),
+        dynamic: T::Boolean,
+        raw_args: T::Boolean,
+        unfinished_policy: Integer,
+        arg_hints: T.nilable(T.any(Object, T::Array[Object]))
+      ).void
+    end
+    def workflow_signal(
+      name: T.unsafe(nil),
+      description: T.unsafe(nil),
+      dynamic: T.unsafe(nil),
+      raw_args: T.unsafe(nil),
+      unfinished_policy: T.unsafe(nil),
+      arg_hints: T.unsafe(nil)
+    ); end
+
+    sig do
+      params(
+        name: T.nilable(T.any(String, Symbol)),
+        description: T.nilable(String),
+        dynamic: T::Boolean,
+        raw_args: T::Boolean,
+        arg_hints: T.nilable(T.any(Object, T::Array[Object])),
+        result_hint: T.nilable(Object)
+      ).void
+    end
+    def workflow_query(
+      name: T.unsafe(nil),
+      description: T.unsafe(nil),
+      dynamic: T.unsafe(nil),
+      raw_args: T.unsafe(nil),
+      arg_hints: T.unsafe(nil),
+      result_hint: T.unsafe(nil)
+    ); end
+
+    sig do
+      params(
+        name: T.nilable(T.any(String, Symbol)),
+        description: T.nilable(String),
+        dynamic: T::Boolean,
+        raw_args: T::Boolean,
+        unfinished_policy: Integer,
+        arg_hints: T.nilable(T.any(Object, T::Array[Object])),
+        result_hint: T.nilable(Object)
+      ).void
+    end
+    def workflow_update(
+      name: T.unsafe(nil),
+      description: T.unsafe(nil),
+      dynamic: T.unsafe(nil),
+      raw_args: T.unsafe(nil),
+      unfinished_policy: T.unsafe(nil),
+      arg_hints: T.unsafe(nil),
+      result_hint: T.unsafe(nil)
+    ); end
+
+    sig { params(update_method: Symbol).void }
+    def workflow_update_validator(update_method); end
+
+    sig { void }
+    def workflow_dynamic_options; end
+  end
+end
+
+class Temporalio::Workflow::Definition::Info
+  extend T::Sig
+
+  sig { returns(T.class_of(Temporalio::Workflow::Definition)) }
+  attr_reader :workflow_class
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :override_name
+
+  sig { returns(T::Boolean) }
+  attr_reader :dynamic
+
+  sig { returns(T::Boolean) }
+  attr_reader :init
+
+  sig { returns(T::Boolean) }
+  attr_reader :raw_args
+
+  sig { returns(T::Array[T.class_of(Exception)]) }
+  attr_reader :failure_exception_types
+
+  sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Signal]) }
+  attr_reader :signals
+
+  sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Query]) }
+  attr_reader :queries
+
+  sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Update]) }
+  attr_reader :updates
+
+  sig { returns(T.nilable(Integer)) }
+  attr_reader :versioning_behavior
+
+  sig { returns(T.nilable(Symbol)) }
+  attr_reader :dynamic_options_method
+
+  sig { returns(T.nilable(T::Array[Object])) }
+  attr_reader :arg_hints
+
+  sig { returns(T.nilable(Object)) }
+  attr_reader :result_hint
+
+  sig { params(workflow_class: T.class_of(Temporalio::Workflow::Definition)).returns(Temporalio::Workflow::Definition::Info) }
+  def self.from_class(workflow_class); end
+
+  sig do
+    params(
+      workflow_class: T.class_of(Temporalio::Workflow::Definition),
+      override_name: T.nilable(String),
+      dynamic: T::Boolean,
+      init: T::Boolean,
+      raw_args: T::Boolean,
+      failure_exception_types: T::Array[T.class_of(Exception)],
+      signals: T::Hash[String, Temporalio::Workflow::Definition::Signal],
+      queries: T::Hash[String, Temporalio::Workflow::Definition::Query],
+      updates: T::Hash[String, Temporalio::Workflow::Definition::Update],
+      versioning_behavior: T.nilable(Integer),
+      dynamic_options_method: T.nilable(Symbol),
+      arg_hints: T.nilable(T::Array[Object]),
+      result_hint: T.nilable(Object)
+    ).void
+  end
+  def initialize(
+    workflow_class:,
+    override_name: T.unsafe(nil),
+    dynamic: T.unsafe(nil),
+    init: T.unsafe(nil),
+    raw_args: T.unsafe(nil),
+    failure_exception_types: T.unsafe(nil),
+    signals: T.unsafe(nil),
+    queries: T.unsafe(nil),
+    updates: T.unsafe(nil),
+    versioning_behavior: T.unsafe(nil),
+    dynamic_options_method: T.unsafe(nil),
+    arg_hints: T.unsafe(nil),
+    result_hint: T.unsafe(nil)
+  ); end
+
+  sig { returns(T.nilable(String)) }
+  def name; end
+end
+
+class Temporalio::Workflow::Definition::Signal
+  extend T::Sig
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :name
+
+  sig { returns(T.any(Symbol, Proc)) }
+  attr_reader :to_invoke
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :description
+
+  sig { returns(T::Boolean) }
+  attr_reader :raw_args
+
+  sig { returns(Integer) }
+  attr_reader :unfinished_policy
+
+  sig { returns(T.nilable(T::Array[Object])) }
+  attr_reader :arg_hints
+
+  sig do
+    params(
+      name: T.nilable(String),
+      to_invoke: T.any(Symbol, Proc),
+      description: T.nilable(String),
+      raw_args: T::Boolean,
+      unfinished_policy: Integer,
+      arg_hints: T.nilable(T::Array[Object])
+    ).void
+  end
+  def initialize(name:, to_invoke:, description: T.unsafe(nil), raw_args: T.unsafe(nil), unfinished_policy: T.unsafe(nil), arg_hints: T.unsafe(nil)); end
+end
+
+class Temporalio::Workflow::Definition::Query
+  extend T::Sig
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :name
+
+  sig { returns(T.any(Symbol, Proc)) }
+  attr_reader :to_invoke
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :description
+
+  sig { returns(T::Boolean) }
+  attr_reader :raw_args
+
+  sig { returns(T.nilable(T::Array[Object])) }
+  attr_reader :arg_hints
+
+  sig { returns(T.nilable(Object)) }
+  attr_reader :result_hint
+
+  sig do
+    params(
+      name: T.nilable(String),
+      to_invoke: T.any(Symbol, Proc),
+      description: T.nilable(String),
+      raw_args: T::Boolean,
+      arg_hints: T.nilable(T::Array[Object]),
+      result_hint: T.nilable(Object)
+    ).void
+  end
+  def initialize(name:, to_invoke:, description: T.unsafe(nil), raw_args: T.unsafe(nil), arg_hints: T.unsafe(nil), result_hint: T.unsafe(nil)); end
+end
+
+class Temporalio::Workflow::Definition::Update
+  extend T::Sig
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :name
+
+  sig { returns(T.any(Symbol, Proc)) }
+  attr_reader :to_invoke
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :description
+
+  sig { returns(T::Boolean) }
+  attr_reader :raw_args
+
+  sig { returns(Integer) }
+  attr_reader :unfinished_policy
+
+  sig { returns(T.nilable(T.any(Symbol, Proc))) }
+  attr_reader :validator_to_invoke
+
+  sig { returns(T.nilable(T::Array[Object])) }
+  attr_reader :arg_hints
+
+  sig { returns(T.nilable(Object)) }
+  attr_reader :result_hint
+
+  sig do
+    params(
+      name: T.nilable(String),
+      to_invoke: T.any(Symbol, Proc),
+      description: T.nilable(String),
+      raw_args: T::Boolean,
+      unfinished_policy: Integer,
+      validator_to_invoke: T.nilable(T.any(Symbol, Proc)),
+      arg_hints: T.nilable(T::Array[Object]),
+      result_hint: T.nilable(Object)
+    ).void
+  end
+  def initialize(
+    name:,
+    to_invoke:,
+    description: T.unsafe(nil),
+    raw_args: T.unsafe(nil),
+    unfinished_policy: T.unsafe(nil),
+    validator_to_invoke: T.unsafe(nil),
+    arg_hints: T.unsafe(nil),
+    result_hint: T.unsafe(nil)
+  ); end
+end

data/rbi/temporalio/workflow/external_workflow_handle.rbi

@@ -0,0 +1,24 @@
+# typed: true
+
+class Temporalio::Workflow::ExternalWorkflowHandle
+  extend T::Sig
+
+  sig { returns(String) }
+  def id; end
+
+  sig { returns(T.nilable(String)) }
+  def run_id; end
+
+  sig do
+    params(
+      signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String),
+      args: T.nilable(Object),
+      cancellation: Temporalio::Cancellation,
+      arg_hints: T.nilable(T::Array[Object])
+    ).void
+  end
+  def signal(signal, *args, cancellation: T.unsafe(nil), arg_hints: T.unsafe(nil)); end
+
+  sig { void }
+  def cancel; end
+end

data/rbi/temporalio/workflow/future.rbi

@@ -0,0 +1,62 @@
+# typed: true
+
+class Temporalio::Workflow::Future
+  extend T::Sig
+  extend T::Generic
+
+  Elem = type_member
+
+  sig { returns(T.nilable(Elem)) }
+  attr_reader :result
+
+  sig { returns(T.nilable(Exception)) }
+  attr_reader :failure
+
+  sig { params(block: T.nilable(T.proc.returns(Elem))).void }
+  def initialize(&); end
+
+  sig { returns(T::Boolean) }
+  def done?; end
+
+  sig { returns(T::Boolean) }
+  def result?; end
+
+  sig { params(result: Elem).void }
+  def result=(result); end
+
+  sig { returns(T::Boolean) }
+  def failure?; end
+
+  sig { params(failure: Exception).void }
+  def failure=(failure); end
+
+  sig { returns(Elem) }
+  def wait; end
+
+  sig { returns(T.nilable(Elem)) }
+  def wait_no_raise; end
+
+  class << self
+    extend T::Sig
+
+    sig { params(futures: Temporalio::Workflow::Future[T.anything]).returns(Temporalio::Workflow::Future[NilClass]) }
+    def all_of(*futures); end
+
+    sig do
+      type_parameters(:T)
+        .params(futures: Temporalio::Workflow::Future[T.type_parameter(:T)])
+        .returns(Temporalio::Workflow::Future[T.type_parameter(:T)])
+    end
+    def any_of(*futures); end
+
+    sig do
+      type_parameters(:T)
+        .params(futures: Temporalio::Workflow::Future[T.type_parameter(:T)])
+        .returns(Temporalio::Workflow::Future[Temporalio::Workflow::Future[T.type_parameter(:T)]])
+    end
+    def try_any_of(*futures); end
+
+    sig { params(futures: Temporalio::Workflow::Future[T.anything]).returns(Temporalio::Workflow::Future[NilClass]) }
+    def try_all_of(*futures); end
+  end
+end

data/rbi/temporalio/workflow/handler_unfinished_policy.rbi

@@ -0,0 +1,6 @@
+# typed: true
+
+module Temporalio::Workflow::HandlerUnfinishedPolicy
+  WARN_AND_ABANDON = T.let(T.unsafe(nil), Integer)
+  ABANDON = T.let(T.unsafe(nil), Integer)
+end

data/rbi/temporalio/workflow/info.rbi

@@ -0,0 +1,100 @@
+# typed: true
+
+class Temporalio::Workflow::Info < ::Struct
+  extend T::Sig
+
+  sig { returns(Integer) }
+  def attempt; end
+
+  sig { returns(T.nilable(String)) }
+  def continued_run_id; end
+
+  sig { returns(T.nilable(String)) }
+  def cron_schedule; end
+
+  sig { returns(T.nilable(Numeric)) }
+  def execution_timeout; end
+
+  sig { returns(String) }
+  def first_execution_run_id; end
+
+  sig { returns(T::Hash[String, Temporalio::Api::Common::V1::Payload]) }
+  def headers; end
+
+  sig { returns(T.nilable(Exception)) }
+  def last_failure; end
+
+  sig { returns(T.nilable(Object)) }
+  def last_result; end
+
+  sig { returns(T::Boolean) }
+  def has_last_result?; end
+
+  sig { returns(String) }
+  def namespace; end
+
+  sig { returns(T.nilable(Temporalio::Workflow::Info::ParentInfo)) }
+  def parent; end
+
+  sig { returns(Temporalio::Priority) }
+  def priority; end
+
+  sig { returns(T.nilable(Temporalio::RetryPolicy)) }
+  def retry_policy; end
+
+  sig { returns(T.nilable(Temporalio::Workflow::Info::RootInfo)) }
+  def root; end
+
+  sig { returns(String) }
+  def run_id; end
+
+  sig { returns(T.nilable(Numeric)) }
+  def run_timeout; end
+
+  sig { returns(Time) }
+  def start_time; end
+
+  sig { returns(String) }
+  def task_queue; end
+
+  sig { returns(Float) }
+  def task_timeout; end
+
+  sig { returns(String) }
+  def workflow_id; end
+
+  sig { returns(String) }
+  def workflow_type; end
+
+  sig { returns(T::Hash[Symbol, Object]) }
+  def to_h; end
+end
+
+class Temporalio::Workflow::Info::ParentInfo < ::Struct
+  extend T::Sig
+
+  sig { returns(String) }
+  def namespace; end
+
+  sig { returns(String) }
+  def run_id; end
+
+  sig { returns(String) }
+  def workflow_id; end
+
+  sig { returns(T::Hash[Symbol, String]) }
+  def to_h; end
+end
+
+class Temporalio::Workflow::Info::RootInfo < ::Struct
+  extend T::Sig
+
+  sig { returns(String) }
+  def run_id; end
+
+  sig { returns(String) }
+  def workflow_id; end
+
+  sig { returns(T::Hash[Symbol, String]) }
+  def to_h; end
+end

data/rbi/temporalio/workflow/nexus_client.rbi

@@ -0,0 +1,65 @@
+# typed: true
+
+class Temporalio::Workflow::NexusClient
+  extend T::Sig
+
+  sig { returns(String) }
+  def endpoint; end
+
+  sig { returns(String) }
+  def service; end
+
+  sig do
+    params(
+      operation: T.any(Symbol, String),
+      arg: T.nilable(Object),
+      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)),
+      cancellation_type: Integer,
+      summary: T.nilable(String),
+      cancellation: Temporalio::Cancellation,
+      arg_hint: T.nilable(Object),
+      result_hint: T.nilable(Object)
+    ).returns(Temporalio::Workflow::NexusOperationHandle)
+  end
+  def start_operation(
+    operation,
+    arg,
+    schedule_to_close_timeout: T.unsafe(nil),
+    schedule_to_start_timeout: T.unsafe(nil),
+    start_to_close_timeout: T.unsafe(nil),
+    cancellation_type: T.unsafe(nil),
+    summary: T.unsafe(nil),
+    cancellation: T.unsafe(nil),
+    arg_hint: T.unsafe(nil),
+    result_hint: T.unsafe(nil)
+  ); end
+
+  sig do
+    params(
+      operation: T.any(Symbol, String),
+      arg: T.nilable(Object),
+      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)),
+      cancellation_type: Integer,
+      summary: T.nilable(String),
+      cancellation: Temporalio::Cancellation,
+      arg_hint: T.nilable(Object),
+      result_hint: T.nilable(Object)
+    ).returns(T.nilable(Object))
+  end
+  def execute_operation(
+    operation,
+    arg,
+    schedule_to_close_timeout: T.unsafe(nil),
+    schedule_to_start_timeout: T.unsafe(nil),
+    start_to_close_timeout: T.unsafe(nil),
+    cancellation_type: T.unsafe(nil),
+    summary: T.unsafe(nil),
+    cancellation: T.unsafe(nil),
+    arg_hint: T.unsafe(nil),
+    result_hint: T.unsafe(nil)
+  ); end
+end

data/rbi/temporalio/workflow/nexus_operation_cancellation_type.rbi

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

data/rbi/temporalio/workflow/nexus_operation_handle.rbi

@@ -0,0 +1,14 @@
+# typed: true
+
+class Temporalio::Workflow::NexusOperationHandle
+  extend T::Sig
+
+  sig { returns(T.nilable(String)) }
+  def operation_token; end
+
+  sig { returns(T.nilable(Object)) }
+  def result_hint; end
+
+  sig { params(result_hint: T.nilable(Object)).returns(T.nilable(Object)) }
+  def result(result_hint: T.unsafe(nil)); end
+end

data/rbi/temporalio/workflow/parent_close_policy.rbi

@@ -0,0 +1,8 @@
+# typed: true
+
+module Temporalio::Workflow::ParentClosePolicy
+  UNSPECIFIED = T.let(T.unsafe(nil), Integer)
+  TERMINATE = T.let(T.unsafe(nil), Integer)
+  ABANDON = T.let(T.unsafe(nil), Integer)
+  REQUEST_CANCEL = T.let(T.unsafe(nil), Integer)
+end

data/rbi/temporalio/workflow/update_info.rbi

@@ -0,0 +1,14 @@
+# typed: true
+
+class Temporalio::Workflow::UpdateInfo < ::Struct
+  extend T::Sig
+
+  sig { returns(String) }
+  def id; end
+
+  sig { returns(String) }
+  def name; end
+
+  sig { returns(T::Hash[Symbol, String]) }
+  def to_h; end
+end