lithic 0.1.0.pre.alpha.1

data/sig/lithic/base_client.rbs

@@ -0,0 +1,106 @@
+module Lithic
+  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::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::BaseClient::request_components req) -> void
+
+    def self.should_retry?: (
+      Integer status,
+      headers: ::Hash[String, String]
+    ) -> bool
+
+    def self.follow_redirect: (
+      Lithic::BaseClient::request_input request,
+      status: Integer,
+      response_headers: ::Hash[String, String]
+    ) -> Lithic::BaseClient::request_input
+
+    def self.reap_connection!: (
+      Integer | Lithic::APIConnectionError status,
+      stream: Enumerable[String]?
+    ) -> void
+
+    # @api private
+    attr_accessor requester: top
+
+    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::BaseClient::request_components req,
+      Lithic::request_options opts
+    ) -> Lithic::BaseClient::request_input
+
+    private def retry_delay: (
+      ::Hash[String, String] headers,
+      retry_count: Integer
+    ) -> Float
+
+    private def send_request: (
+      Lithic::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::Converter::input?,
+        ?options: Lithic::request_opts?
+      ) -> top
+      | (Lithic::BaseClient::request_components req) -> top
+
+    def inspect: -> String
+  end
+end

data/sig/lithic/base_model.rbs

@@ -0,0 +1,260 @@
+module Lithic
+  module Converter
+    type input = Lithic::Converter | Class
+
+    def coerce: (top value) -> top
+
+    def dump: (top value) -> top
+
+    def try_strict_coerce: (
+      top value
+    ) -> ([true, top, nil] | [false, bool, Integer])
+
+    def self.type_info: (
+      {
+        const: (nil | bool | Integer | Float | Symbol)?,
+        enum: ^-> Lithic::Converter::input?,
+        union: ^-> Lithic::Converter::input?
+      }
+      | ^-> Lithic::Converter::input
+      | Lithic::Converter::input spec
+    ) -> (^-> top)
+
+    def self.coerce: (Lithic::Converter::input target, top value) -> top
+
+    def self.dump: (Lithic::Converter::input target, top value) -> top
+
+    def self.try_strict_coerce: (
+      Lithic::Converter::input target,
+      top value
+    ) -> top
+  end
+
+  class Unknown
+    extend Lithic::Converter
+
+    def self.===: (top other) -> bool
+
+    def self.==: (top other) -> bool
+
+    def self.coerce: (top value) -> top
+
+    def self.dump: (top value) -> top
+
+    def self.try_strict_coerce: (
+      top value
+    ) -> ([true, top, nil] | [false, bool, Integer])
+  end
+
+  class BooleanModel
+    extend Lithic::Converter
+
+    def self.===: (top other) -> bool
+
+    def self.==: (top other) -> bool
+
+    def self.coerce: (bool | top value) -> (bool | top)
+
+    def self.dump: (bool | top value) -> (bool | top)
+
+    def self.try_strict_coerce: (
+      top value
+    ) -> ([true, top, nil] | [false, bool, Integer])
+  end
+
+  module Enum
+    include Lithic::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) -> (Symbol | top)
+
+    def dump: (Symbol | top value) -> (Symbol | top)
+
+    def try_strict_coerce: (
+      top value
+    ) -> ([true, top, nil] | [false, bool, Integer])
+  end
+
+  module Union
+    include Lithic::Converter
+
+    private def self.known_variants: -> ::Array[[Symbol?, (^-> Lithic::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::Converter::input
+      | Lithic::Converter::input key,
+      ?::Hash[Symbol, top]
+      | ^-> Lithic::Converter::input
+      | Lithic::Converter::input spec
+    ) -> void
+
+    private def self.resolve_variant: (top value) -> Lithic::Converter::input?
+
+    def ===: (top other) -> bool
+
+    def ==: (top other) -> bool
+
+    def coerce: (top value) -> top
+
+    def dump: (top value) -> top
+
+    def try_strict_coerce: (
+      top value
+    ) -> ([true, top, nil] | [false, bool, Integer])
+  end
+
+  class ArrayOf
+    include Lithic::Converter
+
+    def self.[]: (
+      ::Hash[Symbol, top]
+      | ^-> Lithic::Converter::input
+      | Lithic::Converter::input type_info,
+      ?::Hash[Symbol, top] spec
+    ) -> instance
+
+    def ===: (top other) -> bool
+
+    def ==: (top other) -> bool
+
+    def coerce: (Enumerable[top] | top value) -> (::Array[top] | top)
+
+    def dump: (Enumerable[top] | top value) -> (::Array[top] | top)
+
+    def try_strict_coerce: (
+      top value
+    ) -> ([true, top, nil] | [false, bool, Integer])
+
+    def item_type: -> top
+
+    def initialize: (
+      ::Hash[Symbol, top]
+      | ^-> Lithic::Converter::input
+      | Lithic::Converter::input type_info,
+      ?::Hash[Symbol, top] spec
+    ) -> void
+  end
+
+  class HashOf
+    include Lithic::Converter
+
+    def self.[]: (
+      ::Hash[Symbol, top]
+      | ^-> Lithic::Converter::input
+      | Lithic::Converter::input type_info,
+      ?::Hash[Symbol, top] spec
+    ) -> instance
+
+    def ===: (top other) -> bool
+
+    def ==: (top other) -> bool
+
+    def coerce: (::Hash[top, top] | top value) -> (::Hash[Symbol, top] | top)
+
+    def dump: (::Hash[top, top] | top value) -> (::Hash[Symbol, top] | top)
+
+    def try_strict_coerce: (
+      top value
+    ) -> ([true, top, nil] | [false, bool, Integer])
+
+    def item_type: -> top
+
+    def initialize: (
+      ::Hash[Symbol, top]
+      | ^-> Lithic::Converter::input
+      | Lithic::Converter::input type_info,
+      ?::Hash[Symbol, top] spec
+    ) -> void
+  end
+
+  class BaseModel
+    extend Lithic::Converter
+
+    type known_field = { mode: (:coerce | :dump)?, required: bool }
+
+    def self.known_fields: -> ::Hash[Symbol, (Lithic::BaseModel::known_field
+    & { type_fn: (^-> Lithic::Converter::input) })]
+
+    def self.reverse_map: -> ::Hash[Symbol, Symbol]
+
+    def self.fields: -> ::Hash[Symbol, (Lithic::BaseModel::known_field
+    & { type: Lithic::Converter::input })]
+
+    def self.defaults: -> ::Hash[Symbol, (^-> Class)]
+
+    private def self.add_field: (
+      Symbol name_sym,
+      required: bool,
+      type_info: {
+        const: (nil | bool | Integer | Float | Symbol)?,
+        enum: ^-> Lithic::Converter::input?,
+        union: ^-> Lithic::Converter::input?,
+        api_name: Symbol
+      }
+      | ^-> Lithic::Converter::input
+      | Lithic::Converter::input,
+      spec: ::Hash[Symbol, top]
+    ) -> void
+
+    def self.required: (
+      Symbol name_sym,
+      ::Hash[Symbol, top]
+      | ^-> Lithic::Converter::input
+      | Lithic::Converter::input type_info,
+      ?::Hash[Symbol, top] spec
+    ) -> void
+
+    def self.optional: (
+      Symbol name_sym,
+      ::Hash[Symbol, top]
+      | ^-> Lithic::Converter::input
+      | Lithic::Converter::input type_info,
+      ?::Hash[Symbol, top] spec
+    ) -> void
+
+    private def self.request_only: { -> void } -> void
+
+    private def self.response_only: { -> void } -> void
+
+    def ==: (top other) -> bool
+
+    def self.coerce: (
+      Lithic::BaseModel | ::Hash[top, top] | top value
+    ) -> (instance | top)
+
+    def self.dump: (instance | top value) -> (::Hash[top, top] | top)
+
+    def self.try_strict_coerce: (
+      top value
+    ) -> ([true, top, nil] | [false, bool, Integer])
+
+    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 initialize: (?::Hash[Symbol, top] | self data) -> void
+
+    def to_s: -> String
+
+    def inspect: -> String
+  end
+end

data/sig/lithic/base_page.rbs

@@ -0,0 +1,20 @@
+module Lithic
+  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::BaseClient,
+      req: Lithic::BaseClient::request_components,
+      headers: ::Hash[String, String],
+      page_data: top
+    ) -> void
+  end
+end

data/sig/lithic/client.rbs

@@ -0,0 +1,84 @@
+module Lithic
+  class Client < Lithic::BaseClient
+    DEFAULT_MAX_RETRIES: 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS: Float
+
+    DEFAULT_INITIAL_RETRY_DELAY: Float
+
+    DEFAULT_MAX_RETRY_DELAY: Float
+
+    ENVIRONMENTS: {
+      production: "https://api.lithic.com",
+      sandbox: "https://sandbox.lithic.com"
+    }
+
+    attr_reader api_key: String
+
+    attr_reader accounts: Lithic::Resources::Accounts
+
+    attr_reader account_holders: Lithic::Resources::AccountHolders
+
+    attr_reader auth_rules: Lithic::Resources::AuthRules
+
+    attr_reader auth_stream_enrollment: Lithic::Resources::AuthStreamEnrollment
+
+    attr_reader tokenization_decisioning: Lithic::Resources::TokenizationDecisioning
+
+    attr_reader tokenizations: Lithic::Resources::Tokenizations
+
+    attr_reader cards: Lithic::Resources::Cards
+
+    attr_reader balances: Lithic::Resources::Balances
+
+    attr_reader aggregate_balances: Lithic::Resources::AggregateBalances
+
+    attr_reader disputes: Lithic::Resources::Disputes
+
+    attr_reader events: Lithic::Resources::Events
+
+    attr_reader transfers: Lithic::Resources::Transfers
+
+    attr_reader financial_accounts: Lithic::Resources::FinancialAccounts
+
+    attr_reader transactions: Lithic::Resources::Transactions
+
+    attr_reader responder_endpoints: Lithic::Resources::ResponderEndpoints
+
+    attr_reader external_bank_accounts: Lithic::Resources::ExternalBankAccounts
+
+    attr_reader payments: Lithic::Resources::Payments
+
+    attr_reader three_ds: Lithic::Resources::ThreeDS
+
+    attr_reader reports: Lithic::Resources::Reports
+
+    attr_reader card_programs: Lithic::Resources::CardPrograms
+
+    attr_reader digital_card_art: Lithic::Resources::DigitalCardArt
+
+    attr_reader book_transfers: Lithic::Resources::BookTransfers
+
+    attr_reader credit_products: Lithic::Resources::CreditProducts
+
+    attr_reader external_payments: Lithic::Resources::ExternalPayments
+
+    attr_reader management_operations: Lithic::Resources::ManagementOperations
+
+    def api_status: (
+      ?request_options: Lithic::request_opts
+    ) -> Lithic::Models::APIStatus
+
+    private def auth_headers: -> ::Hash[String, String]
+
+    def initialize: (
+      ?environment: :production | :sandbox | nil,
+      ?base_url: String?,
+      ?api_key: String?,
+      ?max_retries: Integer,
+      ?timeout: Float,
+      ?initial_retry_delay: Float,
+      ?max_retry_delay: Float
+    ) -> void
+  end
+end

data/sig/lithic/cursor_page.rbs

@@ -0,0 +1,11 @@
+module Lithic
+  class CursorPage[Elem]
+    include Lithic::BasePage[Elem]
+
+    attr_accessor data: ::Array[Elem]?
+
+    attr_accessor has_more: bool
+
+    def inspect: -> String
+  end
+end

data/sig/lithic/errors.rbs

@@ -0,0 +1,99 @@
+module Lithic
+  class Error < StandardError
+    attr_accessor cause: StandardError?
+  end
+
+  class ConversionError < Lithic::Error
+  end
+
+  class APIError < Lithic::Error
+    attr_accessor url: URI::Generic
+
+    attr_accessor status: Integer?
+
+    attr_accessor body: top?
+
+    def initialize: (
+      url: URI::Generic,
+      ?status: Integer?,
+      ?body: Object?,
+      ?request: nil,
+      ?response: nil,
+      ?message: String?
+    ) -> void
+  end
+
+  class APIConnectionError < Lithic::APIError
+    def initialize: (
+      url: URI::Generic,
+      ?status: nil,
+      ?body: nil,
+      ?request: nil,
+      ?response: nil,
+      ?message: String?
+    ) -> void
+  end
+
+  class APITimeoutError < Lithic::APIConnectionError
+    def initialize: (
+      url: URI::Generic,
+      ?status: nil,
+      ?body: nil,
+      ?request: nil,
+      ?response: nil,
+      ?message: String?
+    ) -> void
+  end
+
+  class APIStatusError < Lithic::APIError
+    def self.for: (
+      url: URI::Generic,
+      status: Integer,
+      body: Object?,
+      request: nil,
+      response: nil,
+      ?message: String?
+    ) -> instance
+
+    def initialize: (
+      url: URI::Generic,
+      status: Integer,
+      body: Object?,
+      request: nil,
+      response: nil,
+      ?message: String?
+    ) -> void
+  end
+
+  class BadRequestError < Lithic::APIStatusError
+    HTTP_STATUS: 400
+  end
+
+  class AuthenticationError < Lithic::APIStatusError
+    HTTP_STATUS: 401
+  end
+
+  class PermissionDeniedError < Lithic::APIStatusError
+    HTTP_STATUS: 403
+  end
+
+  class NotFoundError < Lithic::APIStatusError
+    HTTP_STATUS: 404
+  end
+
+  class ConflictError < Lithic::APIStatusError
+    HTTP_STATUS: 409
+  end
+
+  class UnprocessableEntityError < Lithic::APIStatusError
+    HTTP_STATUS: 422
+  end
+
+  class RateLimitError < Lithic::APIStatusError
+    HTTP_STATUS: 429
+  end
+
+  class InternalServerError < Lithic::APIStatusError
+    HTTP_STATUS: Range[Integer]
+  end
+end

data/sig/lithic/extern.rbs

@@ -0,0 +1,4 @@
+module Lithic
+  module Extern
+  end
+end