temporalio 0.1.0 → 0.1.1

data/sig/temporalio/payload_converter/composite.rbs

@@ -0,0 +1,19 @@
+module Temporalio
+  module PayloadConverter
+    class Composite < Base
+      class ConverterNotFound < Temporalio::Error
+      end
+
+      class EncodingNotSet < Temporalio::Error
+      end
+
+      include _PayloadConverter
+
+      def initialize: (*_EncodingPayloadConverter converters) -> void
+
+      private
+
+      attr_reader converters: Hash[String, _EncodingPayloadConverter]
+    end
+  end
+end

data/sig/temporalio/payload_converter/encoding_base.rbs

@@ -0,0 +1,14 @@
+module Temporalio
+  module PayloadConverter
+    interface _EncodingPayloadConverter
+      def class: -> Class
+      def encoding: -> String
+      def to_payload: (untyped) -> Temporalio::Api::Common::V1::Payload?
+      def from_payload: (Temporalio::Api::Common::V1::Payload) -> untyped
+    end
+
+    class EncodingBase
+      include _EncodingPayloadConverter
+    end
+  end
+end

data/sig/temporalio/payload_converter/json.rbs

@@ -0,0 +1,9 @@
+module Temporalio
+  module PayloadConverter
+    class JSON
+      include _EncodingPayloadConverter
+
+      ENCODING: String
+    end
+  end
+end

data/sig/temporalio/payload_converter/nil.rbs

@@ -0,0 +1,9 @@
+module Temporalio
+  module PayloadConverter
+    class Nil
+      include _EncodingPayloadConverter
+
+      ENCODING: String
+    end
+  end
+end

data/sig/temporalio/payload_converter.rbs

@@ -0,0 +1,5 @@
+module Temporalio
+  module PayloadConverter
+    DEFAULT: _PayloadConverter
+  end
+end

data/sig/temporalio/retry_policy.rbs

@@ -0,0 +1,25 @@
+module Temporalio
+  class RetryPolicy
+    Invalid: Temporalio::Error
+
+    attr_reader initial_interval: Integer
+    attr_reader backoff: Float
+    attr_reader max_interval: Integer?
+    attr_reader max_attempts: Integer
+    attr_reader non_retriable_errors: Array[String]
+
+    def self.from_proto: (Temporalio::Api::Common::V1::RetryPolicy) -> RetryPolicy
+
+    def initialize: (
+      ?initial_interval: Integer,
+      ?backoff: Float,
+      ?max_interval: Integer?,
+      ?max_attempts: Integer,
+      ?non_retriable_errors: Array[Class | String]
+    ) -> void
+
+    def validate!: -> nil
+
+    def to_proto: -> Temporalio::Api::Common::V1::RetryPolicy
+  end
+end

data/sig/temporalio/retry_state.rbs

@@ -0,0 +1,20 @@
+module Temporalio
+  module RetryState
+    type values =
+      :IN_PROGRESS | :NON_RETRYABLE_FAILURE | :TIMEOUT | :MAXIMUM_ATTEMPTS_REACHED |
+      :RETRY_POLICY_NOT_SET | :INTERNAL_SERVER_ERROR | :CANCEL_REQUESTED
+
+    IN_PROGRESS: :IN_PROGRESS
+    NON_RETRYABLE_FAILURE: :NON_RETRYABLE_FAILURE
+    TIMEOUT: :TIMEOUT
+    MAXIMUM_ATTEMPTS_REACHED: :MAXIMUM_ATTEMPTS_REACHED
+    RETRY_POLICY_NOT_SET: :RETRY_POLICY_NOT_SET
+    INTERNAL_SERVER_ERROR: :INTERNAL_SERVER_ERROR
+    CANCEL_REQUESTED: :CANCEL_REQUESTED
+    STATES: Array[values]
+    API_MAP: Hash[Temporalio::Api::Enums::V1::RetryState::init, values]
+
+    def self.to_raw: (values) -> Temporalio::Api::Enums::V1::RetryState::init
+    def self.from_raw: (Temporalio::Api::Enums::V1::RetryState::init) -> values
+  end
+end

data/sig/temporalio/runtime.rbs

@@ -0,0 +1,12 @@
+module Temporalio
+  class Runtime
+    attr_reader core_runtime: Temporalio::Bridge::Runtime
+    attr_reader reactor: Temporalio::Worker::Reactor
+
+    @thread: Thread
+
+    def self.instance: () -> Runtime
+    def initialize: () -> void
+    def ensure_callback_loop: () -> void
+  end
+end

data/sig/temporalio/testing/time_skipping_handle.rbs

@@ -0,0 +1,15 @@
+module Temporalio
+  module Testing
+    class TimeSkippingHandle
+      extend Forwardable
+      include Temporalio::Client::WorkflowHandle::_Interface
+
+      def initialize: (Temporalio::Client::WorkflowHandle, Temporalio::Testing::WorkflowEnvironment) -> void
+
+      private
+
+      attr_reader handle: Temporalio::Client::WorkflowHandle
+      attr_reader env: Temporalio::Testing::WorkflowEnvironment
+    end
+  end
+end

data/sig/temporalio/testing/time_skipping_interceptor.rbs

@@ -0,0 +1,13 @@
+module Temporalio
+  module Testing
+    class TimeSkippingInterceptor
+      include Temporalio::Interceptor::Client
+
+      def initialize: (Temporalio::Testing::WorkflowEnvironment env) -> void
+
+      private
+
+      attr_reader env: Temporalio::Testing::WorkflowEnvironment
+    end
+  end
+end

data/sig/temporalio/testing/workflow_environment.rbs

@@ -0,0 +1,22 @@
+module Temporalio
+  module Testing
+    class WorkflowEnvironment
+      attr_reader connection: Temporalio::Connection
+      attr_reader namespace: String
+
+      def initialize: (Temporalio::Bridge::TestServer server, Temporalio::Connection connection, String namespace) -> void
+      def client: -> Temporalio::Client
+      def sleep: (Integer duration) -> void
+      def current_time: -> Time?
+      def supports_time_skipping?: -> bool
+      def shutdown: -> void
+      def with_time_skipping: { () -> untyped } -> untyped
+
+      private
+
+      @client: Temporalio::Client
+
+      attr_reader server: Temporalio::Bridge::TestServer
+    end
+  end
+end

data/sig/temporalio/testing.rbs

@@ -0,0 +1,35 @@
+module Temporalio
+  module Testing
+    DEFAULT_NAMESPACE: String
+
+    def self.start_local_environment: (
+      ?namespace: String,
+      ?ip: String,
+      ?port: Integer?,
+      ?download_dir: String?,
+      ?ui: bool,
+      ?temporalite_existing_path: String?,
+      ?temporalite_database_filename: String?,
+      ?temporalite_log_format: String,
+      ?temporalite_log_level: String,
+      ?temporalite_download_version: String,
+      ?temporalite_extra_args: Array[String]
+    ) { (Temporalio::Testing::WorkflowEnvironment) -> untyped } -> (Temporalio::Testing::WorkflowEnvironment | untyped)
+
+    def self.start_time_skipping_environment: (
+      ?port: Integer?,
+      ?download_dir: String?,
+      ?test_server_existing_path: String?,
+      ?test_server_download_version: String,
+      ?test_server_extra_args: Array[String]
+    ) { (Temporalio::Testing::WorkflowEnvironment) -> untyped } -> (Temporalio::Testing::WorkflowEnvironment | untyped)
+
+    private
+
+    def self.init_workflow_environment_for: (Temporalio::Bridge::TestServer server, String namespace) -> WorkflowEnvironment
+    def self.run_server: (
+      Temporalio::Bridge::TestServer server,
+      Temporalio::Testing::WorkflowEnvironment env
+    ) { (Temporalio::Testing::WorkflowEnvironment) -> untyped } -> void
+  end
+end

data/sig/temporalio/timeout_type.rbs

@@ -0,0 +1,15 @@
+module Temporalio
+  module TimeoutType
+    type values = :START_TO_CLOSE | :SCHEDULE_TO_START | :SCHEDULE_TO_CLOSE | :HEARTBEAT
+
+    START_TO_CLOSE: :START_TO_CLOSE
+    SCHEDULE_TO_START: :SCHEDULE_TO_START
+    SCHEDULE_TO_CLOSE: :SCHEDULE_TO_CLOSE
+    HEARTBEAT: :HEARTBEAT
+    TYPES: Array[values]
+    API_MAP: Hash[Temporalio::Api::Enums::V1::TimeoutType::init, values]
+
+    def self.to_raw: (values) -> Temporalio::Api::Enums::V1::TimeoutType::init
+    def self.from_raw: (Temporalio::Api::Enums::V1::TimeoutType::init) -> values
+  end
+end

data/sig/temporalio/version.rbs

@@ -0,0 +1,3 @@
+module Temporalio
+  VERSION: String
+end

data/sig/temporalio/worker/activity_runner.rbs

@@ -0,0 +1,35 @@
+module Temporalio
+  class Worker
+    class ActivityRunner
+      def initialize: (
+        singleton(Temporalio::Activity) activity_class,
+        Temporalio::Bridge::Api::ActivityTask::Start start,
+        String task_queue,
+        String task_token,
+        Temporalio::Worker::SyncWorker worker,
+        Temporalio::DataConverter converter,
+        Temporalio::Interceptor::Chain[Temporalio::Interceptor::ActivityInbound] inbound_interceptors,
+        Temporalio::Interceptor::Chain[Temporalio::Interceptor::ActivityOutbound] outbound_interceptors
+      ) -> void
+      def run: -> (Temporalio::Api::Common::V1::Payload | Temporalio::Api::Failure::V1::Failure)
+      def cancel: (String reason, by_request: bool) -> void
+
+      private
+
+      @context: Temporalio::Activity::Context
+
+      attr_reader activity_class: singleton(Temporalio::Activity)
+      attr_reader start: Temporalio::Bridge::Api::ActivityTask::Start
+      attr_reader task_queue: String
+      attr_reader task_token: String
+      attr_reader worker: Temporalio::Worker::SyncWorker
+      attr_reader converter: Temporalio::DataConverter
+      attr_reader inbound_interceptors: Temporalio::Interceptor::Chain[Temporalio::Interceptor::ActivityInbound]
+      attr_reader outbound_interceptors: Temporalio::Interceptor::Chain[Temporalio::Interceptor::ActivityOutbound]
+
+      def context: -> Temporalio::Activity::Context
+      def generate_activity_info: -> Temporalio::Activity::Info
+      def heartbeat: (*untyped) -> void
+    end
+  end
+end

data/sig/temporalio/worker/activity_worker.rbs

@@ -0,0 +1,44 @@
+module Temporalio
+  class Worker
+    class ActivityWorker
+      @cancelation_task: Async::Task?
+      @running: bool
+
+      def initialize: (
+        String task_queue,
+        Temporalio::Worker::SyncWorker worker,
+        Array[singleton(Temporalio::Activity)] activities,
+        Temporalio::DataConverter converter,
+        Array[Temporalio::Worker::worker_interceptor] interceptors,
+        Temporalio::Worker::_ActivityExecutor executor,
+        Integer? graceful_timeout
+      ) -> void
+      def run: (Async::Task reactor) -> void
+      def drain: -> void
+      def setup_graceful_shutdown_timer: (Temporalio::Worker::Reactor reactor) -> void
+
+      private
+
+      attr_reader task_queue: String
+      attr_reader worker: SyncWorker
+      attr_reader activities: Hash[String, singleton(Temporalio::Activity)]
+      attr_reader converter: Temporalio::DataConverter
+      attr_reader inbound_interceptors: Temporalio::Interceptor::Chain[Temporalio::Interceptor::ActivityInbound]
+      attr_reader outbound_interceptors: Temporalio::Interceptor::Chain[Temporalio::Interceptor::ActivityOutbound]
+      attr_reader executor: Temporalio::Worker::_ActivityExecutor
+      attr_reader graceful_timeout: Integer?
+      attr_reader running_activities: Hash[String, Temporalio::Worker::ActivityRunner]
+      attr_reader cancellations: Array[String]
+      attr_reader drain_queue: Thread::Queue
+
+      def running?: -> bool
+      def prepare_activities: (Array[singleton(Temporalio::Activity)] activities)
+        -> Hash[String, singleton(Temporalio::Activity)]
+      def lookup_activity: (String activity_type) -> singleton(Temporalio::Activity)
+      def run_activity: (String token, Temporalio::Bridge::Api::ActivityTask::Start task)
+        -> (Temporalio::Api::Common::V1::Payload | Temporalio::Api::Failure::V1::Failure)
+      def handle_start_activity: (String task_token, Temporalio::Bridge::Api::ActivityTask::Start task) -> void
+      def handle_cancel_activity: (String task_token, Temporalio::Bridge::Api::ActivityTask::Cancel task) -> void
+    end
+  end
+end

data/sig/temporalio/worker/reactor.rbs

@@ -0,0 +1,22 @@
+module Temporalio
+  class Worker
+    interface _Reactor
+      def async: { (Async::Task) -> void } -> void
+    end
+
+    class Reactor
+      include _Reactor
+
+      def initialize: -> void
+
+      private
+
+      attr_reader queue: Thread::Queue
+      attr_reader thread: Thread?
+      attr_reader mutex: Thread::Mutex
+
+      def ensure_reactor_thread: -> void
+      def run_loop: -> void
+    end
+  end
+end

data/sig/temporalio/worker/runner.rbs

@@ -0,0 +1,21 @@
+module Temporalio
+  class Worker
+    class Runner
+      @started: bool
+      @shutdown: bool
+
+      def initialize: (*Temporalio::Worker workers) -> void
+      def run: ?{ -> void } -> void
+      def shutdown: (?Exception exception) -> void
+
+      private
+
+      attr_reader workers: Array[Temporalio::Worker]
+      attr_reader mutex: Thread::Mutex
+      attr_reader thread: Thread
+
+      def running?: -> bool
+      def shutdown_workers: -> void
+    end
+  end
+end

data/sig/temporalio/worker/sync_worker.rbs

@@ -0,0 +1,23 @@
+module Temporalio
+  class Worker
+    class SyncWorker
+      def initialize: (Temporalio::Bridge::Worker core_worker) -> void
+      def poll_activity_task: -> Temporalio::Bridge::Api::ActivityTask::ActivityTask
+      def complete_activity_task_with_success: (String task_token, Temporalio::Api::Common::V1::Payload payload) -> void
+      def complete_activity_task_with_failure: (String task_token, Temporalio::Api::Failure::V1::Failure failure) -> void
+      def complete_activity_task_with_cancellation: (String task_token, Temporalio::Api::Failure::V1::Failure failure) -> void
+      def record_activity_heartbeat: (String task_token, Array[Temporalio::Api::Common::V1::Payload] payloads) -> void
+      def poll_workflow_activation: -> Temporalio::Bridge::Api::WorkflowActivation::WorkflowActivation
+      def complete_workflow_activation_with_success: (String, Array[Temporalio::Bridge::Api::WorkflowCommands::WorkflowCommand]) -> void
+      def complete_workflow_activation_with_failure: (String, Temporalio::Api::Failure::V1::Failure) -> void
+
+      private
+
+      attr_reader core_worker: Temporalio::Bridge::Worker
+
+      def with_queue: { (^(untyped?, Exception?) -> void) -> void } -> untyped
+      def complete_activity_task: (String task_token, Temporalio::Bridge::Api::ActivityResult::ActivityExecutionResult result) -> void
+      def complete_workflow_activation: (Temporalio::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion) -> void
+    end
+  end
+end

data/sig/temporalio/worker/thread_pool_executor.rbs

@@ -0,0 +1,23 @@
+module Temporalio
+  class Worker
+    interface _ActivityExecutor
+      def schedule: { -> untyped } -> void
+      def shutdown: -> void
+    end
+
+    class ThreadPoolExecutor
+      EXIT_SYMBOL: :exit
+
+      def initialize: (Integer size) -> void
+      def schedule: { -> untyped } -> void
+      def shutdown: -> void
+
+      private
+
+      attr_reader queue: Thread::Queue
+      attr_reader pool: Array[Thread]
+
+      def poll: -> void
+    end
+  end
+end

data/sig/temporalio/worker.rbs

@@ -0,0 +1,46 @@
+module Temporalio
+  class Worker
+    type worker_interceptor =
+      Temporalio::Interceptor::ActivityInbound |
+      Temporalio::Interceptor::ActivityOutbound
+
+    type interceptor_classes =
+      singleton(Temporalio::Interceptor::ActivityInbound) |
+      singleton(Temporalio::Interceptor::ActivityOutbound)
+
+    def self.run: (
+      *Temporalio::Worker workers,
+      ?shutdown_signals: Array[String]
+    ) ?{ -> void } -> void
+
+    def initialize: (
+      Temporalio::Connection connection,
+      String namespace,
+      String task_queue,
+      ?activities: Array[singleton(Temporalio::Activity)],
+      ?data_converter: Temporalio::DataConverter,
+      ?activity_executor: Temporalio::Worker::_ActivityExecutor?,
+      ?interceptors: Array[worker_interceptor],
+      ?max_concurrent_activities: Integer,
+      ?graceful_shutdown_timeout: Integer?
+    ) -> void
+    def run: ?{ -> void } -> void
+    def start: (?Temporalio::Worker::Runner? runner) -> void
+    def shutdown: (?Exception exception) -> void
+
+    def started?: -> bool
+    def running?: -> bool
+
+    private
+
+    @started: bool
+    @shutdown: bool
+
+    attr_reader mutex: Thread::Mutex
+    attr_reader runtime: Temporalio::Runtime
+    attr_reader activity_executor: Temporalio::Worker::_ActivityExecutor
+    attr_reader core_worker: Temporalio::Bridge::Worker
+    attr_reader activity_worker: Temporalio::Worker::ActivityWorker?
+    attr_reader runner: Temporalio::Worker::Runner?
+  end
+end

data/sig/temporalio/workflow/async.rbs

@@ -0,0 +1,9 @@
+module Temporalio
+  class Workflow
+    module Async
+      def self.run: [T] { () -> T } -> Temporalio::Workflow::Future[T]
+      def self.all: (*Temporalio::Workflow::Future[untyped] futures) -> Temporalio::Workflow::Future[nil]
+      def self.any: (*Temporalio::Workflow::Future[untyped] futures) -> Temporalio::Workflow::Future[Temporalio::Workflow::Future[untyped]]
+    end
+  end
+end

data/sig/temporalio/workflow/execution_info.rbs

@@ -0,0 +1,55 @@
+module Temporalio
+  class Workflow
+    EXECUTION_INFO_ATTRIBUTES: [:raw, :workflow, :id, :run_id, :task_queue, :status, :parent_id, :parent_run_id, :start_time, :close_time, :execution_time, :history_length, :memo, :search_attributes]
+
+    class ExecutionInfo < Struct[untyped]
+      attr_accessor raw(): Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionResponse
+      attr_accessor workflow(): String
+      attr_accessor id(): String
+      attr_accessor run_id(): String
+      attr_accessor task_queue(): String
+      attr_accessor status(): Symbol
+      attr_accessor parent_id(): String
+      attr_accessor parent_run_id(): String
+      attr_accessor start_time(): Time
+      attr_accessor close_time(): Time
+      attr_accessor execution_time(): Time
+      attr_accessor history_length(): Integer
+      attr_accessor memo(): Hash[Symbol | String, untyped]
+      attr_accessor search_attributes(): Hash[Symbol | String, untyped]
+
+      def self.from_raw: (
+        Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionResponse response,
+        Temporalio::DataConverter converter
+      ) -> ExecutionInfo
+
+      def self.new: (
+        raw: Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionResponse,
+        workflow: String?,
+        id: String?,
+        run_id: String?,
+        task_queue: String?,
+        status: Symbol?,
+        parent_id: String?,
+        parent_run_id: String?,
+        start_time: Time?,
+        close_time: Time?,
+        execution_time: Time?,
+        history_length: Integer?,
+        memo: Hash[Symbol | String, untyped]?,
+        search_attributes: Hash[Symbol | String, untyped]?
+      ) -> ExecutionInfo
+
+      # NOTE: RBS doesn't understand define_method semantics
+      def self.status: () -> Symbol
+
+      def running?: -> bool
+      def completed?: -> bool
+      def failed?: -> bool
+      def canceled?: -> bool
+      def terminated?: -> bool
+      def continued_as_new?: -> bool
+      def timed_out?: -> bool
+    end
+  end
+end

data/sig/temporalio/workflow/execution_status.rbs

@@ -0,0 +1,21 @@
+module Temporalio
+  class Workflow
+    module ExecutionStatus
+      type values =
+        :RUNNING | :COMPLETED | :FAILED | :CANCELED | :TERMINATED | :CONTINUED_AS_NEW | :TIMED_OUT
+
+      RUNNING: :RUNNING
+      COMPLETED: :COMPLETED
+      FAILED: :FAILED
+      CANCELED: :CANCELED
+      TERMINATED: :TERMINATED
+      CONTINUED_AS_NEW: :CONTINUED_AS_NEW
+      TIMED_OUT: :TIMED_OUT
+      STATUSES: Array[values]
+      API_MAP: Hash[Temporalio::Api::Enums::V1::WorkflowExecutionStatus::init, values]
+
+      def self.to_raw: (values) -> Temporalio::Api::Enums::V1::WorkflowExecutionStatus::init
+      def self.from_raw: (Temporalio::Api::Enums::V1::WorkflowExecutionStatus::init) -> values
+    end
+  end
+end

data/sig/temporalio/workflow/future.rbs

@@ -0,0 +1,40 @@
+module Temporalio
+  class Workflow
+    class Future[T]
+      class Rejected < StandardError
+      end
+
+      THREAD_KEY: Symbol
+
+      def self.current: -> Future[untyped]?
+      def self.current=: (Future[untyped]) -> void
+
+      def initialize: { (Future[T] future, ^(T) -> void resolve, ^(Exception) -> void reject) -> void } -> void
+      def then: [X] { (Future[T]) -> X } -> Future[X]
+      def on_cancel: { () -> untyped } -> void
+      def pending?: -> bool
+      def resolved?: -> bool
+      def rejected?: -> bool
+      def await: -> T?
+      def cancel: -> void
+
+      private
+
+      @resolved: bool
+      @rejected: bool
+      @cancel_requested: bool
+
+      attr_reader value: T?
+      attr_reader error: Exception
+      attr_reader blocked_fibers: Array[Fiber]
+      attr_reader callbacks: Array[^() -> void]
+      attr_reader cancel_callbacks: Array[^() -> void]
+
+      def cancel_requested?: -> bool
+      def run_callbacks: -> void
+      def resume_fibers: -> void
+      def resolve: (T value) -> void
+      def reject: (Exception error) -> void
+    end
+  end
+end

data/sig/temporalio/workflow/id_reuse_policy.rbs

@@ -0,0 +1,15 @@
+module Temporalio
+  class Workflow
+    class IDReusePolicy
+      ALLOW_DUPLICATE: :ALLOW_DUPLICATE
+      ALLOW_DUPLICATE_FAILED_ONLY: :ALLOW_DUPLICATE_FAILED_ONLY
+      REJECT_DUPLICATE: :REJECT_DUPLICATE
+      TERMINATE_IF_RUNNING: :TERMINATE_IF_RUNNING
+      POLICIES: Array[Symbol]
+      API_MAP: Hash[Temporalio::Api::Enums::V1::WorkflowIdReusePolicy::init, Symbol]
+
+      def self.to_raw: (Symbol policy) -> Temporalio::Api::Enums::V1::WorkflowIdReusePolicy::init?
+      def self.from_raw: (Temporalio::Api::Enums::V1::WorkflowIdReusePolicy::init raw_policy) -> Symbol
+    end
+  end
+end

data/sig/temporalio/workflow/info.rbs

@@ -0,0 +1,55 @@
+module Temporalio
+  class Workflow
+    class ParentInfo < Struct[untyped]
+      attr_accessor namespace: String
+      attr_accessor run_id: String
+      attr_accessor workflow_id: String
+
+      def self.new: (
+        namespace: String?,
+        run_id: String?,
+        workflow_id: String?
+      ) -> ParentInfo
+    end
+
+    class Info < Struct[untyped]
+      attr_accessor Integer: String
+      attr_accessor continued_run_id: String
+      attr_accessor cron_schedule: String
+      attr_accessor execution_timeout: Float
+      attr_accessor headers: Hash[String, untyped]
+      attr_accessor namespace: String
+      attr_accessor parent: ParentInfo
+      attr_accessor raw_memo: Hash[String, untyped]
+      attr_accessor retry_policy: Temporalio::RetryPolicy
+      attr_accessor run_id: String
+      attr_accessor run_timeout: Float
+      attr_accessor search_attributes: Hash[String, String]
+      attr_accessor start_time: Time
+      attr_accessor task_queue: String
+      attr_accessor task_timeout: Float
+      attr_accessor workflow_id: String
+      attr_accessor workflow_type: String
+
+      def self.new: (
+        attempt: Integer,
+        continued_run_id: String,
+        cron_schedule: String,
+        execution_timeout: Float?,
+        headers: Hash[String, untyped],
+        namespace: String,
+        parent: ParentInfo,
+        raw_memo: Hash[String, untyped],
+        retry_policy: Temporalio::RetryPolicy?,
+        run_id: String,
+        run_timeout: Float?,
+        search_attributes: Hash[String, String],
+        start_time: Time?,
+        task_queue: String,
+        task_timeout: Float?,
+        workflow_id: String,
+        workflow_type: String
+      ) -> Info
+    end
+  end
+end