job-workflow 0.1.3

data/sig/generated/job_workflow/instrumentation.rbs

@@ -0,0 +1,138 @@
+# Generated from lib/job_workflow/instrumentation.rb with RBS::Inline
+
+module JobWorkflow
+  # Instrumentation provides ActiveSupport::Notifications-based event instrumentation for JobWorkflow workflows and tasks.
+  #
+  # @example Subscribing to events
+  #   ```ruby
+  #   ActiveSupport::Notifications.subscribe("task.start.job_workflow") do |name, start, finish, id, payload|
+  #     puts "Task #{payload[:task_name]} started"
+  #   end
+  #   ```
+  module Instrumentation
+    # rubocop:disable Metrics/ModuleLength
+    NAMESPACE: ::String
+
+    module Events
+      WORKFLOW: untyped
+
+      WORKFLOW_START: untyped
+
+      WORKFLOW_COMPLETE: untyped
+
+      TASK: untyped
+
+      TASK_START: untyped
+
+      TASK_COMPLETE: untyped
+
+      TASK_ERROR: untyped
+
+      TASK_SKIP: untyped
+
+      TASK_ENQUEUE: untyped
+
+      TASK_RETRY: untyped
+
+      THROTTLE_ACQUIRE: untyped
+
+      THROTTLE_ACQUIRE_START: untyped
+
+      THROTTLE_ACQUIRE_COMPLETE: untyped
+
+      THROTTLE_RELEASE: untyped
+
+      DEPENDENT_WAIT: untyped
+
+      DEPENDENT_WAIT_START: untyped
+
+      DEPENDENT_WAIT_COMPLETE: untyped
+
+      DEPENDENT_RESCHEDULE: untyped
+
+      QUEUE_PAUSE: untyped
+
+      QUEUE_RESUME: untyped
+
+      CUSTOM: untyped
+
+      DRY_RUN: untyped
+
+      DRY_RUN_SKIP: untyped
+
+      DRY_RUN_EXECUTE: untyped
+    end
+
+    # :  (DSL) { () -> untyped } -> untyped
+    def self.instrument_workflow: (DSL) { () -> untyped } -> untyped
+
+    # :  (DSL, Task, Context) { () -> untyped } -> untyped
+    def self.instrument_task: (DSL, Task, Context) { () -> untyped } -> untyped
+
+    # :  (DSL, Task, String) -> void
+    def self.notify_task_skip: (DSL, Task, String) -> void
+
+    # :  (DSL, Task, Integer) -> void
+    def self.notify_task_enqueue: (DSL, Task, Integer) -> void
+
+    # :  (Task, Context, String, Integer, Float, StandardError) -> void
+    def self.notify_task_retry: (Task, Context, String, Integer, Float, StandardError) -> void
+
+    # :  (DSL, Task) { () -> untyped } -> untyped
+    def self.instrument_dependent_wait: (DSL, Task) { () -> untyped } -> untyped
+
+    # :  (DSL, Task, Numeric, Integer) -> void
+    def self.notify_dependent_reschedule: (DSL, Task, Numeric, Integer) -> void
+
+    # :  (Semaphore) { () -> untyped } -> untyped
+    def self.instrument_throttle: (Semaphore) { () -> untyped } -> untyped
+
+    # :  (Semaphore) -> void
+    def self.notify_throttle_release: (Semaphore) -> void
+
+    # :  (String) -> void
+    def self.notify_queue_pause: (String) -> void
+
+    # :  (String) -> void
+    def self.notify_queue_resume: (String) -> void
+
+    # :  (String, Hash[Symbol, untyped]) { () -> untyped } -> untyped
+    def self.instrument_custom: (String, Hash[Symbol, untyped]) { () -> untyped } -> untyped
+
+    # :  (DSL, Context, Symbol?, Integer, bool) { () -> untyped } -> untyped
+    def self.instrument_dry_run: (DSL, Context, Symbol?, Integer, bool) { () -> untyped } -> untyped
+
+    # :  (String, Hash[Symbol, untyped]) ?{ () -> untyped } -> untyped
+    private def self.instrument: (String, Hash[Symbol, untyped]) ?{ () -> untyped } -> untyped
+
+    # :  (DSL) -> Hash[Symbol, untyped]
+    private def self.build_workflow_payload: (DSL) -> Hash[Symbol, untyped]
+
+    # :  (DSL, Task, Context) -> Hash[Symbol, untyped]
+    private def self.build_task_payload: (DSL, Task, Context) -> Hash[Symbol, untyped]
+
+    # :  (DSL, Task, String) -> Hash[Symbol, untyped]
+    private def self.build_task_skip_payload: (DSL, Task, String) -> Hash[Symbol, untyped]
+
+    # :  (DSL, Task, Integer) -> Hash[Symbol, untyped]
+    private def self.build_task_enqueue_payload: (DSL, Task, Integer) -> Hash[Symbol, untyped]
+
+    # :  (Task, Context, String, Integer, Float, StandardError) -> Hash[Symbol, untyped]
+    private def self.build_task_retry_payload: (Task, Context, String, Integer, Float, StandardError) -> Hash[Symbol, untyped]
+
+    # :  (DSL, Task) -> Hash[Symbol, untyped]
+    private def self.build_dependent_payload: (DSL, Task) -> Hash[Symbol, untyped]
+
+    # :  (DSL, Task, Numeric, Integer) -> Hash[Symbol, untyped]
+    private def self.build_dependent_reschedule_payload: (DSL, Task, Numeric, Integer) -> Hash[Symbol, untyped]
+
+    # :  (Semaphore) -> Hash[Symbol, untyped]
+    private def self.build_throttle_payload: (Semaphore) -> Hash[Symbol, untyped]
+
+    # :  (String) -> Hash[Symbol, untyped]
+    private def self.build_queue_payload: (String) -> Hash[Symbol, untyped]
+
+    # :  (DSL, Context, Symbol?, Integer, bool) -> Hash[Symbol, untyped]
+    private def self.build_skip_in_dry_run_payload: (DSL, Context, Symbol?, Integer, bool) -> Hash[Symbol, untyped]
+  end
+end

data/sig/generated/job_workflow/job_status.rbs

@@ -0,0 +1,46 @@
+# Generated from lib/job_workflow/job_status.rb with RBS::Inline
+
+module JobWorkflow
+  class JobStatus
+    # :  (Array[Hash[untyped, untyped]]) -> JobStatus
+    def self.from_hash_array: (Array[Hash[untyped, untyped]]) -> JobStatus
+
+    # :  (Hash[String, untyped]) -> JobStatus
+    def self.deserialize: (Hash[String, untyped]) -> JobStatus
+
+    # :  (?task_job_statuses: Array[TaskJobStatus]) -> void
+    def initialize: (?task_job_statuses: Array[TaskJobStatus]) -> void
+
+    # :  (task_name: Symbol) -> Array[TaskJobStatus]
+    def fetch_all: (task_name: Symbol) -> Array[TaskJobStatus]
+
+    # :  (task_name: Symbol, index: Integer) -> TaskJobStatus?
+    def fetch: (task_name: Symbol, index: Integer) -> TaskJobStatus?
+
+    # :  (task_name: Symbol) -> Array[String]
+    def finished_job_ids: (task_name: Symbol) -> Array[String]
+
+    # :  () -> Array[TaskJobStatus]
+    def flat_task_job_statuses: () -> Array[TaskJobStatus]
+
+    # @note
+    #   - If the array is empty, the task is not enqueued and is considered completed.
+    #   - If we add a task existence check in the future, we'll check here.
+    #
+    # :  (Symbol) -> bool
+    def needs_waiting?: (Symbol) -> bool
+
+    # :  (TaskJobStatus) -> void
+    def update_task_job_status: (TaskJobStatus) -> void
+
+    # :  (task_name: Symbol, jobs: Array[DSL]) -> void
+    def update_task_job_statuses_from_jobs: (task_name: Symbol, jobs: Array[DSL]) -> void
+
+    # :  (Symbol) -> void
+    def update_task_job_statuses_from_db: (Symbol) -> void
+
+    private
+
+    attr_accessor task_job_statuses: Hash[Symbol, Array[TaskJobStatus]]
+  end
+end

data/sig/generated/job_workflow/logger.rbs

@@ -0,0 +1,56 @@
+# Generated from lib/job_workflow/logger.rb with RBS::Inline
+
+module JobWorkflow
+  # Logger provides structured JSON logging for JobWorkflow workflows.
+  #
+  # @example Basic usage
+  #   ```ruby
+  #   JobWorkflow.logger = ActiveSupport::Logger.new($stdout)
+  #   JobWorkflow.logger.formatter = JobWorkflow::Logger::JsonFormatter.new
+  #   ```
+  #
+  # @example With custom log tags
+  #   ```ruby
+  #   JobWorkflow.logger.formatter = JobWorkflow::Logger::JsonFormatter.new(log_tags: [:request_id])
+  #   ```
+  module Logger
+    # :  (ActiveSupport::Logger) -> void
+    attr_writer logger: untyped
+
+    # :  () -> ActiveSupport::Logger
+    def logger: () -> ActiveSupport::Logger
+
+    private
+
+    # :  () -> ActiveSupport::Logger
+    def build_default_logger: () -> ActiveSupport::Logger
+
+    # JSON formatter for structured logging output.
+    # @rbs inherits ::Logger::Formatter
+    class JsonFormatter < ::Logger::Formatter
+      include ActiveSupport::TaggedLogging::Formatter
+
+      # :  (?log_tags: Array[Symbol]) -> void
+      def initialize: (?log_tags: Array[Symbol]) -> void
+
+      # :  (String, Time, String, String | Hash[untyped, untyped]) -> String
+      def call: (String, Time, String, String | Hash[untyped, untyped]) -> String
+
+      private
+
+      attr_reader log_tags: Array[Symbol]
+
+      # :  (String, Time, String) -> Hash[Symbol, untyped]
+      def build_base_hash: (String, Time, String) -> Hash[Symbol, untyped]
+
+      # :  () -> Hash[Symbol, untyped]
+      def build_tags_hash: () -> Hash[Symbol, untyped]
+
+      # :  (String | Hash[untyped, untyped]) -> Hash[Symbol, untyped]
+      def build_msg_hash: (String | Hash[untyped, untyped]) -> Hash[Symbol, untyped]
+
+      # :  (String) -> Hash[Symbol, untyped]
+      def parse_json_or_message: (String) -> Hash[Symbol, untyped]
+    end
+  end
+end

data/sig/generated/job_workflow/namespace.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/job_workflow/namespace.rb with RBS::Inline
+
+module JobWorkflow
+  class Namespace
+    attr_reader name: Symbol
+
+    attr_reader parent: Namespace?
+
+    # :  () -> Namespace
+    def self.default: () -> Namespace
+
+    # :  (name: Symbol, ?parent: Namespace?) -> void
+    def initialize: (name: Symbol, ?parent: Namespace?) -> void
+
+    # :  () -> bool
+    def default?: () -> bool
+
+    # :  (Namespace) -> Namespace
+    def update_parent: (Namespace) -> Namespace
+
+    # :  () -> Symbol
+    def full_name: () -> Symbol
+  end
+end

data/sig/generated/job_workflow/output.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/job_workflow/output.rb with RBS::Inline
+
+module JobWorkflow
+  class Output
+    # :  (Array[Hash[untyped, untyped]]) -> Output
+    def self.from_hash_array: (Array[Hash[untyped, untyped]]) -> Output
+
+    # :  (Hash[String, untyped]) -> Output
+    def self.deserialize: (Hash[String, untyped]) -> Output
+
+    # :  (?task_outputs: Array[TaskOutput]) -> void
+    def initialize: (?task_outputs: Array[TaskOutput]) -> void
+
+    # :  (task_name: Symbol?) -> Array[TaskOutput]
+    def fetch_all: (task_name: Symbol?) -> Array[TaskOutput]
+
+    # :  (task_name: Symbol?, each_index: Integer) -> TaskOutput?
+    def fetch: (task_name: Symbol?, each_index: Integer) -> TaskOutput?
+
+    # :  (Symbol | String) -> Array[TaskOutput?]
+    def []: (Symbol | String) -> Array[TaskOutput?]
+
+    # :  (TaskOutput) -> void
+    def add_task_output: (TaskOutput) -> void
+
+    # :  (Array[String], Workflow) -> void
+    def update_task_outputs_from_db: (Array[String], Workflow) -> void
+
+    # :  (Array[SolidQueue::Job], Workflow) -> void
+    def update_task_outputs_from_jobs: (Array[SolidQueue::Job], Workflow) -> void
+
+    # :  () -> Array[TaskOutput]
+    def flat_task_outputs: () -> Array[TaskOutput]
+
+    private
+
+    attr_accessor task_outputs: Hash[Symbol, Array[TaskOutput]]
+  end
+end

data/sig/generated/job_workflow/output_def.rbs

@@ -0,0 +1,12 @@
+# Generated from lib/job_workflow/output_def.rb with RBS::Inline
+
+module JobWorkflow
+  class OutputDef
+    attr_reader name: Symbol
+
+    attr_reader type: String
+
+    # :  (name: Symbol, type: String) -> void
+    def initialize: (name: Symbol, type: String) -> void
+  end
+end

data/sig/generated/job_workflow/queue.rbs

@@ -0,0 +1,49 @@
+# Generated from lib/job_workflow/queue.rb with RBS::Inline
+
+module JobWorkflow
+  # Queue provides a unified interface for queue operations across different queue adapters.
+  #
+  # @example Pausing and resuming a queue
+  #   ```ruby
+  #   JobWorkflow::Queue.pause(:import_workflow)
+  #   JobWorkflow::Queue.paused?(:import_workflow)  # => true
+  #   JobWorkflow::Queue.resume(:import_workflow)
+  #   JobWorkflow::Queue.paused?(:import_workflow)  # => false
+  #   ```
+  #
+  # @example Getting queue metrics
+  #   ```ruby
+  #   JobWorkflow::Queue.latency(:import_workflow)  # => 120 (seconds)
+  #   JobWorkflow::Queue.size(:import_workflow)     # => 42 (pending jobs)
+  #   ```
+  #
+  # @example Listing workflows associated with a queue
+  #   ```ruby
+  #   JobWorkflow::Queue.workflows(:import_workflow)  # => [ImportJob, DataSyncJob]
+  #   ```
+  class Queue
+    # :  (String | Symbol) -> bool
+    def self.pause: (String | Symbol) -> bool
+
+    # :  (String | Symbol) -> bool
+    def self.resume: (String | Symbol) -> bool
+
+    # :  (String | Symbol) -> bool
+    def self.paused?: (String | Symbol) -> bool
+
+    # :  () -> Array[String]
+    def self.paused_queues: () -> Array[String]
+
+    # :  (String | Symbol) -> Integer?
+    def self.latency: (String | Symbol) -> Integer?
+
+    # :  (String | Symbol) -> Integer
+    def self.size: (String | Symbol) -> Integer
+
+    # :  (String | Symbol) -> bool
+    def self.clear: (String | Symbol) -> bool
+
+    # :  (String | Symbol) -> Array[singleton(DSL)]
+    def self.workflows: (String | Symbol) -> Array[singleton(DSL)]
+  end
+end

data/sig/generated/job_workflow/queue_adapter.rbs

@@ -0,0 +1,18 @@
+# Generated from lib/job_workflow/queue_adapter.rb with RBS::Inline
+
+module JobWorkflow
+  module QueueAdapter
+    def self._current: () -> QueueAdapters::Abstract
+
+    def self._current=: (QueueAdapters::Abstract?) -> void
+
+    # :  () -> QueueAdapters::Abstract
+    def self.current: () -> QueueAdapters::Abstract
+
+    # :  () -> void
+    def self.reset!: () -> void
+
+    # :  () -> QueueAdapters::Abstract
+    private def self.detect_adapter: () -> QueueAdapters::Abstract
+  end
+end

data/sig/generated/job_workflow/queue_adapters/abstract.rbs

@@ -0,0 +1,56 @@
+# Generated from lib/job_workflow/queue_adapters/abstract.rb with RBS::Inline
+
+module JobWorkflow
+  module QueueAdapters
+    # rubocop:disable Naming/PredicateMethod
+    class Abstract
+      # :  () -> void
+      def initialize_adapter!: () -> void
+
+      # :  () -> bool
+      def semaphore_available?: () -> bool
+
+      # :  (Semaphore) -> bool
+      def semaphore_wait: (Semaphore) -> bool
+
+      # :  (Semaphore) -> bool
+      def semaphore_signal: (Semaphore) -> bool
+
+      # :  (Array[String]) -> Hash[String, untyped]
+      def fetch_job_statuses: (Array[String]) -> Hash[String, untyped]
+
+      # :  (untyped) -> Symbol
+      def job_status: (untyped) -> Symbol
+
+      # :  () -> bool
+      def supports_concurrency_limits?: () -> bool
+
+      # :  (String) -> bool
+      def pause_queue: (String) -> bool
+
+      # :  (String) -> bool
+      def resume_queue: (String) -> bool
+
+      # :  (String) -> bool
+      def queue_paused?: (String) -> bool
+
+      # :  () -> Array[String]
+      def paused_queues: () -> Array[String]
+
+      # :  (String) -> Integer?
+      def queue_latency: (String) -> Integer?
+
+      # :  (String) -> Integer
+      def queue_size: (String) -> Integer
+
+      # :  (String) -> bool
+      def clear_queue: (String) -> bool
+
+      # :  (String) -> Hash[String, untyped]?
+      def find_job: (String) -> Hash[String, untyped]?
+
+      # :  (DSL, Numeric) -> bool
+      def reschedule_job: (DSL, Numeric) -> bool
+    end
+  end
+end

data/sig/generated/job_workflow/queue_adapters/null_adapter.rbs

@@ -0,0 +1,73 @@
+# Generated from lib/job_workflow/queue_adapters/null_adapter.rb with RBS::Inline
+
+module JobWorkflow
+  module QueueAdapters
+    # rubocop:disable Naming/PredicateMethod
+    class NullAdapter < Abstract
+      # :  () -> void
+      def initialize_adapter!: () -> void
+
+      def initialize: () -> untyped
+
+      # :  () -> bool
+      def semaphore_available?: () -> bool
+
+      # :  (Semaphore) -> bool
+      def semaphore_wait: (Semaphore) -> bool
+
+      # :  (Semaphore) -> bool
+      def semaphore_signal: (Semaphore) -> bool
+
+      # :  (Array[String]) -> Hash[String, untyped]
+      def fetch_job_statuses: (Array[String]) -> Hash[String, untyped]
+
+      # :  (untyped) -> Symbol
+      def job_status: (untyped) -> Symbol
+
+      # :  () -> bool
+      def supports_concurrency_limits?: () -> bool
+
+      # :  (String) -> bool
+      def pause_queue: (String) -> bool
+
+      # :  (String) -> bool
+      def resume_queue: (String) -> bool
+
+      # :  (String) -> bool
+      def queue_paused?: (String) -> bool
+
+      # :  () -> Array[String]
+      def paused_queues: () -> Array[String]
+
+      # :  (String) -> Integer?
+      def queue_latency: (String) -> Integer?
+
+      # :  (String) -> Integer
+      def queue_size: (String) -> Integer
+
+      # :  (String) -> bool
+      def clear_queue: (String) -> bool
+
+      # :  (String) -> Hash[String, untyped]?
+      def find_job: (String) -> Hash[String, untyped]?
+
+      # :  (DSL, Numeric) -> bool
+      def reschedule_job: (DSL, Numeric) -> bool
+
+      # @note Test helpers
+      #
+      # :  (String, untyped) -> void
+      def enqueue_test_job: (String, untyped) -> void
+
+      # @note Test helpers - stores job data for find_job
+      #
+      # :  (String, Hash[String, untyped]) -> void
+      def store_job: (String, Hash[String, untyped]) -> void
+
+      # @note Test helpers
+      #
+      # :  () -> void
+      def reset!: () -> void
+    end
+  end
+end

data/sig/generated/job_workflow/queue_adapters/solid_queue_adapter.rbs

@@ -0,0 +1,111 @@
+# Generated from lib/job_workflow/queue_adapters/solid_queue_adapter.rb with RBS::Inline
+
+module JobWorkflow
+  module QueueAdapters
+    # rubocop:disable Naming/PredicateMethod
+    class SolidQueueAdapter < Abstract
+      # @note
+      #   - Registry scope: @semaphore_registry is process-scoped (shared across fibers/threads
+      #     in the same process) and lives for the lifetime of the worker process. It is not
+      #     serialized to persistent storage; semaphores are transient per worker instance.
+      #   - Cleanup: The adapter relies on SolidQueue::Worker lifecycle hooks to clean up
+      #     active semaphores when the worker stops. If a worker crashes, semaphores will
+      #     leak until the underlying database records expire or are manually cleaned.
+      #
+      # :  () -> void
+      def initialize: () -> void
+
+      # :  () -> void
+      def initialize_adapter!: () -> void
+
+      # :  () -> bool
+      def semaphore_available?: () -> bool
+
+      # @note
+      #   - Thread safety: @semaphore_registry is a non-thread-safe Hash. In multi-threaded workers,
+      #     concurrent calls to semaphore_wait or semaphore_signal may cause race conditions.
+      #     Mitigation: SolidQueue workers typically run in single-threaded Fiber mode; verify
+      #     worker configuration does not enable raw multithreading.
+      #   - Double-wait behavior: If semaphore_wait is called twice for the same Semaphore
+      #     (e.g., due to retry or requeue), the second call returns false and does not
+      #     re-register the hook. This is a fail-fast contract: the semaphore is already
+      #     being waited and will signal the registered hook.
+      #
+      # :  (Semaphore) -> bool
+      def semaphore_wait: (Semaphore) -> bool
+
+      # @note
+      #   - Lifecycle management: The adapter is responsible for removing the hook from
+      #     SolidQueue::Worker.lifecycle_hooks[:stop] before calling signal. The hook must
+      #     be deleted from the registry and the global lifecycle_hooks to prevent redundant
+      #     signal calls after the semaphore has already been signaled.
+      #   - Hook deletion order: The hook is deleted before calling signal to ensure the
+      #     hook lambda is no longer invoked even if the signal triggers a worker stop.
+      #
+      # :  (Semaphore) -> bool
+      def semaphore_signal: (Semaphore) -> bool
+
+      # :  (Array[String]) -> Hash[String, untyped]
+      def fetch_job_statuses: (Array[String]) -> Hash[String, untyped]
+
+      # :  (untyped) -> Symbol
+      def job_status: (untyped) -> Symbol
+
+      # :  () -> bool
+      def supports_concurrency_limits?: () -> bool
+
+      # :  (String) -> bool
+      def pause_queue: (String) -> bool
+
+      # :  (String) -> bool
+      def resume_queue: (String) -> bool
+
+      # :  (String) -> bool
+      def queue_paused?: (String) -> bool
+
+      # :  () -> Array[String]
+      def paused_queues: () -> Array[String]
+
+      # :  (String) -> Integer?
+      def queue_latency: (String) -> Integer?
+
+      # :  (String) -> Integer
+      def queue_size: (String) -> Integer
+
+      # :  (String) -> bool
+      def clear_queue: (String) -> bool
+
+      # @note
+      #   - SolidQueue stores the full ActiveJob serialization in job.arguments
+      #   - We need to extract the actual arguments array for consistency
+      #
+      # :  (String) -> Hash[String, untyped]?
+      def find_job: (String) -> Hash[String, untyped]?
+
+      # :  (DSL, Numeric) -> bool
+      def reschedule_job: (DSL, Numeric) -> bool
+
+      private
+
+      attr_reader semaphore_registry: Hash[Object, ^(SolidQueue::Worker) -> void]
+
+      # :  (SolidQueue::Job, DSL, Numeric) -> bool
+      def reschedule_solid_queue_job: (SolidQueue::Job, DSL, Numeric) -> bool
+
+      # @rbs module-self SolidQueue::ClaimedExecution
+      module ClaimedExecutionPatch : SolidQueue::ClaimedExecution
+        private
+
+        # :  () -> SolidQueue::ClaimedExecution
+        def finished: () -> SolidQueue::ClaimedExecution
+      end
+
+      module SchedulingPatch
+        private
+
+        # :  () -> Hash[Symbol, Hash[Symbol, untyped]]
+        def recurring_tasks_config: () -> Hash[Symbol, Hash[Symbol, untyped]]
+      end
+    end
+  end
+end

data/sig/generated/job_workflow/runner.rbs

@@ -0,0 +1,66 @@
+# Generated from lib/job_workflow/runner.rb with RBS::Inline
+
+module JobWorkflow
+  class Runner
+    # rubocop:disable Metrics/ClassLength
+    attr_reader context: Context
+
+    # :  (context: Context) -> void
+    def initialize: (context: Context) -> void
+
+    # :  () -> void
+    def run: () -> void
+
+    private
+
+    attr_reader job: DSL
+
+    # :  () -> Workflow
+    def workflow: () -> Workflow
+
+    # :  () -> Array[Task]
+    def tasks: () -> Array[Task]
+
+    # :  () -> HookRegistry
+    def hooks: () -> HookRegistry
+
+    # :  () -> void
+    def run_workflow: () -> void
+
+    # :  (Task) -> bool
+    def skip_task?: (Task) -> bool
+
+    # :  (Task) -> void
+    def run_task: (Task) -> void
+
+    # :  (Task, Context) -> void
+    def run_each_task: (Task, Context) -> void
+
+    # :  (Task, Context) { () -> void } -> void
+    def run_hooks: (Task, Context) { () -> void } -> void
+
+    # :  (Task, Context, Array[Hook]) { () -> void } -> void
+    def run_around_hooks: (Task, Context, Array[Hook]) { () -> void } -> void
+
+    # :  (Task, Context, StandardError) -> void
+    def run_error_hooks: (Task, Context, StandardError) -> void
+
+    # :  (Task) -> void
+    def enqueue_task: (Task) -> void
+
+    # :  (Task, ActiveJob::Continuation::Step) -> void
+    def wait_for_dependent_tasks: (Task, ActiveJob::Continuation::Step) -> void
+
+    # :  (Task, Task, ActiveJob::Continuation::Step) -> void
+    def poll_until_complete_or_reschedule: (Task, Task, ActiveJob::Continuation::Step) -> void
+
+    # :  (Task, TaskDependencyWait, Hash[Symbol, untyped]) -> void
+    def reschedule_if_needed: (Task, TaskDependencyWait, Hash[Symbol, untyped]) -> void
+
+    # :  (ctx: Context, task: Task, each_index: Integer, data: untyped) -> void
+    def add_task_output: (ctx: Context, task: Task, each_index: Integer, data: untyped) -> void
+
+    # :  (Task) -> void
+    def update_task_outputs: (Task) -> void
+  end
+end