lithic 0.1.0.pre.alpha.4 → 0.1.0.pre.alpha.6

data/sig/lithic/transport/base_client.rbs

@@ -1,110 +0,0 @@
-module Lithic
-  module Transport
-    class BaseClient
-      type request_components =
-        {
-          method: Symbol,
-          path: String | ::Array[String],
-          query: ::Hash[String, (::Array[String] | String)?]?,
-          headers: ::Hash[String, (String
-          | Integer
-          | ::Array[(String | Integer)?])?]?,
-          body: top?,
-          unwrap: Symbol?,
-          page: Class?,
-          stream: Class?,
-          model: Lithic::Type::Converter::input?,
-          options: Lithic::request_opts?
-        }
-
-      type request_input =
-        {
-          method: Symbol,
-          url: URI::Generic,
-          headers: ::Hash[String, String],
-          body: top,
-          max_retries: Integer,
-          timeout: Float
-        }
-
-      MAX_REDIRECTS: 20
-
-      PLATFORM_HEADERS: ::Hash[String, String]
-
-      def self.validate!: (
-        Lithic::Transport::BaseClient::request_components req
-      ) -> void
-
-      def self.should_retry?: (
-        Integer status,
-        headers: ::Hash[String, String]
-      ) -> bool
-
-      def self.follow_redirect: (
-        Lithic::Transport::BaseClient::request_input request,
-        status: Integer,
-        response_headers: ::Hash[String, String]
-      ) -> Lithic::Transport::BaseClient::request_input
-
-      def self.reap_connection!: (
-        Integer | Lithic::Errors::APIConnectionError status,
-        stream: Enumerable[String]?
-      ) -> void
-
-      # @api private
-      attr_accessor requester: Lithic::Transport::PooledNetRequester
-
-      def initialize: (
-        base_url: String,
-        ?timeout: Float,
-        ?max_retries: Integer,
-        ?initial_retry_delay: Float,
-        ?max_retry_delay: Float,
-        ?headers: ::Hash[String, (String
-        | Integer
-        | ::Array[(String | Integer)?])?],
-        ?idempotency_header: String?
-      ) -> void
-
-      private def auth_headers: -> ::Hash[String, String]
-
-      private def generate_idempotency_key: -> String
-
-      private def build_request: (
-        Lithic::Transport::BaseClient::request_components req,
-        Lithic::request_options opts
-      ) -> Lithic::Transport::BaseClient::request_input
-
-      private def retry_delay: (
-        ::Hash[String, String] headers,
-        retry_count: Integer
-      ) -> Float
-
-      private def send_request: (
-        Lithic::Transport::BaseClient::request_input request,
-        redirect_count: Integer,
-        retry_count: Integer,
-        send_retry_header: bool
-      ) -> [Integer, top, Enumerable[String]]
-
-      def request:
-        (
-          Symbol method,
-          String | ::Array[String] path,
-          ?query: ::Hash[String, (::Array[String] | String)?]?,
-          ?headers: ::Hash[String, (String
-          | Integer
-          | ::Array[(String | Integer)?])?]?,
-          ?body: top?,
-          ?unwrap: Symbol?,
-          ?page: Class?,
-          ?stream: Class?,
-          ?model: Lithic::Type::Converter::input?,
-          ?options: Lithic::request_opts?
-        ) -> top
-        | (Lithic::Transport::BaseClient::request_components req) -> top
-
-      def inspect: -> String
-    end
-  end
-end

data/sig/lithic/transport/pooled_net_requester.rbs

@@ -1,39 +0,0 @@
-module Lithic
-  module Transport
-    class PooledNetRequester
-      type request =
-        {
-          method: Symbol,
-          url: URI::Generic,
-          headers: ::Hash[String, String],
-          body: top,
-          deadline: Float
-        }
-
-      KEEP_ALIVE_TIMEOUT: 30
-
-      def self.connect: (URI::Generic url) -> top
-
-      def self.calibrate_socket_timeout: (top conn, Float deadline) -> void
-
-      def self.build_request: (
-        Lithic::Transport::PooledNetRequester::request request
-      ) {
-        (String arg0) -> void
-      } -> top
-
-      private def with_pool: (
-        URI::Generic url,
-        deadline: Float
-      ) {
-        (top arg0) -> void
-      } -> void
-
-      def execute: (
-        Lithic::Transport::PooledNetRequester::request request
-      ) -> [Integer, top, Enumerable[String]]
-
-      def initialize: (?size: Integer) -> void
-    end
-  end
-end

data/sig/lithic/type/array_of.rbs

@@ -1,36 +0,0 @@
-module Lithic
-  module Type
-    class ArrayOf[Elem]
-      include Lithic::Type::Converter
-
-      def self.[]: (
-        ::Hash[Symbol, top]
-        | ^-> Lithic::Type::Converter::input
-        | Lithic::Type::Converter::input type_info,
-        ?::Hash[Symbol, top] spec
-      ) -> instance
-
-      def ===: (top other) -> bool
-
-      def ==: (top other) -> bool
-
-      def coerce: (
-        Enumerable[Elem] | top value,
-        state: Lithic::Type::Converter::state
-      ) -> (::Array[top] | top)
-
-      def dump: (Enumerable[Elem] | top value) -> (::Array[top] | top)
-
-      def item_type: -> Elem
-
-      def nilable?: -> bool
-
-      def initialize: (
-        ::Hash[Symbol, top]
-        | ^-> Lithic::Type::Converter::input
-        | Lithic::Type::Converter::input type_info,
-        ?::Hash[Symbol, top] spec
-      ) -> void
-    end
-  end
-end

data/sig/lithic/type/base_model.rbs

@@ -1,77 +0,0 @@
-module Lithic
-  module Type
-    class BaseModel
-      extend Lithic::Type::Converter
-
-      type known_field =
-        { mode: (:coerce | :dump)?, required: bool, nilable: bool }
-
-      def self.known_fields: -> ::Hash[Symbol, (Lithic::BaseModel::known_field
-      & { type_fn: (^-> Lithic::Type::Converter::input) })]
-
-      def self.fields: -> ::Hash[Symbol, (Lithic::BaseModel::known_field
-      & { type: Lithic::Type::Converter::input })]
-
-      private def self.add_field: (
-        Symbol name_sym,
-        required: bool,
-        type_info: {
-          const: (nil | bool | Integer | Float | Symbol)?,
-          enum: ^-> Lithic::Type::Converter::input?,
-          union: ^-> Lithic::Type::Converter::input?,
-          api_name: Symbol
-        }
-        | ^-> Lithic::Type::Converter::input
-        | Lithic::Type::Converter::input,
-        spec: ::Hash[Symbol, top]
-      ) -> void
-
-      def self.required: (
-        Symbol name_sym,
-        ::Hash[Symbol, top]
-        | ^-> Lithic::Type::Converter::input
-        | Lithic::Type::Converter::input type_info,
-        ?::Hash[Symbol, top] spec
-      ) -> void
-
-      def self.optional: (
-        Symbol name_sym,
-        ::Hash[Symbol, top]
-        | ^-> Lithic::Type::Converter::input
-        | Lithic::Type::Converter::input type_info,
-        ?::Hash[Symbol, top] spec
-      ) -> void
-
-      private def self.request_only: { -> void } -> void
-
-      private def self.response_only: { -> void } -> void
-
-      def self.==: (top other) -> bool
-
-      def ==: (top other) -> bool
-
-      def self.coerce: (
-        Lithic::BaseModel | ::Hash[top, top] | top value,
-        state: Lithic::Type::Converter::state
-      ) -> (instance | top)
-
-      def self.dump: (instance | top value) -> (::Hash[top, top] | top)
-
-      def []: (Symbol key) -> top?
-
-      def to_h: -> ::Hash[Symbol, top]
-
-      alias to_hash to_h
-
-      def deconstruct_keys: (::Array[Symbol]? keys) -> ::Hash[Symbol, top]
-
-      def to_json: (*top a) -> String
-
-      def to_yaml: (*top a) -> String
-
-      def initialize: (?::Hash[Symbol, top] | self data) -> void
-
-      def inspect: -> String
-    end
-  end
-end

data/sig/lithic/type/base_page.rbs

@@ -1,22 +0,0 @@
-module Lithic
-  module Type
-    module BasePage[Elem]
-      def next_page?: -> bool
-
-      def next_page: -> self
-
-      def auto_paging_each: { (Elem arg0) -> void } -> void
-
-      def to_enum: -> Enumerable[Elem]
-
-      alias enum_for to_enum
-
-      def initialize: (
-        client: Lithic::Transport::BaseClient,
-        req: Lithic::Transport::BaseClient::request_components,
-        headers: ::Hash[String, String],
-        page_data: top
-      ) -> void
-    end
-  end
-end

data/sig/lithic/type/boolean_model.rbs

@@ -1,18 +0,0 @@
-module Lithic
-  module Type
-    class BooleanModel
-      extend Lithic::Type::Converter
-
-      def self.===: (top other) -> bool
-
-      def self.==: (top other) -> bool
-
-      def self.coerce: (
-        bool | top value,
-        state: Lithic::Type::Converter::state
-      ) -> (bool | top)
-
-      def self.dump: (bool | top value) -> (bool | top)
-    end
-  end
-end

data/sig/lithic/type/converter.rbs

@@ -1,36 +0,0 @@
-module Lithic
-  module Type
-    module Converter
-      type input = Lithic::Type::Converter | Class
-
-      type state =
-        {
-          strictness: bool | :strong,
-          exactness: { yes: Integer, no: Integer, maybe: Integer },
-          branched: Integer
-        }
-
-      def coerce: (top value, state: Lithic::Type::Converter::state) -> top
-
-      def dump: (top value) -> top
-
-      def self.type_info: (
-        {
-          const: (nil | bool | Integer | Float | Symbol)?,
-          enum: ^-> Lithic::Type::Converter::input?,
-          union: ^-> Lithic::Type::Converter::input?
-        }
-        | ^-> Lithic::Type::Converter::input
-        | Lithic::Type::Converter::input spec
-      ) -> (^-> top)
-
-      def self.coerce: (
-        Lithic::Type::Converter::input target,
-        top value,
-        ?state: Lithic::Type::Converter::state
-      ) -> top
-
-      def self.dump: (Lithic::Type::Converter::input target, top value) -> top
-    end
-  end
-end

data/sig/lithic/type/enum.rbs

@@ -1,22 +0,0 @@
-module Lithic
-  module Type
-    module Enum
-      include Lithic::Type::Converter
-
-      def self.values: -> ::Array[(nil | bool | Integer | Float | Symbol)]
-
-      private def self.finalize!: -> void
-
-      def ===: (top other) -> bool
-
-      def ==: (top other) -> bool
-
-      def coerce: (
-        String | Symbol | top value,
-        state: Lithic::Type::Converter::state
-      ) -> (Symbol | top)
-
-      def dump: (Symbol | top value) -> (Symbol | top)
-    end
-  end
-end

data/sig/lithic/type/hash_of.rbs

@@ -1,36 +0,0 @@
-module Lithic
-  module Type
-    class HashOf[Elem]
-      include Lithic::Type::Converter
-
-      def self.[]: (
-        ::Hash[Symbol, top]
-        | ^-> Lithic::Type::Converter::input
-        | Lithic::Type::Converter::input type_info,
-        ?::Hash[Symbol, top] spec
-      ) -> instance
-
-      def ===: (top other) -> bool
-
-      def ==: (top other) -> bool
-
-      def coerce: (
-        ::Hash[top, top] | top value,
-        state: Lithic::Type::Converter::state
-      ) -> (::Hash[Symbol, top] | top)
-
-      def dump: (::Hash[top, top] | top value) -> (::Hash[Symbol, top] | top)
-
-      def item_type: -> Elem
-
-      def nilable?: -> bool
-
-      def initialize: (
-        ::Hash[Symbol, top]
-        | ^-> Lithic::Type::Converter::input
-        | Lithic::Type::Converter::input type_info,
-        ?::Hash[Symbol, top] spec
-      ) -> void
-    end
-  end
-end

data/sig/lithic/type/request_parameters.rbs

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

data/sig/lithic/type/union.rbs

@@ -1,37 +0,0 @@
-module Lithic
-  module Type
-    module Union
-      include Lithic::Type::Converter
-
-      private def self.known_variants: -> ::Array[[Symbol?, (^-> Lithic::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]
-        | ^-> Lithic::Type::Converter::input
-        | Lithic::Type::Converter::input key,
-        ?::Hash[Symbol, top]
-        | ^-> Lithic::Type::Converter::input
-        | Lithic::Type::Converter::input spec
-      ) -> void
-
-      private def self.resolve_variant: (
-        top value
-      ) -> Lithic::Type::Converter::input?
-
-      def ===: (top other) -> bool
-
-      def ==: (top other) -> bool
-
-      def coerce: (top value, state: Lithic::Type::Converter::state) -> top
-
-      def dump: (top value) -> top
-    end
-  end
-end

data/sig/lithic/type/unknown.rbs

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

data/sig/lithic/type.rbs

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

data/sig/lithic/util.rbs

@@ -1,132 +0,0 @@
-module Lithic
-  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) -> Lithic::Util::parsed_uri
-
-    def self?.unparse_uri: (Lithic::Util::parsed_uri parsed) -> URI::Generic
-
-    def self?.join_parsed_uri: (
-      Lithic::Util::parsed_uri lhs,
-      Lithic::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
-    ) -> Lithic::Util::server_sent_event
-  end
-end