temporalio 1.5.0 → 1.6.0

data/rbi/temporalio/converters/failure_converter.rbi

@@ -0,0 +1,20 @@
+# typed: true
+
+class Temporalio::Converters::FailureConverter
+  extend T::Sig
+
+  sig { returns(Temporalio::Converters::FailureConverter) }
+  def self.default; end
+
+  sig { params(encode_common_attributes: T::Boolean).void }
+  def initialize(encode_common_attributes: T.unsafe(nil)); end
+
+  sig { returns(T::Boolean) }
+  attr_reader :encode_common_attributes
+
+  sig { params(error: Exception, converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)).returns(Temporalio::Api::Failure::V1::Failure) }
+  def to_failure(error, converter); end
+
+  sig { params(failure: Temporalio::Api::Failure::V1::Failure, converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)).returns(Exception) }
+  def from_failure(failure, converter); end
+end

data/rbi/temporalio/converters/payload_codec.rbi

@@ -0,0 +1,11 @@
+# typed: true
+
+class Temporalio::Converters::PayloadCodec
+  extend T::Sig
+
+  sig { params(payloads: T::Enumerable[Temporalio::Api::Common::V1::Payload]).returns(T::Array[Temporalio::Api::Common::V1::Payload]) }
+  def encode(payloads); end
+
+  sig { params(payloads: T::Enumerable[Temporalio::Api::Common::V1::Payload]).returns(T::Array[Temporalio::Api::Common::V1::Payload]) }
+  def decode(payloads); end
+end

data/rbi/temporalio/converters/payload_converter/binary_null.rbi

@@ -0,0 +1,5 @@
+# typed: true
+
+class Temporalio::Converters::PayloadConverter::BinaryNull < ::Temporalio::Converters::PayloadConverter::Encoding
+  ENCODING = T.let(T.unsafe(nil), String)
+end

data/rbi/temporalio/converters/payload_converter/binary_plain.rbi

@@ -0,0 +1,5 @@
+# typed: true
+
+class Temporalio::Converters::PayloadConverter::BinaryPlain < ::Temporalio::Converters::PayloadConverter::Encoding
+  ENCODING = T.let(T.unsafe(nil), String)
+end

data/rbi/temporalio/converters/payload_converter/binary_protobuf.rbi

@@ -0,0 +1,5 @@
+# typed: true
+
+class Temporalio::Converters::PayloadConverter::BinaryProtobuf < ::Temporalio::Converters::PayloadConverter::Encoding
+  ENCODING = T.let(T.unsafe(nil), String)
+end

data/rbi/temporalio/converters/payload_converter/composite.rbi

@@ -0,0 +1,20 @@
+# typed: true
+
+class Temporalio::Converters::PayloadConverter::Composite < ::Temporalio::Converters::PayloadConverter
+  extend T::Sig
+
+  sig { returns(T::Hash[String, Temporalio::Converters::PayloadConverter::Encoding]) }
+  attr_reader :converters
+
+  sig { params(converters: Temporalio::Converters::PayloadConverter::Encoding).void }
+  def initialize(*converters); end
+
+  sig { params(value: T.nilable(Object), hint: T.nilable(Object)).returns(Temporalio::Api::Common::V1::Payload) }
+  def to_payload(value, hint: T.unsafe(nil)); end
+
+  sig { params(payload: T.nilable(Temporalio::Api::Common::V1::Payload), hint: T.nilable(Object)).returns(T.nilable(Object)) }
+  def from_payload(payload, hint: T.unsafe(nil)); end
+
+  class ConverterNotFound < ::Temporalio::Error; end
+  class EncodingNotSet < ::Temporalio::Error; end
+end

data/rbi/temporalio/converters/payload_converter/encoding.rbi

@@ -0,0 +1,14 @@
+# typed: true
+
+class Temporalio::Converters::PayloadConverter::Encoding
+  extend T::Sig
+
+  sig { returns(String) }
+  def encoding; end
+
+  sig { params(value: T.nilable(Object), hint: T.nilable(Object)).returns(T.nilable(Temporalio::Api::Common::V1::Payload)) }
+  def to_payload(value, hint: T.unsafe(nil)); end
+
+  sig { params(payload: T.nilable(Temporalio::Api::Common::V1::Payload), hint: T.nilable(Object)).returns(T.nilable(Object)) }
+  def from_payload(payload, hint: T.unsafe(nil)); end
+end

data/rbi/temporalio/converters/payload_converter/json_plain.rbi

@@ -0,0 +1,10 @@
+# typed: true
+
+class Temporalio::Converters::PayloadConverter::JSONPlain < ::Temporalio::Converters::PayloadConverter::Encoding
+  extend T::Sig
+
+  ENCODING = T.let(T.unsafe(nil), String)
+
+  sig { params(parse_options: T::Hash[Symbol, Object], generate_options: T::Hash[Symbol, Object]).void }
+  def initialize(parse_options: T.unsafe(nil), generate_options: T.unsafe(nil)); end
+end

data/rbi/temporalio/converters/payload_converter/json_protobuf.rbi

@@ -0,0 +1,5 @@
+# typed: true
+
+class Temporalio::Converters::PayloadConverter::JSONProtobuf < ::Temporalio::Converters::PayloadConverter::Encoding
+  ENCODING = T.let(T.unsafe(nil), String)
+end

data/rbi/temporalio/converters/payload_converter.rbi

@@ -0,0 +1,28 @@
+# typed: true
+
+class Temporalio::Converters::PayloadConverter
+  extend T::Sig
+
+  sig { returns(Temporalio::Converters::PayloadConverter::Composite) }
+  def self.default; end
+
+  sig do
+    params(
+      json_parse_options: T::Hash[Symbol, Object],
+      json_generate_options: T::Hash[Symbol, Object]
+    ).returns(Temporalio::Converters::PayloadConverter::Composite)
+  end
+  def self.new_with_defaults(json_parse_options: T.unsafe(nil), json_generate_options: T.unsafe(nil)); end
+
+  sig { params(value: T.nilable(Object), hint: T.nilable(Object)).returns(Temporalio::Api::Common::V1::Payload) }
+  def to_payload(value, hint: T.unsafe(nil)); end
+
+  sig { params(values: T::Array[T.nilable(Object)], hints: T.nilable(T::Array[Object])).returns(Temporalio::Api::Common::V1::Payloads) }
+  def to_payloads(values, hints: T.unsafe(nil)); end
+
+  sig { params(payload: Temporalio::Api::Common::V1::Payload, hint: T.nilable(Object)).returns(T.nilable(Object)) }
+  def from_payload(payload, hint: T.unsafe(nil)); end
+
+  sig { params(payloads: T.nilable(Temporalio::Api::Common::V1::Payloads), hints: T.nilable(T::Array[Object])).returns(T::Array[T.nilable(Object)]) }
+  def from_payloads(payloads, hints: T.unsafe(nil)); end
+end

data/rbi/temporalio/converters/raw_value.rbi

@@ -0,0 +1,11 @@
+# typed: true
+
+class Temporalio::Converters::RawValue
+  extend T::Sig
+
+  sig { returns(Temporalio::Api::Common::V1::Payload) }
+  attr_reader :payload
+
+  sig { params(payload: Temporalio::Api::Common::V1::Payload).void }
+  def initialize(payload); end
+end

data/rbi/temporalio/converters.rbi

@@ -0,0 +1,3 @@
+# typed: true
+
+module Temporalio::Converters; end

data/rbi/temporalio/env_config.rbi

@@ -0,0 +1,156 @@
+# typed: true
+
+module Temporalio::EnvConfig; end
+
+class Temporalio::EnvConfig::ClientConfigTLS < ::Data
+  extend T::Sig
+
+  sig { returns(T.nilable(T::Boolean)) }
+  def disabled; end
+
+  sig { returns(T.nilable(String)) }
+  def server_name; end
+
+  sig { returns(T.nilable(T.any(Pathname, String))) }
+  def server_root_ca_cert; end
+
+  sig { returns(T.nilable(T.any(Pathname, String))) }
+  def client_cert; end
+
+  sig { returns(T.nilable(T.any(Pathname, String))) }
+  def client_private_key; end
+
+  sig do
+    params(
+      disabled: T.nilable(T::Boolean),
+      server_name: T.nilable(String),
+      server_root_ca_cert: T.nilable(T.any(Pathname, String)),
+      client_cert: T.nilable(T.any(Pathname, String)),
+      client_private_key: T.nilable(T.any(Pathname, String))
+    ).void
+  end
+  def initialize(
+    disabled: T.unsafe(nil),
+    server_name: T.unsafe(nil),
+    server_root_ca_cert: T.unsafe(nil),
+    client_cert: T.unsafe(nil),
+    client_private_key: T.unsafe(nil)
+  ); end
+
+  sig { returns(T::Hash[Symbol, Object]) }
+  def to_h; end
+
+  sig { returns(T.any(Temporalio::Client::Connection::TLSOptions, FalseClass)) }
+  def to_client_tls_options; end
+
+  sig { params(hash: T.nilable(T::Hash[Symbol, Object])).returns(T.nilable(Temporalio::EnvConfig::ClientConfigTLS)) }
+  def self.from_h(hash); end
+end
+
+class Temporalio::EnvConfig::ClientConfigProfile < ::Data
+  extend T::Sig
+
+  sig { returns(T.nilable(String)) }
+  def address; end
+
+  sig { returns(T.nilable(String)) }
+  def namespace; end
+
+  sig { returns(T.nilable(String)) }
+  def api_key; end
+
+  sig { returns(T.nilable(Temporalio::EnvConfig::ClientConfigTLS)) }
+  def tls; end
+
+  sig { returns(T::Hash[String, String]) }
+  def grpc_meta; end
+
+  sig do
+    params(
+      address: T.nilable(String),
+      namespace: T.nilable(String),
+      api_key: T.nilable(String),
+      tls: T.nilable(Temporalio::EnvConfig::ClientConfigTLS),
+      grpc_meta: T::Hash[String, String]
+    ).void
+  end
+  def initialize(
+    address: T.unsafe(nil),
+    namespace: T.unsafe(nil),
+    api_key: T.unsafe(nil),
+    tls: T.unsafe(nil),
+    grpc_meta: T.unsafe(nil)
+  ); end
+
+  sig { params(hash: T::Hash[Symbol, Object]).returns(Temporalio::EnvConfig::ClientConfigProfile) }
+  def self.from_h(hash); end
+
+  sig do
+    params(
+      profile: T.nilable(String),
+      config_source: T.nilable(T.any(Pathname, String)),
+      disable_file: T::Boolean,
+      disable_env: T::Boolean,
+      config_file_strict: T::Boolean,
+      override_env_vars: T.nilable(T::Hash[String, String])
+    ).returns(Temporalio::EnvConfig::ClientConfigProfile)
+  end
+  def self.load(
+    profile: T.unsafe(nil),
+    config_source: T.unsafe(nil),
+    disable_file: T.unsafe(nil),
+    disable_env: T.unsafe(nil),
+    config_file_strict: T.unsafe(nil),
+    override_env_vars: T.unsafe(nil)
+  ); end
+
+  sig { returns(T::Hash[Symbol, Object]) }
+  def to_h; end
+
+  sig { returns([T::Array[T.nilable(String)], T::Hash[Symbol, Object]]) }
+  def to_client_connect_options; end
+end
+
+class Temporalio::EnvConfig::ClientConfig < ::Data
+  extend T::Sig
+
+  sig { returns(T::Hash[String, Temporalio::EnvConfig::ClientConfigProfile]) }
+  def profiles; end
+
+  sig { params(profiles: T::Hash[String, Temporalio::EnvConfig::ClientConfigProfile]).void }
+  def initialize(profiles: T.unsafe(nil)); end
+
+  sig { params(hash: T::Hash[String, T::Hash[Symbol, Object]]).returns(Temporalio::EnvConfig::ClientConfig) }
+  def self.from_h(hash); end
+
+  sig do
+    params(
+      config_source: T.nilable(T.any(Pathname, String)),
+      config_file_strict: T::Boolean,
+      override_env_vars: T.nilable(T::Hash[String, String])
+    ).returns(Temporalio::EnvConfig::ClientConfig)
+  end
+  def self.load(config_source: T.unsafe(nil), config_file_strict: T.unsafe(nil), override_env_vars: T.unsafe(nil)); end
+
+  sig do
+    params(
+      profile: T.nilable(String),
+      config_source: T.nilable(T.any(Pathname, 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::Array[T.nilable(String)], T::Hash[Symbol, Object]])
+  end
+  def self.load_client_connect_options(
+    profile: T.unsafe(nil),
+    config_source: T.unsafe(nil),
+    disable_file: T.unsafe(nil),
+    disable_env: T.unsafe(nil),
+    config_file_strict: T.unsafe(nil),
+    override_env_vars: T.unsafe(nil)
+  ); end
+
+  sig { override(allow_incompatible: true).returns(T::Hash[String, T::Hash[Symbol, Object]]) }
+  def to_h; end
+end

data/rbi/temporalio/error/failure.rbi

@@ -0,0 +1,3 @@
+# typed: true
+
+class Temporalio::Error::Failure < ::Temporalio::Error; end

data/rbi/temporalio/error.rbi

@@ -0,0 +1,313 @@
+# typed: true
+
+class Temporalio::Error < ::StandardError
+  sig { params(error: Exception).returns(T::Boolean) }
+  def self.canceled?(error); end
+end
+
+class Temporalio::Error::WorkflowAlreadyStartedError < ::Temporalio::Error::Failure
+  sig { params(workflow_id: String, workflow_type: String, run_id: T.nilable(String)).void }
+  def initialize(workflow_id:, workflow_type:, run_id:); end
+
+  sig { returns(String) }
+  attr_reader :workflow_id
+
+  sig { returns(String) }
+  attr_reader :workflow_type
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :run_id
+end
+
+class Temporalio::Error::ApplicationError < ::Temporalio::Error::Failure
+  sig do
+    params(
+      message: String,
+      details: T.nilable(Object),
+      type: T.nilable(String),
+      non_retryable: T::Boolean,
+      next_retry_delay: T.nilable(T.any(Integer, Float)),
+      category: Integer
+    ).void
+  end
+  def initialize(message, *details, type: nil, non_retryable: false, next_retry_delay: nil, category: T.unsafe(nil)); end
+
+  sig { returns(T::Array[T.nilable(Object)]) }
+  attr_reader :details
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :type
+
+  sig { returns(T::Boolean) }
+  attr_reader :non_retryable
+
+  sig { returns(T.nilable(T.any(Integer, Float))) }
+  attr_reader :next_retry_delay
+
+  sig { returns(Integer) }
+  attr_reader :category
+
+  sig { returns(T::Boolean) }
+  def retryable?; end
+end
+
+module Temporalio::Error::ApplicationError::Category
+  UNSPECIFIED = T.let(T.unsafe(nil), Integer)
+  BENIGN = T.let(T.unsafe(nil), Integer)
+end
+
+class Temporalio::Error::CanceledError < ::Temporalio::Error::Failure
+  sig { params(message: String, details: T::Array[T.nilable(Object)]).void }
+  def initialize(message, details: []); end
+
+  sig { returns(T::Array[T.nilable(Object)]) }
+  attr_reader :details
+end
+
+class Temporalio::Error::TerminatedError < ::Temporalio::Error::Failure
+  sig { params(message: String, details: T::Array[T.nilable(Object)]).void }
+  def initialize(message, details:); end
+
+  sig { returns(T::Array[T.nilable(Object)]) }
+  attr_reader :details
+end
+
+class Temporalio::Error::TimeoutError < ::Temporalio::Error::Failure
+  sig do
+    params(
+      message: String,
+      type: Integer,
+      last_heartbeat_details: T::Array[T.nilable(Object)]
+    ).void
+  end
+  def initialize(message, type:, last_heartbeat_details:); end
+
+  sig { returns(Integer) }
+  attr_reader :type
+
+  sig { returns(T::Array[T.nilable(Object)]) }
+  attr_reader :last_heartbeat_details
+end
+
+module Temporalio::Error::TimeoutError::TimeoutType
+  START_TO_CLOSE = T.let(T.unsafe(nil), Integer)
+  SCHEDULE_TO_START = T.let(T.unsafe(nil), Integer)
+  SCHEDULE_TO_CLOSE = T.let(T.unsafe(nil), Integer)
+  HEARTBEAT = T.let(T.unsafe(nil), Integer)
+end
+
+class Temporalio::Error::ServerError < ::Temporalio::Error::Failure
+  sig { params(message: String, non_retryable: T::Boolean).void }
+  def initialize(message, non_retryable:); end
+
+  sig { returns(T::Boolean) }
+  attr_reader :non_retryable
+
+  sig { returns(T::Boolean) }
+  def retryable?; end
+end
+
+module Temporalio::Error::RetryState
+  IN_PROGRESS = T.let(T.unsafe(nil), Integer)
+  NON_RETRYABLE_FAILURE = T.let(T.unsafe(nil), Integer)
+  TIMEOUT = T.let(T.unsafe(nil), Integer)
+  MAXIMUM_ATTEMPTS_REACHED = T.let(T.unsafe(nil), Integer)
+  RETRY_POLICY_NOT_SET = T.let(T.unsafe(nil), Integer)
+  INTERNAL_SERVER_ERROR = T.let(T.unsafe(nil), Integer)
+  CANCEL_REQUESTED = T.let(T.unsafe(nil), Integer)
+end
+
+class Temporalio::Error::ActivityError < ::Temporalio::Error::Failure
+  sig do
+    params(
+      message: String,
+      scheduled_event_id: Integer,
+      started_event_id: Integer,
+      identity: String,
+      activity_type: String,
+      activity_id: String,
+      retry_state: T.nilable(Integer)
+    ).void
+  end
+  def initialize(message, scheduled_event_id:, started_event_id:, identity:, activity_type:, activity_id:, retry_state:); end
+
+  sig { returns(Integer) }
+  attr_reader :scheduled_event_id
+
+  sig { returns(Integer) }
+  attr_reader :started_event_id
+
+  sig { returns(String) }
+  attr_reader :identity
+
+  sig { returns(String) }
+  attr_reader :activity_type
+
+  sig { returns(String) }
+  attr_reader :activity_id
+
+  sig { returns(T.nilable(Integer)) }
+  attr_reader :retry_state
+end
+
+class Temporalio::Error::ChildWorkflowError < ::Temporalio::Error::Failure
+  sig do
+    params(
+      message: String,
+      namespace: String,
+      workflow_id: String,
+      run_id: String,
+      workflow_type: String,
+      initiated_event_id: Integer,
+      started_event_id: Integer,
+      retry_state: T.nilable(Integer)
+    ).void
+  end
+  def initialize(message, namespace:, workflow_id:, run_id:, workflow_type:, initiated_event_id:, started_event_id:, retry_state:); end
+
+  sig { returns(String) }
+  attr_reader :namespace
+
+  sig { returns(String) }
+  attr_reader :workflow_id
+
+  sig { returns(String) }
+  attr_reader :run_id
+
+  sig { returns(String) }
+  attr_reader :workflow_type
+
+  sig { returns(Integer) }
+  attr_reader :initiated_event_id
+
+  sig { returns(Integer) }
+  attr_reader :started_event_id
+
+  sig { returns(T.nilable(Integer)) }
+  attr_reader :retry_state
+end
+
+class Temporalio::Error::NexusOperationError < ::Temporalio::Error::Failure
+  sig do
+    params(
+      message: String,
+      endpoint: String,
+      service: String,
+      operation: String,
+      operation_token: T.nilable(String)
+    ).void
+  end
+  def initialize(message, endpoint:, service:, operation:, operation_token:); end
+
+  sig { returns(String) }
+  attr_reader :endpoint
+
+  sig { returns(String) }
+  attr_reader :service
+
+  sig { returns(String) }
+  attr_reader :operation
+
+  sig { returns(T.nilable(String)) }
+  attr_reader :operation_token
+end
+
+class Temporalio::Error::NexusHandlerError < ::Temporalio::Error::Failure
+  sig do
+    params(
+      message: String,
+      error_type: T.any(Symbol, String),
+      retry_behavior: Integer
+    ).void
+  end
+  def initialize(message, error_type:, retry_behavior:); end
+
+  sig { returns(Symbol) }
+  attr_reader :error_type
+
+  sig { returns(Integer) }
+  attr_reader :retry_behavior
+end
+
+module Temporalio::Error::NexusHandlerError::RetryBehavior
+  UNSPECIFIED = T.let(T.unsafe(nil), Integer)
+  RETRYABLE = T.let(T.unsafe(nil), Integer)
+  NON_RETRYABLE = T.let(T.unsafe(nil), Integer)
+end
+
+class Temporalio::Error::AsyncActivityCanceledError < ::Temporalio::Error
+  sig { params(details: Temporalio::Activity::CancellationDetails).void }
+  def initialize(details); end
+
+  sig { returns(Temporalio::Activity::CancellationDetails) }
+  attr_reader :details
+end
+
+class Temporalio::Error::WorkflowFailedError < ::Temporalio::Error
+  sig { params(message: T.nilable(String)).void }
+  def initialize(message = nil); end
+end
+
+class Temporalio::Error::WorkflowContinuedAsNewError < ::Temporalio::Error
+  sig { params(new_run_id: String).void }
+  def initialize(new_run_id:); end
+
+  sig { returns(String) }
+  attr_reader :new_run_id
+end
+
+class Temporalio::Error::WorkflowQueryFailedError < ::Temporalio::Error; end
+
+class Temporalio::Error::WorkflowQueryRejectedError < ::Temporalio::Error
+  sig { params(status: Integer).void }
+  def initialize(status:); end
+
+  sig { returns(Integer) }
+  attr_reader :status
+end
+
+class Temporalio::Error::WorkflowUpdateFailedError < ::Temporalio::Error
+  sig { void }
+  def initialize; end
+end
+
+class Temporalio::Error::WorkflowUpdateRPCTimeoutOrCanceledError < ::Temporalio::Error
+  sig { void }
+  def initialize; end
+end
+
+class Temporalio::Error::ScheduleAlreadyRunningError < ::Temporalio::Error
+  sig { void }
+  def initialize; end
+end
+
+class Temporalio::Error::RPCError < ::Temporalio::Error
+  sig { params(message: String, code: Integer, raw_grpc_status: T.nilable(Object)).void }
+  def initialize(message, code:, raw_grpc_status:); end
+
+  sig { returns(Integer) }
+  attr_reader :code
+
+  sig { returns(Temporalio::Api::Common::V1::GrpcStatus) }
+  def grpc_status; end
+end
+
+module Temporalio::Error::RPCError::Code
+  OK = T.let(T.unsafe(nil), Integer)
+  CANCELED = T.let(T.unsafe(nil), Integer)
+  UNKNOWN = T.let(T.unsafe(nil), Integer)
+  INVALID_ARGUMENT = T.let(T.unsafe(nil), Integer)
+  DEADLINE_EXCEEDED = T.let(T.unsafe(nil), Integer)
+  NOT_FOUND = T.let(T.unsafe(nil), Integer)
+  ALREADY_EXISTS = T.let(T.unsafe(nil), Integer)
+  PERMISSION_DENIED = T.let(T.unsafe(nil), Integer)
+  RESOURCE_EXHAUSTED = T.let(T.unsafe(nil), Integer)
+  FAILED_PRECONDITION = T.let(T.unsafe(nil), Integer)
+  ABORTED = T.let(T.unsafe(nil), Integer)
+  OUT_OF_RANGE = T.let(T.unsafe(nil), Integer)
+  UNIMPLEMENTED = T.let(T.unsafe(nil), Integer)
+  INTERNAL = T.let(T.unsafe(nil), Integer)
+  UNAVAILABLE = T.let(T.unsafe(nil), Integer)
+  DATA_LOSS = T.let(T.unsafe(nil), Integer)
+  UNAUTHENTICATED = T.let(T.unsafe(nil), Integer)
+end