terminal-shop 0.1.0.pre.alpha.5

data/rbi/lib/terminal-shop/base_client.rbi

@@ -0,0 +1,145 @@
+# typed: strong
+
+module TerminalShop
+  class BaseClient
+    abstract!
+
+    RequestShape = T.type_alias do
+      {
+        method: Symbol,
+        path: T.any(String, T::Array[String]),
+        query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]),
+        headers: T.nilable(T::Hash[String, T.nilable(String)]),
+        body: T.nilable(T.anything),
+        unwrap: T.nilable(Symbol),
+        page: T.nilable(T::Class[TerminalShop::BaseModel]),
+        model: T.nilable(TerminalShop::Converter::Input),
+        options: T.nilable(T.any(TerminalShop::RequestOptions, T::Hash[Symbol, T.anything]))
+      }
+    end
+
+    NormalizedRequestShape = T.type_alias do
+      {
+        method: Symbol,
+        url: URI::Generic,
+        headers: T::Hash[String, String],
+        body: T.anything,
+        max_retries: Integer,
+        timeout: Float
+      }
+    end
+
+    MAX_REDIRECTS = 20
+
+    sig { params(req: TerminalShop::BaseClient::RequestShape).void }
+    def self.validate!(req)
+    end
+
+    # @private
+    #
+    sig { returns(T.anything) }
+    attr_accessor :requester
+
+    sig do
+      params(
+        base_url: String,
+        timeout: Float,
+        max_retries: Integer,
+        initial_retry_delay: Float,
+        max_retry_delay: Float,
+        headers: T::Hash[String, T.nilable(String)],
+        idempotency_header: T.nilable(String)
+      ).void
+    end
+    def initialize(
+      base_url:,
+      timeout: 0.0,
+      max_retries: 0,
+      initial_retry_delay: 0.0,
+      max_retry_delay: 0.0,
+      headers: {},
+      idempotency_header: nil
+    )
+    end
+
+    sig { overridable.returns(T::Hash[String, String]) }
+    private def auth_headers
+    end
+
+    sig { returns(String) }
+    private def generate_idempotency_key
+    end
+
+    sig do
+      params(
+        req: TerminalShop::BaseClient::RequestShape,
+        opts: T::Hash[Symbol, T.anything]
+      ).returns(TerminalShop::BaseClient::NormalizedRequestShape)
+    end
+    private def build_request(req, opts)
+    end
+
+    sig { params(status: Integer, headers: T::Hash[String, String]).returns(T::Boolean) }
+    private def should_retry?(status, headers:)
+    end
+
+    sig { params(headers: T::Hash[String, String], retry_count: Integer).returns(Float) }
+    private def retry_delay(headers, retry_count:)
+    end
+
+    sig do
+      params(
+        request: TerminalShop::BaseClient::NormalizedRequestShape,
+        status: Integer,
+        location_header: String
+      ).returns(TerminalShop::BaseClient::NormalizedRequestShape)
+    end
+    private def follow_redirect(request, status:, location_header:)
+    end
+
+    sig do
+      params(
+        request: TerminalShop::BaseClient::NormalizedRequestShape,
+        redirect_count: Integer,
+        retry_count: Integer,
+        send_retry_header: T::Boolean
+      ).returns(Net::HTTPResponse)
+    end
+    private def send_request(request, redirect_count:, retry_count:, send_retry_header:)
+    end
+
+    sig { params(req: TerminalShop::BaseClient::RequestShape, response: NilClass).returns(T.anything) }
+    private def parse_response(req, response)
+    end
+
+    sig do
+      params(
+        method: Symbol,
+        path: T.any(String, T::Array[String]),
+        query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]),
+        headers: T.nilable(T::Hash[String, T.nilable(String)]),
+        body: T.nilable(T.anything),
+        unwrap: T.nilable(Symbol),
+        page: T.nilable(T::Class[TerminalShop::BaseModel]),
+        model: T.nilable(TerminalShop::Converter::Input),
+        options: T.nilable(T.any(TerminalShop::RequestOptions, T::Hash[Symbol, T.anything]))
+      ).returns(T.anything)
+    end
+    def request(
+      method,
+      path,
+      query: {},
+      headers: {},
+      body: nil,
+      unwrap: nil,
+      page: nil,
+      model: TerminalShop::Unknown,
+      options: {}
+    )
+    end
+
+    sig { returns(String) }
+    def inspect
+    end
+  end
+end

data/rbi/lib/terminal-shop/base_model.rbi

@@ -0,0 +1,514 @@
+# typed: strong
+
+module TerminalShop
+  module Converter
+    abstract!
+
+    Input = T.type_alias { T.any(TerminalShop::Converter, T::Class[T.anything]) }
+
+    sig { overridable.params(value: T.anything).returns(T.anything) }
+    def coerce(value)
+    end
+
+    sig { overridable.params(value: T.anything).returns(T.anything) }
+    def dump(value)
+    end
+
+    sig do
+      overridable.params(value: T.anything).returns(
+        T.any(
+          [T::Boolean, T.anything, NilClass],
+          [T::Boolean, T::Boolean, Integer]
+        )
+      )
+    end
+    def try_strict_coerce(value)
+    end
+
+    sig do
+      params(
+        spec: T.any(
+          {
+            const: T.nilable(T.any(NilClass, T::Boolean, Integer, Float, Symbol)),
+            enum: T.nilable(T.proc.returns(TerminalShop::Converter::Input)),
+            union: T.nilable(T.proc.returns(TerminalShop::Converter::Input))
+          },
+          T.proc.returns(TerminalShop::Converter::Input),
+          TerminalShop::Converter::Input
+        )
+      ).returns(T.proc.returns(T.anything).void)
+    end
+    def self.type_info(spec)
+    end
+
+    sig { params(target: TerminalShop::Converter::Input, value: T.anything).returns(T.anything) }
+    def self.coerce(target, value)
+    end
+
+    sig { params(target: TerminalShop::Converter::Input, value: T.anything).returns(T.anything) }
+    def self.dump(target, value)
+    end
+
+    sig { params(target: TerminalShop::Converter::Input, value: T.anything).returns(T.anything) }
+    def self.try_strict_coerce(target, value)
+    end
+  end
+
+  class Unknown
+    abstract!
+
+    extend TerminalShop::Converter
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.==(other)
+    end
+
+    sig { override.params(value: T.anything).returns(T.anything) }
+    def self.coerce(value)
+    end
+
+    sig { override.params(value: T.anything).returns(T.anything) }
+    def self.dump(value)
+    end
+
+    sig do
+      override.params(value: T.anything).returns(
+        T.any(
+          [T::Boolean, T.anything, NilClass],
+          [T::Boolean, T::Boolean, Integer]
+        )
+      )
+    end
+    def self.try_strict_coerce(value)
+    end
+  end
+
+  class BooleanModel
+    abstract!
+
+    extend TerminalShop::Converter
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.==(other)
+    end
+
+    sig { override.params(value: T.any(T::Boolean, T.anything)).returns(T.any(T::Boolean, T.anything)) }
+    def self.coerce(value)
+    end
+
+    sig { override.params(value: T.any(T::Boolean, T.anything)).returns(T.any(T::Boolean, T.anything)) }
+    def self.dump(value)
+    end
+
+    sig do
+      override.params(value: T.anything).returns(
+        T.any(
+          [T::Boolean, T.anything, NilClass],
+          [T::Boolean, T::Boolean, Integer]
+        )
+      )
+    end
+    def self.try_strict_coerce(value)
+    end
+  end
+
+  class Enum
+    abstract!
+
+    extend TerminalShop::Converter
+
+    sig { overridable.returns(T::Array[T.any(NilClass, T::Boolean, Integer, Float, Symbol)]) }
+    def self.values
+    end
+
+    sig { void }
+    private_class_method def self.finalize!
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.==(other)
+    end
+
+    sig { override.params(value: T.any(String, Symbol, T.anything)).returns(T.any(Symbol, T.anything)) }
+    def self.coerce(value)
+    end
+
+    sig { override.params(value: T.any(Symbol, T.anything)).returns(T.any(Symbol, T.anything)) }
+    def self.dump(value)
+    end
+
+    sig do
+      override.params(value: T.anything).returns(
+        T.any(
+          [T::Boolean, T.anything, NilClass],
+          [T::Boolean, T::Boolean, Integer]
+        )
+      )
+    end
+    def self.try_strict_coerce(value)
+    end
+  end
+
+  class Union
+    abstract!
+
+    extend TerminalShop::Extern
+    extend TerminalShop::Converter
+
+    sig { returns(T::Array[[T.nilable(Symbol), Proc]]) }
+    private_class_method def self.known_variants
+    end
+
+    sig { overridable.returns(T::Array[[T.nilable(Symbol), T.anything]]) }
+    private_class_method def self.variants
+    end
+
+    sig { params(property: Symbol).void }
+    private_class_method def self.discriminator(property)
+    end
+
+    sig do
+      params(
+        key: T.any(
+          Symbol,
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(TerminalShop::Converter::Input),
+          TerminalShop::Converter::Input
+        ),
+        spec: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(TerminalShop::Converter::Input),
+          TerminalShop::Converter::Input
+        )
+      ).void
+    end
+    private_class_method def self.variant(key, spec = nil)
+    end
+
+    sig { params(value: T.anything).returns(T.nilable(TerminalShop::Converter::Input)) }
+    private_class_method def self.resolve_variant(value)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.==(other)
+    end
+
+    sig { override.params(value: T.anything).returns(T.anything) }
+    def self.coerce(value)
+    end
+
+    sig { override.params(value: T.anything).returns(T.anything) }
+    def self.dump(value)
+    end
+
+    sig do
+      override.params(value: T.anything).returns(
+        T.any(
+          [T::Boolean, T.anything, NilClass],
+          [T::Boolean, T::Boolean, Integer]
+        )
+      )
+    end
+    def self.try_strict_coerce(value)
+    end
+  end
+
+  class ArrayOf
+    abstract!
+
+    include TerminalShop::Converter
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ==(other)
+    end
+
+    sig do
+      override.params(
+        value: T.any(
+          T::Enumerable[T.anything],
+          T.anything
+        )
+      ).returns(T.any(T::Array[T.anything], T.anything))
+    end
+    def coerce(value)
+    end
+
+    sig do
+      override.params(
+        value: T.any(
+          T::Enumerable[T.anything],
+          T.anything
+        )
+      ).returns(T.any(T::Array[T.anything], T.anything))
+    end
+    def dump(value)
+    end
+
+    sig do
+      override.params(value: T.anything).returns(
+        T.any(
+          [T::Boolean, T.anything, NilClass],
+          [T::Boolean, T::Boolean, Integer]
+        )
+      )
+    end
+    def try_strict_coerce(value)
+    end
+
+    sig { returns(TerminalShop::Converter::Input) }
+    protected def item_type
+    end
+
+    sig do
+      params(
+        type_info: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(TerminalShop::Converter::Input),
+          TerminalShop::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      ).void
+    end
+    def initialize(type_info, spec = {})
+    end
+  end
+
+  class HashOf
+    abstract!
+
+    include TerminalShop::Converter
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ==(other)
+    end
+
+    sig do
+      override.params(
+        value: T.any(
+          T::Hash[T.anything, T.anything],
+          T.anything
+        )
+      ).returns(T.any(T::Hash[Symbol, T.anything], T.anything))
+    end
+    def coerce(value)
+    end
+
+    sig do
+      override.params(
+        value: T.any(
+          T::Hash[T.anything, T.anything],
+          T.anything
+        )
+      ).returns(T.any(T::Hash[Symbol, T.anything], T.anything))
+    end
+    def dump(value)
+    end
+
+    sig do
+      override.params(value: T.anything).returns(
+        T.any(
+          [T::Boolean, T.anything, NilClass],
+          [T::Boolean, T::Boolean, Integer]
+        )
+      )
+    end
+    def try_strict_coerce(value)
+    end
+
+    sig { returns(TerminalShop::Converter::Input) }
+    protected def item_type
+    end
+
+    sig do
+      params(
+        type_info: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(TerminalShop::Converter::Input),
+          TerminalShop::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      ).void
+    end
+    def initialize(type_info, spec = {})
+    end
+  end
+
+  class BaseModel
+    abstract!
+
+    extend TerminalShop::Extern
+    extend TerminalShop::Converter
+
+    KnownFieldShape = T.type_alias { {mode: T.nilable(Symbol), required: T::Boolean} }
+
+    sig do
+      returns(
+        T::Hash[Symbol,
+                T.all(
+                  TerminalShop::BaseModel::KnownFieldShape,
+                  {type_fn: T.proc.returns(TerminalShop::Converter::Input)}
+                )]
+      )
+    end
+    def self.known_fields
+    end
+
+    sig do
+      returns(
+        T::Hash[Symbol,
+                T.all(TerminalShop::BaseModel::KnownFieldShape, {type: TerminalShop::Converter::Input})]
+      )
+    end
+    def self.fields
+    end
+
+    sig { returns(T::Hash[Symbol, T.proc.returns(T::Class[T.anything])]) }
+    def self.defaults
+    end
+
+    sig do
+      params(
+        name_sym: Symbol,
+        required: T::Boolean,
+        type_info: T.any(
+          {
+            const: T.nilable(T.any(NilClass, T::Boolean, Integer, Float, Symbol)),
+            enum: T.nilable(T.proc.returns(TerminalShop::Converter::Input)),
+            union: T.nilable(T.proc.returns(TerminalShop::Converter::Input)),
+            api_name: Symbol,
+            nil?: T::Boolean
+          },
+          T.proc.returns(TerminalShop::Converter::Input),
+          TerminalShop::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      ).void
+    end
+    private_class_method def self.add_field(name_sym, required:, type_info:, spec:)
+    end
+
+    sig do
+      params(
+        name_sym: Symbol,
+        type_info: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(TerminalShop::Converter::Input),
+          TerminalShop::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      ).void
+    end
+    def self.required(name_sym, type_info, spec = {})
+    end
+
+    sig do
+      params(
+        name_sym: Symbol,
+        type_info: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(TerminalShop::Converter::Input),
+          TerminalShop::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      ).void
+    end
+    def self.optional(name_sym, type_info, spec = {})
+    end
+
+    sig { params(blk: T.proc.void).void }
+    private_class_method def self.request_only(&blk)
+    end
+
+    sig { params(blk: T.proc.void).void }
+    private_class_method def self.response_only(&blk)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ==(other)
+    end
+
+    sig do
+      override.params(
+        value: T.any(
+          TerminalShop::BaseModel,
+          T::Hash[T.anything, T.anything],
+          T.anything
+        )
+      ).returns(T.any(T.attached_class, T.anything))
+    end
+    def self.coerce(value)
+    end
+
+    sig do
+      override.params(
+        value: T.any(
+          T.attached_class,
+          T.anything
+        )
+      ).returns(T.any(T::Hash[T.anything, T.anything], T.anything))
+    end
+    def self.dump(value)
+    end
+
+    sig do
+      override.params(value: T.anything).returns(
+        T.any(
+          [T::Boolean, T.anything, NilClass],
+          [T::Boolean, T::Boolean, Integer]
+        )
+      )
+    end
+    def self.try_strict_coerce(value)
+    end
+
+    sig { params(key: Symbol).returns(T.nilable(T.anything)) }
+    def [](key)
+    end
+
+    sig { overridable.returns(T::Hash[Symbol, T.anything]) }
+    def to_h
+    end
+
+    alias_method :to_hash, :to_h
+
+    sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.anything]) }
+    def deconstruct_keys(keys)
+    end
+
+    sig { params(data: T.any(T::Hash[Symbol, T.anything], T.self_type)).void }
+    def initialize(data = {})
+    end
+
+    sig { returns(String) }
+    def to_s
+    end
+
+    sig { returns(String) }
+    def inspect
+    end
+  end
+end

data/rbi/lib/terminal-shop/base_page.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module TerminalShop
+  module BasePage
+    abstract!
+
+    Elem = type_member(:out)
+
+    sig { overridable.returns(T::Boolean) }
+    def next_page?
+    end
+
+    sig { overridable.returns(T.self_type) }
+    def next_page
+    end
+
+    sig { overridable.params(blk: T.proc.params(arg0: Elem).void).void }
+    def auto_paging_each(&blk)
+    end
+
+    sig { returns(T::Enumerable[Elem]) }
+    def to_enum
+    end
+
+    alias_method :enum_for, :to_enum
+
+    sig do
+      params(
+        client: TerminalShop::BaseClient,
+        req: TerminalShop::BaseClient::RequestShape,
+        headers: T::Hash[String, String],
+        unwrapped: T.anything
+      ).void
+    end
+    def initialize(client:, req:, headers:, unwrapped:)
+    end
+  end
+end