orb-billing 0.1.0.pre.alpha.33

data/sig/orb/type/request_parameters.rbs

@@ -0,0 +1,13 @@
+module Orb
+  module Type
+    type request_parameters = { request_options: Orb::request_opts }
+
+    module RequestParameters
+      attr_accessor request_options: Orb::request_opts
+
+      module Converter
+        def dump_request: (top params) -> [top, ::Hash[Symbol, top]]
+      end
+    end
+  end
+end

data/sig/orb/type/union.rbs

@@ -0,0 +1,37 @@
+module Orb
+  module Type
+    module Union
+      include Orb::Type::Converter
+
+      private def self.known_variants: -> ::Array[[Symbol?, (^-> Orb::Type::Converter::input)]]
+
+      def self.derefed_variants: -> ::Array[[Symbol?, top]]
+
+      def self.variants: -> ::Array[top]
+
+      private def self.discriminator: (Symbol property) -> void
+
+      private def self.variant: (
+        Symbol
+        | ::Hash[Symbol, top]
+        | ^-> Orb::Type::Converter::input
+        | Orb::Type::Converter::input key,
+        ?::Hash[Symbol, top]
+        | ^-> Orb::Type::Converter::input
+        | Orb::Type::Converter::input spec
+      ) -> void
+
+      private def self.resolve_variant: (
+        top value
+      ) -> Orb::Type::Converter::input?
+
+      def ===: (top other) -> bool
+
+      def ==: (top other) -> bool
+
+      def coerce: (top value, state: Orb::Type::Converter::state) -> top
+
+      def dump: (top value) -> top
+    end
+  end
+end

data/sig/orb/type/unknown.rbs

@@ -0,0 +1,15 @@
+module Orb
+  module Type
+    class Unknown
+      extend Orb::Type::Converter
+
+      def self.===: (top other) -> bool
+
+      def self.==: (top other) -> bool
+
+      def self.coerce: (top value, state: Orb::Type::Converter::state) -> top
+
+      def self.dump: (top value) -> top
+    end
+  end
+end

data/sig/orb/type.rbs

@@ -0,0 +1,22 @@
+module Orb
+  class Unknown = Orb::Type::Unknown
+
+  class BooleanModel = Orb::Type::BooleanModel
+
+  module Enum = Orb::Type::Enum
+
+  module Union = Orb::Type::Union
+
+  class ArrayOf = Orb::Type::ArrayOf
+
+  class HashOf = Orb::Type::HashOf
+
+  class BaseModel = Orb::Type::BaseModel
+
+  type request_parameters = Orb::Type::request_parameters
+
+  module RequestParameters = Orb::Type::RequestParameters
+
+  module Type
+  end
+end

data/sig/orb/util.rbs

@@ -0,0 +1,132 @@
+module Orb
+  module Util
+    def self?.monotonic_secs: -> Float
+
+    def self?.arch: -> String
+
+    def self?.os: -> String
+
+    def self?.primitive?: (top input) -> bool
+
+    def self?.coerce_boolean: (top input) -> (bool | top)
+
+    def self?.coerce_boolean!: (top input) -> bool?
+
+    def self?.coerce_integer: (top input) -> (Integer | top)
+
+    def self?.coerce_float: (top input) -> (Float | top)
+
+    def self?.coerce_hash: (top input) -> (::Hash[top, top] | top)
+
+    OMIT: top
+
+    def self?.deep_merge_lr: (top lhs, top rhs, ?concat: bool) -> top
+
+    def self?.deep_merge: (
+      *::Array[top] values,
+      ?sentinel: top?,
+      ?concat: bool
+    ) -> top
+
+    def self?.dig: (
+      ::Hash[Symbol, top] | ::Array[top] | top data,
+      (Symbol | Integer | ::Array[(Symbol | Integer)])? pick,
+      ?top? sentinel
+    ) {
+      -> top?
+    } -> top?
+
+    def self?.uri_origin: (URI::Generic uri) -> String
+
+    def self?.interpolate_path: (String | ::Array[String] path) -> String
+
+    def self?.decode_query: (String? query) -> ::Hash[String, ::Array[String]]
+
+    def self?.encode_query: (
+      ::Hash[String, (::Array[String] | String)?]? query
+    ) -> String?
+
+    type parsed_uri =
+      {
+        scheme: String?,
+        host: String?,
+        port: Integer?,
+        path: String?,
+        query: ::Hash[String, ::Array[String]]
+      }
+
+    def self?.parse_uri: (URI::Generic | String url) -> Orb::Util::parsed_uri
+
+    def self?.unparse_uri: (Orb::Util::parsed_uri parsed) -> URI::Generic
+
+    def self?.join_parsed_uri: (
+      Orb::Util::parsed_uri lhs,
+      Orb::Util::parsed_uri rhs
+    ) -> URI::Generic
+
+    def self?.normalized_headers: (
+      *::Hash[String, (String
+      | Integer
+      | ::Array[(String | Integer)?])?] headers
+    ) -> ::Hash[String, String]
+
+    class ReadIOAdapter
+      private def read_enum: (Integer? max_len) -> String
+
+      def read: (?Integer? max_len, ?String? out_string) -> String?
+
+      def initialize: (
+        String | IO | StringIO | Enumerable[String] stream
+      ) {
+        (String arg0) -> void
+      } -> void
+    end
+
+    def self?.writable_enum: {
+      (Enumerator::Yielder y) -> void
+    } -> Enumerable[String]
+
+    def self?.write_multipart_chunk: (
+      Enumerator::Yielder y,
+      boundary: String,
+      key: Symbol | String,
+      val: top
+    ) -> void
+
+    def self?.encode_multipart_streaming: (
+      top body
+    ) -> [String, Enumerable[String]]
+
+    def self?.encode_content: (::Hash[String, String] headers, top body) -> top
+
+    def self?.decode_content: (
+      ::Hash[String, String] headers,
+      stream: Enumerable[String],
+      ?suppress_error: bool
+    ) -> top
+
+    def self?.fused_enum: (
+      Enumerable[top] enum,
+      ?external: bool
+    ) {
+      -> void
+    } -> Enumerable[top]
+
+    def self?.close_fused!: (Enumerable[top]? enum) -> void
+
+    def self?.chain_fused: (
+      Enumerable[top]? enum
+    ) {
+      (Enumerator::Yielder arg0) -> void
+    } -> Enumerable[top]
+
+    type server_sent_event =
+      { event: String?, data: String?, id: String?, retry: Integer? }
+
+    def self?.decode_lines: (Enumerable[String] enum) -> Enumerable[String]
+
+    def self?.decode_sse: (
+      Enumerable[String] lines
+    ) -> Orb::Util::server_sent_event
+  end
+end

data/sig/orb/version.rbs

@@ -0,0 +1,3 @@
+module Orb
+  VERSION: "0.1.0-alpha.32"
+end