orb-billing 0.1.0.pre.alpha.33

data/rbi/lib/orb/type/converter.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module Orb
+  module Type
+    # @api private
+    module Converter
+      Input = T.type_alias { T.any(Orb::Type::Converter, T::Class[T.anything]) }
+
+      State =
+        T.type_alias do
+          {
+            strictness: T.any(T::Boolean, Symbol),
+            exactness: {yes: Integer, no: Integer, maybe: Integer},
+            branched: Integer
+          }
+        end
+
+      # @api private
+      sig { overridable.params(value: T.anything, state: Orb::Type::Converter::State).returns(T.anything) }
+      def coerce(value, state:)
+      end
+
+      # @api private
+      sig { overridable.params(value: T.anything).returns(T.anything) }
+      def dump(value)
+      end
+
+      class << self
+        # @api private
+        sig do
+          params(
+            spec: T.any(
+              {
+                const: T.nilable(T.any(NilClass, T::Boolean, Integer, Float, Symbol)),
+                enum: T.nilable(T.proc.returns(Orb::Type::Converter::Input)),
+                union: T.nilable(T.proc.returns(Orb::Type::Converter::Input))
+              },
+              T.proc.returns(Orb::Type::Converter::Input),
+              Orb::Type::Converter::Input
+            )
+          )
+            .returns(T.proc.returns(T.anything))
+        end
+        def self.type_info(spec)
+        end
+
+        # @api private
+        #
+        # Based on `target`, transform `value` into `target`, to the extent possible:
+        #
+        #   1. if the given `value` conforms to `target` already, return the given `value`
+        #   2. if it's possible and safe to convert the given `value` to `target`, then the
+        #      converted value
+        #   3. otherwise, the given `value` unaltered
+        #
+        #   The coercion process is subject to improvement between minor release versions.
+        #   See https://docs.pydantic.dev/latest/concepts/unions/#smart-mode
+        sig do
+          params(target: Orb::Type::Converter::Input, value: T.anything, state: Orb::Type::Converter::State)
+            .returns(T.anything)
+        end
+        def self.coerce(
+          target,
+          value,
+          # The `strictness` is one of `true`, `false`, or `:strong`. This informs the
+          #   coercion strategy when we have to decide between multiple possible conversion
+          #   targets:
+          #
+          #   - `true`: the conversion must be exact, with minimum coercion.
+          #   - `false`: the conversion can be approximate, with some coercion.
+          #   - `:strong`: the conversion must be exact, with no coercion, and raise an error
+          #     if not possible.
+          #
+          #   The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For
+          #   any given conversion attempt, the exactness will be updated based on how closely
+          #   the value recursively matches the target type:
+          #
+          #   - `yes`: the value can be converted to the target type with minimum coercion.
+          #   - `maybe`: the value can be converted to the target type with some reasonable
+          #     coercion.
+          #   - `no`: the value cannot be converted to the target type.
+          #
+          #   See implementation below for more details.
+          state: {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0}
+        )
+        end
+
+        # @api private
+        sig { params(target: Orb::Type::Converter::Input, value: T.anything).returns(T.anything) }
+        def self.dump(target, value)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/type/enum.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module Orb
+  module Type
+    # @api private
+    #
+    # A value from among a specified list of options. OpenAPI enum values map to Ruby
+    #   values in the SDK as follows:
+    #
+    #   1. boolean => true | false
+    #   2. integer => Integer
+    #   3. float => Float
+    #   4. string => Symbol
+    #
+    #   We can therefore convert string values to Symbols, but can't convert other
+    #   values safely.
+    module Enum
+      include Orb::Type::Converter
+
+      # All of the valid Symbol values for this enum.
+      sig { overridable.returns(T::Array[T.any(NilClass, T::Boolean, Integer, Float, Symbol)]) }
+      def values
+      end
+
+      # @api private
+      #
+      # Guard against thread safety issues by instantiating `@values`.
+      sig { void }
+      private def finalize!
+      end
+
+      sig { params(other: T.anything).returns(T::Boolean) }
+      def ===(other)
+      end
+
+      sig { params(other: T.anything).returns(T::Boolean) }
+      def ==(other)
+      end
+
+      # @api private
+      #
+      # Unlike with primitives, `Enum` additionally validates that the value is a member
+      #   of the enum.
+      sig do
+        override
+          .params(value: T.any(String, Symbol, T.anything), state: Orb::Type::Converter::State)
+          .returns(T.any(Symbol, T.anything))
+      end
+      def coerce(value, state:)
+      end
+
+      # @api private
+      sig { override.params(value: T.any(Symbol, T.anything)).returns(T.any(Symbol, T.anything)) }
+      def dump(value)
+      end
+    end
+  end
+end

data/rbi/lib/orb/type/hash_of.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Orb
+  module Type
+    # @api private
+    #
+    # Hash of items of a given type.
+    class HashOf
+      include Orb::Type::Converter
+
+      abstract!
+      final!
+
+      Elem = type_member(:out)
+
+      sig(:final) do
+        params(
+          type_info: T.any(
+            Orb::Util::AnyHash,
+            T.proc.returns(Orb::Type::Converter::Input),
+            Orb::Type::Converter::Input
+          ),
+          spec: Orb::Util::AnyHash
+        )
+          .returns(T.attached_class)
+      end
+      def self.[](type_info, spec = {})
+      end
+
+      sig(:final) { params(other: T.anything).returns(T::Boolean) }
+      def ===(other)
+      end
+
+      sig(:final) { params(other: T.anything).returns(T::Boolean) }
+      def ==(other)
+      end
+
+      # @api private
+      sig(:final) do
+        override
+          .params(value: T.any(
+            T::Hash[T.anything, T.anything],
+            T.anything
+          ),
+                  state: Orb::Type::Converter::State)
+          .returns(T.any(Orb::Util::AnyHash, T.anything))
+      end
+      def coerce(value, state:)
+      end
+
+      # @api private
+      sig(:final) do
+        override
+          .params(value: T.any(T::Hash[T.anything, T.anything], T.anything))
+          .returns(T.any(Orb::Util::AnyHash, T.anything))
+      end
+      def dump(value)
+      end
+
+      # @api private
+      sig(:final) { returns(Elem) }
+      protected def item_type
+      end
+
+      # @api private
+      sig(:final) { returns(T::Boolean) }
+      protected def nilable?
+      end
+
+      # @api private
+      sig(:final) do
+        params(
+          type_info: T.any(
+            Orb::Util::AnyHash,
+            T.proc.returns(Orb::Type::Converter::Input),
+            Orb::Type::Converter::Input
+          ),
+          spec: Orb::Util::AnyHash
+        )
+          .void
+      end
+      def initialize(type_info, spec = {})
+      end
+    end
+  end
+end

data/rbi/lib/orb/type/request_parameters.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Orb
+  module Type
+    # @api private
+    module RequestParameters
+      # Options to specify HTTP behaviour for this request.
+      sig { returns(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) }
+      attr_accessor :request_options
+
+      # @api private
+      module Converter
+        # @api private
+        sig { params(params: T.anything).returns([T.anything, Orb::Util::AnyHash]) }
+        def dump_request(params)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/type/union.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Orb
+  module Type
+    # @api private
+    module Union
+      include Orb::Type::Converter
+
+      # @api private
+      #
+      # All of the specified variant info for this union.
+      sig { returns(T::Array[[T.nilable(Symbol), T.proc.returns(Orb::Type::Converter::Input)]]) }
+      private def known_variants
+      end
+
+      # @api private
+      sig { returns(T::Array[[T.nilable(Symbol), T.anything]]) }
+      protected def derefed_variants
+      end
+
+      # All of the specified variants for this union.
+      sig { overridable.returns(T::Array[T.anything]) }
+      def variants
+      end
+
+      # @api private
+      sig { params(property: Symbol).void }
+      private def discriminator(property)
+      end
+
+      # @api private
+      sig do
+        params(
+          key: T.any(Symbol, Orb::Util::AnyHash, T.proc.returns(T.anything), T.anything),
+          spec: T.any(Orb::Util::AnyHash, T.proc.returns(T.anything), T.anything)
+        )
+          .void
+      end
+      private def variant(key, spec = nil)
+      end
+
+      # @api private
+      sig { params(value: T.anything).returns(T.nilable(T.anything)) }
+      private def resolve_variant(value)
+      end
+
+      sig { params(other: T.anything).returns(T::Boolean) }
+      def ===(other)
+      end
+
+      sig { params(other: T.anything).returns(T::Boolean) }
+      def ==(other)
+      end
+
+      # @api private
+      sig { override.params(value: T.anything, state: Orb::Type::Converter::State).returns(T.anything) }
+      def coerce(value, state:)
+      end
+
+      # @api private
+      sig { override.params(value: T.anything).returns(T.anything) }
+      def dump(value)
+      end
+    end
+  end
+end

data/rbi/lib/orb/type/unknown.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module Orb
+  module Type
+    # @api private
+    #
+    # When we don't know what to expect for the value.
+    class Unknown
+      extend Orb::Type::Converter
+
+      abstract!
+      final!
+
+      sig(:final) { params(other: T.anything).returns(T::Boolean) }
+      def self.===(other)
+      end
+
+      sig(:final) { params(other: T.anything).returns(T::Boolean) }
+      def self.==(other)
+      end
+
+      class << self
+        # @api private
+        sig(:final) do
+          override.params(value: T.anything, state: Orb::Type::Converter::State).returns(T.anything)
+        end
+        def coerce(value, state:)
+        end
+
+        # @api private
+        sig(:final) { override.params(value: T.anything).returns(T.anything) }
+        def dump(value)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/type.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Orb
+  Unknown = Orb::Type::Unknown
+
+  BooleanModel = Orb::Type::BooleanModel
+
+  Enum = Orb::Type::Enum
+
+  Union = Orb::Type::Union
+
+  ArrayOf = Orb::Type::ArrayOf
+
+  HashOf = Orb::Type::HashOf
+
+  BaseModel = Orb::Type::BaseModel
+
+  RequestParameters = Orb::Type::RequestParameters
+
+  # This module contains various type declarations.
+  module Type
+  end
+end

data/rbi/lib/orb/util.rbi

@@ -0,0 +1,278 @@
+# typed: strong
+
+module Orb
+  # @api private
+  module Util
+    # Due to the current WIP status of Shapes support in Sorbet, types referencing
+    #   this alias might be refined in the future.
+    AnyHash = T.type_alias { T::Hash[Symbol, T.anything] }
+
+    # @api private
+    sig { returns(Float) }
+    def self.monotonic_secs
+    end
+
+    class << self
+      # @api private
+      sig { returns(String) }
+      def arch
+      end
+
+      # @api private
+      sig { returns(String) }
+      def os
+      end
+    end
+
+    class << self
+      # @api private
+      sig { params(input: T.anything).returns(T::Boolean) }
+      def primitive?(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
+      def coerce_boolean(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.nilable(T::Boolean)) }
+      def coerce_boolean!(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(Integer, T.anything)) }
+      def coerce_integer(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(Float, T.anything)) }
+      def coerce_float(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(T::Hash[T.anything, T.anything], T.anything)) }
+      def coerce_hash(input)
+      end
+    end
+
+    # Use this to indicate that a value should be explicitly removed from a data
+    #   structure when using `Orb::Util.deep_merge`.
+    #
+    #   e.g. merging `{a: 1}` and `{a: OMIT}` should produce `{}`, where merging
+    #   `{a: 1}` and `{}` would produce `{a: 1}`.
+    OMIT = T.let(T.anything, T.anything)
+
+    class << self
+      # @api private
+      sig { params(lhs: T.anything, rhs: T.anything, concat: T::Boolean).returns(T.anything) }
+      private def deep_merge_lr(lhs, rhs, concat: false)
+      end
+
+      # @api private
+      #
+      # Recursively merge one hash with another. If the values at a given key are not
+      #   both hashes, just take the new value.
+      sig do
+        params(values: T::Array[T.anything], sentinel: T.nilable(T.anything), concat: T::Boolean)
+          .returns(T.anything)
+      end
+      def deep_merge(
+        *values,
+        # the value to return if no values are provided.
+        sentinel: nil,
+        # whether to merge sequences by concatenation.
+        concat: false
+      )
+      end
+
+      # @api private
+      sig do
+        params(
+          data: T.any(Orb::Util::AnyHash, T::Array[T.anything], T.anything),
+          pick: T.nilable(T.any(Symbol, Integer, T::Array[T.any(Symbol, Integer)])),
+          sentinel: T.nilable(T.anything),
+          blk: T.nilable(T.proc.returns(T.anything))
+        )
+          .returns(T.nilable(T.anything))
+      end
+      def dig(data, pick, sentinel = nil, &blk)
+      end
+    end
+
+    class << self
+      # @api private
+      sig { params(uri: URI::Generic).returns(String) }
+      def uri_origin(uri)
+      end
+
+      # @api private
+      sig { params(path: T.any(String, T::Array[String])).returns(String) }
+      def interpolate_path(path)
+      end
+    end
+
+    class << self
+      # @api private
+      sig { params(query: T.nilable(String)).returns(T::Hash[String, T::Array[String]]) }
+      def decode_query(query)
+      end
+
+      # @api private
+      sig do
+        params(query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
+          .returns(T.nilable(String))
+      end
+      def encode_query(query)
+      end
+    end
+
+    ParsedUriShape =
+      T.type_alias do
+        {
+          scheme: T.nilable(String),
+          host: T.nilable(String),
+          port: T.nilable(Integer),
+          path: T.nilable(String),
+          query: T::Hash[String, T::Array[String]]
+        }
+      end
+
+    class << self
+      # @api private
+      sig { params(url: T.any(URI::Generic, String)).returns(Orb::Util::ParsedUriShape) }
+      def parse_uri(url)
+      end
+
+      # @api private
+      sig { params(parsed: Orb::Util::ParsedUriShape).returns(URI::Generic) }
+      def unparse_uri(parsed)
+      end
+
+      # @api private
+      sig { params(lhs: Orb::Util::ParsedUriShape, rhs: Orb::Util::ParsedUriShape).returns(URI::Generic) }
+      def join_parsed_uri(lhs, rhs)
+      end
+    end
+
+    class << self
+      # @api private
+      sig do
+        params(
+          headers: T::Hash[String,
+                           T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))]
+        )
+          .returns(T::Hash[String, String])
+      end
+      def normalized_headers(*headers)
+      end
+    end
+
+    # @api private
+    #
+    # An adapter that satisfies the IO interface required by `::IO.copy_stream`
+    class ReadIOAdapter
+      # @api private
+      sig { params(max_len: T.nilable(Integer)).returns(String) }
+      private def read_enum(max_len)
+      end
+
+      # @api private
+      sig { params(max_len: T.nilable(Integer), out_string: T.nilable(String)).returns(T.nilable(String)) }
+      def read(max_len = nil, out_string = nil)
+      end
+
+      # @api private
+      sig do
+        params(
+          stream: T.any(String, IO, StringIO, T::Enumerable[String]),
+          blk: T.proc.params(arg0: String).void
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(stream, &blk)
+      end
+    end
+
+    class << self
+      sig { params(blk: T.proc.params(y: Enumerator::Yielder).void).returns(T::Enumerable[String]) }
+      def writable_enum(&blk)
+      end
+    end
+
+    class << self
+      # @api private
+      sig do
+        params(y: Enumerator::Yielder, boundary: String, key: T.any(Symbol, String), val: T.anything).void
+      end
+      private def write_multipart_chunk(y, boundary:, key:, val:)
+      end
+
+      # @api private
+      sig { params(body: T.anything).returns([String, T::Enumerable[String]]) }
+      private def encode_multipart_streaming(body)
+      end
+
+      # @api private
+      sig { params(headers: T::Hash[String, String], body: T.anything).returns(T.anything) }
+      def encode_content(headers, body)
+      end
+
+      # @api private
+      sig do
+        params(
+          headers: T.any(T::Hash[String, String], Net::HTTPHeader),
+          stream: T::Enumerable[String],
+          suppress_error: T::Boolean
+        )
+          .returns(T.anything)
+      end
+      def decode_content(headers, stream:, suppress_error: false)
+      end
+    end
+
+    class << self
+      # @api private
+      #
+      # https://doc.rust-lang.org/std/iter/trait.FusedIterator.html
+      sig do
+        params(enum: T::Enumerable[T.anything], external: T::Boolean, close: T.proc.void)
+          .returns(T::Enumerable[T.anything])
+      end
+      def fused_enum(enum, external: false, &close)
+      end
+
+      # @api private
+      sig { params(enum: T.nilable(T::Enumerable[T.anything])).void }
+      def close_fused!(enum)
+      end
+
+      # @api private
+      sig do
+        params(enum: T.nilable(T::Enumerable[T.anything]), blk: T.proc.params(arg0: Enumerator::Yielder).void)
+          .returns(T::Enumerable[T.anything])
+      end
+      def chain_fused(enum, &blk)
+      end
+    end
+
+    ServerSentEvent =
+      T.type_alias do
+        {event: T.nilable(String), data: T.nilable(String), id: T.nilable(String), retry: T.nilable(Integer)}
+      end
+
+    class << self
+      # @api private
+      sig { params(enum: T::Enumerable[String]).returns(T::Enumerable[String]) }
+      def decode_lines(enum)
+      end
+
+      # @api private
+      #
+      # https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream
+      sig { params(lines: T::Enumerable[String]).returns(Orb::Util::ServerSentEvent) }
+      def decode_sse(lines)
+      end
+    end
+  end
+end

data/rbi/lib/orb/version.rbi

@@ -0,0 +1,5 @@
+# typed: strong
+
+module Orb
+  VERSION = "0.1.0-alpha.33"
+end