handinger 0.0.2

data/rbi/handinger/models/workers/worker_schedule.rbi

@@ -0,0 +1,461 @@
+# typed: strong
+
+module Handinger
+  module Models
+    WorkerSchedule = Workers::WorkerSchedule
+
+    module Workers
+      module WorkerSchedule
+        extend Handinger::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Handinger::Workers::WorkerSchedule::Scheduled,
+              Handinger::Workers::WorkerSchedule::Delayed,
+              Handinger::Workers::WorkerSchedule::Cron,
+              Handinger::Workers::WorkerSchedule::Interval
+            )
+          end
+
+        class Scheduled < Handinger::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Handinger::Workers::WorkerSchedule::Scheduled,
+                Handinger::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig do
+            returns(
+              Handinger::Workers::WorkerSchedule::Scheduled::Budget::TaggedSymbol
+            )
+          end
+          attr_accessor :budget
+
+          sig { returns(String) }
+          attr_accessor :input
+
+          sig { returns(Time) }
+          attr_accessor :next_run_at
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(
+              id: String,
+              budget:
+                Handinger::Workers::WorkerSchedule::Scheduled::Budget::OrSymbol,
+              input: String,
+              next_run_at: Time,
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(id:, budget:, input:, next_run_at:, type: :scheduled)
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                budget:
+                  Handinger::Workers::WorkerSchedule::Scheduled::Budget::TaggedSymbol,
+                input: String,
+                next_run_at: Time,
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Budget
+            extend Handinger::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Handinger::Workers::WorkerSchedule::Scheduled::Budget
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            LOW =
+              T.let(
+                :low,
+                Handinger::Workers::WorkerSchedule::Scheduled::Budget::TaggedSymbol
+              )
+            STANDARD =
+              T.let(
+                :standard,
+                Handinger::Workers::WorkerSchedule::Scheduled::Budget::TaggedSymbol
+              )
+            HIGH =
+              T.let(
+                :high,
+                Handinger::Workers::WorkerSchedule::Scheduled::Budget::TaggedSymbol
+              )
+            UNLIMITED =
+              T.let(
+                :unlimited,
+                Handinger::Workers::WorkerSchedule::Scheduled::Budget::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Handinger::Workers::WorkerSchedule::Scheduled::Budget::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        class Delayed < Handinger::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Handinger::Workers::WorkerSchedule::Delayed,
+                Handinger::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig do
+            returns(
+              Handinger::Workers::WorkerSchedule::Delayed::Budget::TaggedSymbol
+            )
+          end
+          attr_accessor :budget
+
+          sig { returns(Integer) }
+          attr_accessor :delay_in_seconds
+
+          sig { returns(String) }
+          attr_accessor :input
+
+          sig { returns(Time) }
+          attr_accessor :next_run_at
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(
+              id: String,
+              budget:
+                Handinger::Workers::WorkerSchedule::Delayed::Budget::OrSymbol,
+              delay_in_seconds: Integer,
+              input: String,
+              next_run_at: Time,
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            id:,
+            budget:,
+            delay_in_seconds:,
+            input:,
+            next_run_at:,
+            type: :delayed
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                budget:
+                  Handinger::Workers::WorkerSchedule::Delayed::Budget::TaggedSymbol,
+                delay_in_seconds: Integer,
+                input: String,
+                next_run_at: Time,
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Budget
+            extend Handinger::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Handinger::Workers::WorkerSchedule::Delayed::Budget
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            LOW =
+              T.let(
+                :low,
+                Handinger::Workers::WorkerSchedule::Delayed::Budget::TaggedSymbol
+              )
+            STANDARD =
+              T.let(
+                :standard,
+                Handinger::Workers::WorkerSchedule::Delayed::Budget::TaggedSymbol
+              )
+            HIGH =
+              T.let(
+                :high,
+                Handinger::Workers::WorkerSchedule::Delayed::Budget::TaggedSymbol
+              )
+            UNLIMITED =
+              T.let(
+                :unlimited,
+                Handinger::Workers::WorkerSchedule::Delayed::Budget::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Handinger::Workers::WorkerSchedule::Delayed::Budget::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        class Cron < Handinger::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Handinger::Workers::WorkerSchedule::Cron,
+                Handinger::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig do
+            returns(
+              Handinger::Workers::WorkerSchedule::Cron::Budget::TaggedSymbol
+            )
+          end
+          attr_accessor :budget
+
+          sig { returns(String) }
+          attr_accessor :cron
+
+          sig { returns(String) }
+          attr_accessor :input
+
+          sig { returns(Time) }
+          attr_accessor :next_run_at
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(
+              id: String,
+              budget:
+                Handinger::Workers::WorkerSchedule::Cron::Budget::OrSymbol,
+              cron: String,
+              input: String,
+              next_run_at: Time,
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(id:, budget:, cron:, input:, next_run_at:, type: :cron)
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                budget:
+                  Handinger::Workers::WorkerSchedule::Cron::Budget::TaggedSymbol,
+                cron: String,
+                input: String,
+                next_run_at: Time,
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Budget
+            extend Handinger::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, Handinger::Workers::WorkerSchedule::Cron::Budget)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            LOW =
+              T.let(
+                :low,
+                Handinger::Workers::WorkerSchedule::Cron::Budget::TaggedSymbol
+              )
+            STANDARD =
+              T.let(
+                :standard,
+                Handinger::Workers::WorkerSchedule::Cron::Budget::TaggedSymbol
+              )
+            HIGH =
+              T.let(
+                :high,
+                Handinger::Workers::WorkerSchedule::Cron::Budget::TaggedSymbol
+              )
+            UNLIMITED =
+              T.let(
+                :unlimited,
+                Handinger::Workers::WorkerSchedule::Cron::Budget::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Handinger::Workers::WorkerSchedule::Cron::Budget::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        class Interval < Handinger::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Handinger::Workers::WorkerSchedule::Interval,
+                Handinger::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig do
+            returns(
+              Handinger::Workers::WorkerSchedule::Interval::Budget::TaggedSymbol
+            )
+          end
+          attr_accessor :budget
+
+          sig { returns(String) }
+          attr_accessor :input
+
+          sig { returns(Integer) }
+          attr_accessor :interval_seconds
+
+          sig { returns(Time) }
+          attr_accessor :next_run_at
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(
+              id: String,
+              budget:
+                Handinger::Workers::WorkerSchedule::Interval::Budget::OrSymbol,
+              input: String,
+              interval_seconds: Integer,
+              next_run_at: Time,
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            id:,
+            budget:,
+            input:,
+            interval_seconds:,
+            next_run_at:,
+            type: :interval
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                budget:
+                  Handinger::Workers::WorkerSchedule::Interval::Budget::TaggedSymbol,
+                input: String,
+                interval_seconds: Integer,
+                next_run_at: Time,
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Budget
+            extend Handinger::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Handinger::Workers::WorkerSchedule::Interval::Budget
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            LOW =
+              T.let(
+                :low,
+                Handinger::Workers::WorkerSchedule::Interval::Budget::TaggedSymbol
+              )
+            STANDARD =
+              T.let(
+                :standard,
+                Handinger::Workers::WorkerSchedule::Interval::Budget::TaggedSymbol
+              )
+            HIGH =
+              T.let(
+                :high,
+                Handinger::Workers::WorkerSchedule::Interval::Budget::TaggedSymbol
+              )
+            UNLIMITED =
+              T.let(
+                :unlimited,
+                Handinger::Workers::WorkerSchedule::Interval::Budget::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Handinger::Workers::WorkerSchedule::Interval::Budget::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        sig do
+          override.returns(
+            T::Array[Handinger::Workers::WorkerSchedule::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/handinger/models.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module Handinger
+  CreateWorker = Handinger::Models::CreateWorker
+
+  Worker = Handinger::Models::Worker
+
+  WorkerContinueParams = Handinger::Models::WorkerContinueParams
+
+  WorkerCreateParams = Handinger::Models::WorkerCreateParams
+
+  WorkerRetrieveEmailParams = Handinger::Models::WorkerRetrieveEmailParams
+
+  WorkerRetrieveFileParams = Handinger::Models::WorkerRetrieveFileParams
+
+  WorkerRetrieveParams = Handinger::Models::WorkerRetrieveParams
+
+  Workers = Handinger::Models::Workers
+
+  WorkerStreamUpdatesParams = Handinger::Models::WorkerStreamUpdatesParams
+end

data/rbi/handinger/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Handinger
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Handinger::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(Handinger::RequestOptions, Handinger::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: Handinger::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: Handinger::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/handinger/resources/workers/schedules.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module Handinger
+  module Resources
+    class Workers
+      # Manage future and recurring worker tasks.
+      class Schedules
+        # Schedule a worker instruction for a future or recurring run.
+        sig do
+          params(
+            worker_id: String,
+            input: String,
+            when_:
+              T.any(
+                Handinger::Workers::ScheduleCreateParams::When::Scheduled::OrHash,
+                Handinger::Workers::ScheduleCreateParams::When::Delayed::OrHash,
+                Handinger::Workers::ScheduleCreateParams::When::Cron::OrHash,
+                Handinger::Workers::ScheduleCreateParams::When::Interval::OrHash
+              ),
+            budget: Handinger::Workers::ScheduleCreateParams::Budget::OrSymbol,
+            request_options: Handinger::RequestOptions::OrHash
+          ).returns(Handinger::Workers::WorkerSchedule::Variants)
+        end
+        def create(
+          # Worker id returned by the create worker endpoint.
+          worker_id,
+          input:,
+          when_:,
+          budget: nil,
+          request_options: {}
+        )
+        end
+
+        # List scheduled tasks for a worker.
+        sig do
+          params(
+            worker_id: String,
+            request_options: Handinger::RequestOptions::OrHash
+          ).returns(Handinger::Models::Workers::ScheduleListResponse)
+        end
+        def list(
+          # Worker id returned by the create worker endpoint.
+          worker_id,
+          request_options: {}
+        )
+        end
+
+        # Cancel a scheduled task for a worker.
+        sig do
+          params(
+            schedule_id: String,
+            worker_id: String,
+            request_options: Handinger::RequestOptions::OrHash
+          ).returns(Handinger::Models::Workers::ScheduleCancelResponse)
+        end
+        def cancel(
+          # Scheduled task id returned by the create schedule endpoint.
+          schedule_id,
+          # Worker id returned by the create worker endpoint.
+          worker_id:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Handinger::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end