temporalio 1.5.0 → 1.6.0

data/rbi/temporalio/client/schedule_handle.rbi

@@ -0,0 +1,40 @@
+# typed: true
+
+class Temporalio::Client::ScheduleHandle
+  sig { params(client: Temporalio::Client, id: String).void }
+  def initialize(client:, id:); end
+
+  sig { returns(String) }
+  attr_reader :id
+
+  sig do
+    params(
+      backfills: Temporalio::Client::Schedule::Backfill,
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).void
+  end
+  def backfill(*backfills, rpc_options: T.unsafe(nil)); end
+
+  sig { params(rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
+  def delete(rpc_options: T.unsafe(nil)); end
+
+  sig { params(rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Client::Schedule::Description) }
+  def describe(rpc_options: T.unsafe(nil)); end
+
+  sig { params(note: String, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
+  def pause(note: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig { params(overlap: T.nilable(Integer), rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
+  def trigger(overlap: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig { params(note: String, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
+  def unpause(note: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions),
+      updater: T.proc.params(arg0: Temporalio::Client::Schedule::Update::Input).returns(T.nilable(Temporalio::Client::Schedule::Update))
+    ).void
+  end
+  def update(rpc_options: T.unsafe(nil), &updater); end
+end

data/rbi/temporalio/client/with_start_workflow_operation.rbi

@@ -0,0 +1,126 @@
+# typed: true
+
+class Temporalio::Client::WithStartWorkflowOperation
+  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),
+      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,
+      id_conflict_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),
+      start_delay: T.nilable(T.any(Integer, Float)),
+      priority: Temporalio::Priority,
+      arg_hints: T.nilable(T::Array[Object]),
+      result_hint: T.nilable(Object),
+      headers: T.nilable(T::Hash[String, T.nilable(Object)])
+    ).void
+  end
+  def initialize(
+    workflow,
+    *args,
+    id:,
+    task_queue:,
+    static_summary: T.unsafe(nil),
+    static_details: T.unsafe(nil),
+    execution_timeout: T.unsafe(nil),
+    run_timeout: T.unsafe(nil),
+    task_timeout: T.unsafe(nil),
+    id_reuse_policy: T.unsafe(nil),
+    id_conflict_policy: T.unsafe(nil),
+    retry_policy: T.unsafe(nil),
+    cron_schedule: T.unsafe(nil),
+    memo: T.unsafe(nil),
+    search_attributes: T.unsafe(nil),
+    start_delay: T.unsafe(nil),
+    priority: T.unsafe(nil),
+    arg_hints: T.unsafe(nil),
+    result_hint: T.unsafe(nil),
+    headers: T.unsafe(nil)
+  ); end
+
+  sig { returns(Temporalio::Client::WithStartWorkflowOperation::Options) }
+  attr_accessor :options
+
+  sig { params(wait: T::Boolean).returns(T.nilable(Temporalio::Client::WorkflowHandle)) }
+  def workflow_handle(wait: T.unsafe(nil)); end
+end
+
+class Temporalio::Client::WithStartWorkflowOperation::Options < ::Data
+  sig { returns(String) }
+  def workflow; end
+
+  sig { returns(T::Array[T.nilable(Object)]) }
+  def args; end
+
+  sig { returns(String) }
+  def id; end
+
+  sig { returns(String) }
+  def task_queue; end
+
+  sig { returns(T.nilable(String)) }
+  def static_summary; end
+
+  sig { returns(T.nilable(String)) }
+  def static_details; end
+
+  sig { returns(T.nilable(T.any(Integer, Float))) }
+  def execution_timeout; end
+
+  sig { returns(T.nilable(T.any(Integer, Float))) }
+  def run_timeout; end
+
+  sig { returns(T.nilable(T.any(Integer, Float))) }
+  def task_timeout; end
+
+  sig { returns(Integer) }
+  def id_reuse_policy; end
+
+  sig { returns(Integer) }
+  def id_conflict_policy; end
+
+  sig { returns(T.nilable(Temporalio::RetryPolicy)) }
+  def retry_policy; end
+
+  sig { returns(T.nilable(String)) }
+  def cron_schedule; end
+
+  sig { returns(T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)])) }
+  def memo; end
+
+  sig { returns(T.nilable(Temporalio::SearchAttributes)) }
+  def search_attributes; end
+
+  sig { returns(T.nilable(T.any(Integer, Float))) }
+  def start_delay; end
+
+  sig { returns(T.nilable(T::Array[Object])) }
+  def arg_hints; end
+
+  sig { returns(T.nilable(Object)) }
+  def result_hint; end
+
+  sig { returns(T::Hash[String, T.nilable(Object)]) }
+  def headers; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::Client::WithStartWorkflowOperation::Options) }
+    def new(*args); end
+
+    sig { params(args: T.untyped).returns(Temporalio::Client::WithStartWorkflowOperation::Options) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+  end
+end

data/rbi/temporalio/client/workflow_execution.rbi

@@ -0,0 +1,62 @@
+# typed: true
+
+class Temporalio::Client::WorkflowExecution
+  sig { params(raw_info: Temporalio::Api::Workflow::V1::WorkflowExecutionInfo, data_converter: Temporalio::Converters::DataConverter).void }
+  def initialize(raw_info, data_converter); end
+
+  sig { returns(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo) }
+  attr_reader :raw_info
+
+  sig { returns(T.nilable(Time)) }
+  def close_time; end
+
+  sig { returns(T.nilable(Time)) }
+  def execution_time; end
+
+  sig { returns(Integer) }
+  def history_length; end
+
+  sig { returns(String) }
+  def id; end
+
+  sig { returns(T.nilable(T::Hash[String, T.nilable(Object)])) }
+  def memo; end
+
+  sig { returns(T.nilable(String)) }
+  def parent_id; end
+
+  sig { returns(T.nilable(String)) }
+  def parent_run_id; end
+
+  sig { returns(String) }
+  def run_id; end
+
+  sig { returns(T.nilable(Temporalio::SearchAttributes)) }
+  def search_attributes; end
+
+  sig { returns(Time) }
+  def start_time; end
+
+  sig { returns(Integer) }
+  def status; end
+
+  sig { returns(String) }
+  def task_queue; end
+
+  sig { returns(String) }
+  def workflow_type; end
+end
+
+class Temporalio::Client::WorkflowExecution::Description < ::Temporalio::Client::WorkflowExecution
+  sig { params(raw_description: Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionResponse, data_converter: Temporalio::Converters::DataConverter).void }
+  def initialize(raw_description, data_converter); end
+
+  sig { returns(Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionResponse) }
+  attr_reader :raw_description
+
+  sig { returns(T.nilable(String)) }
+  def static_summary; end
+
+  sig { returns(T.nilable(String)) }
+  def static_details; end
+end

data/rbi/temporalio/client/workflow_execution_count.rbi

@@ -0,0 +1,23 @@
+# typed: true
+
+class Temporalio::Client::WorkflowExecutionCount
+  sig { params(count: Integer, groups: T::Array[Temporalio::Client::WorkflowExecutionCount::AggregationGroup]).void }
+  def initialize(count, groups); end
+
+  sig { returns(Integer) }
+  attr_reader :count
+
+  sig { returns(T::Array[Temporalio::Client::WorkflowExecutionCount::AggregationGroup]) }
+  attr_reader :groups
+end
+
+class Temporalio::Client::WorkflowExecutionCount::AggregationGroup
+  sig { params(count: Integer, group_values: T::Array[T.nilable(Object)]).void }
+  def initialize(count, group_values); end
+
+  sig { returns(Integer) }
+  attr_reader :count
+
+  sig { returns(T::Array[T.nilable(Object)]) }
+  attr_reader :group_values
+end

data/rbi/temporalio/client/workflow_execution_status.rbi

@@ -0,0 +1,11 @@
+# typed: true
+
+module Temporalio::Client::WorkflowExecutionStatus
+  RUNNING = T.let(T.unsafe(nil), Integer)
+  COMPLETED = T.let(T.unsafe(nil), Integer)
+  FAILED = T.let(T.unsafe(nil), Integer)
+  CANCELED = T.let(T.unsafe(nil), Integer)
+  TERMINATED = T.let(T.unsafe(nil), Integer)
+  CONTINUED_AS_NEW = T.let(T.unsafe(nil), Integer)
+  TIMED_OUT = T.let(T.unsafe(nil), Integer)
+end

data/rbi/temporalio/client/workflow_handle.rbi

@@ -0,0 +1,148 @@
+# typed: true
+
+class Temporalio::Client::WorkflowHandle
+  sig do
+    params(
+      client: Temporalio::Client,
+      id: String,
+      run_id: T.nilable(String),
+      result_run_id: T.nilable(String),
+      first_execution_run_id: T.nilable(String),
+      result_hint: T.nilable(Object)
+    ).void
+  end
+  def initialize(client:, id:, run_id:, result_run_id:, first_execution_run_id:, result_hint:); end
+
+  sig { returns(String) }
+  attr_reader :id
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :run_id
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :result_run_id
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :first_execution_run_id
+
+  sig { returns(T.nilable(Object)) }
+  attr_reader :result_hint
+
+  sig do
+    params(
+      follow_runs: T::Boolean,
+      result_hint: T.nilable(Object),
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(T.nilable(Object))
+  end
+  def result(follow_runs: T.unsafe(nil), result_hint: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(Temporalio::Client::WorkflowExecution::Description)
+  end
+  def describe(rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      event_filter_type: Integer,
+      skip_archival: T::Boolean,
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(Temporalio::WorkflowHistory)
+  end
+  def fetch_history(event_filter_type: T.unsafe(nil), skip_archival: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      wait_new_event: T::Boolean,
+      event_filter_type: Integer,
+      skip_archival: T::Boolean,
+      specific_run_id: T.nilable(String),
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(T::Enumerator[Temporalio::Api::History::V1::HistoryEvent])
+  end
+  def fetch_history_events(
+    wait_new_event: T.unsafe(nil),
+    event_filter_type: T.unsafe(nil),
+    skip_archival: T.unsafe(nil),
+    specific_run_id: T.unsafe(nil),
+    rpc_options: T.unsafe(nil)
+  ); end
+
+  sig do
+    params(
+      signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String),
+      args: T.nilable(Object),
+      arg_hints: T.nilable(T::Array[Object]),
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).void
+  end
+  def signal(signal, *args, arg_hints: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      query: T.any(Temporalio::Workflow::Definition::Query, Symbol, String),
+      args: T.nilable(Object),
+      reject_condition: T.nilable(Integer),
+      arg_hints: T.nilable(T::Array[Object]),
+      result_hint: T.nilable(Object),
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(T.nilable(Object))
+  end
+  def query(query, *args, reject_condition: T.unsafe(nil), arg_hints: T.unsafe(nil), result_hint: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      update: T.any(Temporalio::Workflow::Definition::Update, Symbol, String),
+      args: T.nilable(Object),
+      wait_for_stage: Integer,
+      id: String,
+      arg_hints: T.nilable(T::Array[Object]),
+      result_hint: T.nilable(Object),
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(Temporalio::Client::WorkflowUpdateHandle)
+  end
+  def start_update(
+    update,
+    *args,
+    wait_for_stage:,
+    id: T.unsafe(nil),
+    arg_hints: T.unsafe(nil),
+    result_hint: T.unsafe(nil),
+    rpc_options: T.unsafe(nil)
+  ); end
+
+  sig do
+    params(
+      update: T.any(Temporalio::Workflow::Definition::Update, Symbol, String),
+      args: T.nilable(Object),
+      id: String,
+      arg_hints: T.nilable(T::Array[Object]),
+      result_hint: T.nilable(Object),
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(T.nilable(Object))
+  end
+  def execute_update(update, *args, id: T.unsafe(nil), arg_hints: T.unsafe(nil), result_hint: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      id: String,
+      specific_run_id: T.nilable(String),
+      result_hint: T.nilable(Object)
+    ).returns(Temporalio::Client::WorkflowUpdateHandle)
+  end
+  def update_handle(id, specific_run_id: T.unsafe(nil), result_hint: T.unsafe(nil)); end
+
+  sig { params(rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void }
+  def cancel(rpc_options: T.unsafe(nil)); end
+
+  sig do
+    params(
+      reason: T.nilable(String),
+      details: T::Array[T.nilable(Object)],
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).void
+  end
+  def terminate(reason = T.unsafe(nil), details: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+end

data/rbi/temporalio/client/workflow_query_reject_condition.rbi

@@ -0,0 +1,7 @@
+# typed: true
+
+module Temporalio::Client::WorkflowQueryRejectCondition
+  NONE = T.let(T.unsafe(nil), Integer)
+  NOT_OPEN = T.let(T.unsafe(nil), Integer)
+  NOT_COMPLETED_CLEANLY = T.let(T.unsafe(nil), Integer)
+end

data/rbi/temporalio/client/workflow_update_handle.rbi

@@ -0,0 +1,38 @@
+# typed: true
+
+class Temporalio::Client::WorkflowUpdateHandle
+  sig do
+    params(
+      client: Temporalio::Client,
+      id: String,
+      workflow_id: String,
+      workflow_run_id: T.nilable(String),
+      known_outcome: T.nilable(Object),
+      result_hint: T.nilable(Object)
+    ).void
+  end
+  def initialize(client:, id:, workflow_id:, workflow_run_id:, known_outcome:, result_hint:); end
+
+  sig { returns(String) }
+  attr_reader :id
+
+  sig { returns(String) }
+  attr_reader :workflow_id
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :workflow_run_id
+
+  sig { returns(T.nilable(Object)) }
+  attr_reader :result_hint
+
+  sig { returns(T::Boolean) }
+  def result_obtained?; end
+
+  sig do
+    params(
+      result_hint: T.nilable(Object),
+      rpc_options: T.nilable(Temporalio::Client::RPCOptions)
+    ).returns(T.nilable(Object))
+  end
+  def result(result_hint: T.unsafe(nil), rpc_options: T.unsafe(nil)); end
+end

data/rbi/temporalio/client/workflow_update_wait_stage.rbi

@@ -0,0 +1,7 @@
+# typed: true
+
+module Temporalio::Client::WorkflowUpdateWaitStage
+  ADMITTED = T.let(T.unsafe(nil), Integer)
+  ACCEPTED = T.let(T.unsafe(nil), Integer)
+  COMPLETED = T.let(T.unsafe(nil), Integer)
+end