finch-api 0.1.0.pre.alpha.1

data/rbi/lib/finch-api/util.rbi

@@ -0,0 +1,167 @@
+# typed: strong
+
+module FinchAPI
+  module Util
+    sig { returns(Float) }
+    def self.monotonic_secs
+    end
+
+    sig { returns(String) }
+    def self.arch
+    end
+
+    sig { returns(String) }
+    def self.os
+    end
+
+    sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
+    def self.primitive?(input)
+    end
+
+    sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
+    def self.coerce_boolean(input)
+    end
+
+    sig { params(input: T.anything).returns(T.nilable(T::Boolean)) }
+    def self.coerce_boolean!(input)
+    end
+
+    sig { params(input: T.anything).returns(T.any(Integer, T.anything)) }
+    def self.coerce_integer(input)
+    end
+
+    sig { params(input: T.anything).returns(T.any(Float, T.anything)) }
+    def self.coerce_float(input)
+    end
+
+    sig { params(input: T.anything).returns(T.any(T::Hash[T.anything, T.anything], T.anything)) }
+    def self.coerce_hash(input)
+    end
+
+    OMIT = T.let(T.anything, T.anything)
+
+    sig { params(lhs: T.anything, rhs: T.anything, concat: T::Boolean).returns(T.anything) }
+    private_class_method def self.deep_merge_lr(lhs, rhs, concat: false)
+    end
+
+    sig do
+      params(values: T::Array[T.anything], sentinel: T.nilable(T.anything), concat: T::Boolean)
+        .returns(T.anything)
+    end
+    def self.deep_merge(*values, sentinel: nil, concat: false)
+    end
+
+    sig do
+      params(
+        data: T.any(T::Hash[Symbol, T.anything], 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 self.dig(data, pick, sentinel = nil, &blk)
+    end
+
+    sig { params(uri: URI::Generic).returns(String) }
+    def self.uri_origin(uri)
+    end
+
+    sig { params(path: T.any(String, T::Array[String])).returns(String) }
+    def self.interpolate_path(path)
+    end
+
+    sig { params(query: T.nilable(String)).returns(T::Hash[String, T::Array[String]]) }
+    def self.decode_query(query)
+    end
+
+    sig do
+      params(query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
+        .returns(T.nilable(String))
+    end
+    def self.encode_query(query)
+    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
+
+    sig { params(url: T.any(URI::Generic, String)).returns(FinchAPI::Util::ParsedUriShape) }
+    def self.parse_uri(url)
+    end
+
+    sig { params(parsed: FinchAPI::Util::ParsedUriShape).returns(URI::Generic) }
+    def self.unparse_uri(parsed)
+    end
+
+    sig do
+      params(lhs: FinchAPI::Util::ParsedUriShape, rhs: FinchAPI::Util::ParsedUriShape).returns(URI::Generic)
+    end
+    def self.join_parsed_uri(lhs, rhs)
+    end
+
+    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 self.normalized_headers(*headers)
+    end
+
+    sig { params(io: StringIO, boundary: String, key: T.any(Symbol, String), val: T.anything).void }
+    private_class_method def self.encode_multipart_formdata(io, boundary:, key:, val:)
+    end
+
+    sig { params(headers: T::Hash[String, String], body: T.anything).returns(T.anything) }
+    def self.encode_content(headers, body)
+    end
+
+    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 self.decode_content(headers, stream:, suppress_error: false)
+    end
+
+    sig { params(enum: T::Enumerable[T.anything], close: T.proc.void).returns(T::Enumerable[T.anything]) }
+    def self.fused_enum(enum, &close)
+    end
+
+    sig { params(enum: T.nilable(T::Enumerable[T.anything])).void }
+    def self.close_fused!(enum)
+    end
+
+    sig do
+      params(
+        enum: T.nilable(T::Enumerable[T.anything]),
+        blk: T.proc.params(arg0: Enumerator::Yielder).void
+      ).void
+    end
+    def self.chain_fused(enum, &blk)
+    end
+
+    SSEMessage = T.type_alias do
+      {event: T.nilable(String), data: T.nilable(String), id: T.nilable(String), retry: T.nilable(Integer)}
+    end
+
+    sig { params(enum: T::Enumerable[String]).returns(T::Enumerable[String]) }
+    def self.enum_lines(enum)
+    end
+
+    sig { params(lines: T::Enumerable[String]).returns(FinchAPI::Util::SSEMessage) }
+    def self.parse_sse(lines)
+    end
+  end
+end

data/rbi/lib/finch-api/version.rbi

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

data/sig/finch-api/base_client.rbs

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

data/sig/finch-api/base_model.rbs

@@ -0,0 +1,242 @@
+module FinchAPI
+  module Converter
+    type input = FinchAPI::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: ^-> FinchAPI::Converter::input?,
+        union: ^-> FinchAPI::Converter::input?
+      }
+      | ^-> FinchAPI::Converter::input
+      | FinchAPI::Converter::input spec
+    ) -> (^-> top)
+
+    def self.coerce: (FinchAPI::Converter::input target, top value) -> top
+
+    def self.dump: (FinchAPI::Converter::input target, top value) -> top
+
+    def self.try_strict_coerce: (
+      FinchAPI::Converter::input target,
+      top value
+    ) -> top
+  end
+
+  class Unknown
+    extend FinchAPI::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 FinchAPI::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
+
+  class Enum
+    extend FinchAPI::Converter
+
+    def self.values: -> ::Array[(nil | bool | Integer | Float | Symbol)]
+
+    private def self.finalize!: -> void
+
+    def self.===: (top other) -> bool
+
+    def self.==: (top other) -> bool
+
+    def self.coerce: (String | Symbol | top value) -> (Symbol | top)
+
+    def self.dump: (Symbol | top value) -> (Symbol | top)
+
+    def self.try_strict_coerce: (
+      top value
+    ) -> ([true, top, nil] | [false, bool, Integer])
+  end
+
+  class Union
+    extend FinchAPI::Converter
+
+    private def self.known_variants: -> ::Array[[Symbol?, Proc]]
+
+    def self.variants: -> ::Array[[Symbol?, top]]
+
+    private def self.discriminator: (Symbol property) -> void
+
+    private def self.variant: (
+      Symbol
+      | ::Hash[Symbol, top]
+      | ^-> FinchAPI::Converter::input
+      | FinchAPI::Converter::input key,
+      ?::Hash[Symbol, top]
+      | ^-> FinchAPI::Converter::input
+      | FinchAPI::Converter::input spec
+    ) -> void
+
+    private def self.resolve_variant: (top value) -> FinchAPI::Converter::input?
+
+    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 ArrayOf
+    include FinchAPI::Converter
+
+    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: -> FinchAPI::Converter::input
+
+    def initialize: (
+      ::Hash[Symbol, top]
+      | ^-> FinchAPI::Converter::input
+      | FinchAPI::Converter::input type_info,
+      ?::Hash[Symbol, top] spec
+    ) -> void
+  end
+
+  class HashOf
+    include FinchAPI::Converter
+
+    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: -> FinchAPI::Converter::input
+
+    def initialize: (
+      ::Hash[Symbol, top]
+      | ^-> FinchAPI::Converter::input
+      | FinchAPI::Converter::input type_info,
+      ?::Hash[Symbol, top] spec
+    ) -> void
+  end
+
+  class BaseModel
+    extend FinchAPI::Converter
+
+    type known_field = { mode: (:coerce | :dump)?, required: bool }
+
+    def self.known_fields: -> ::Hash[Symbol, (FinchAPI::BaseModel::known_field
+    & { type_fn: (^-> FinchAPI::Converter::input) })]
+
+    def self.fields: -> ::Hash[Symbol, (FinchAPI::BaseModel::known_field
+    & { type: FinchAPI::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: ^-> FinchAPI::Converter::input?,
+        union: ^-> FinchAPI::Converter::input?,
+        api_name: Symbol
+      }
+      | ^-> FinchAPI::Converter::input
+      | FinchAPI::Converter::input,
+      spec: ::Hash[Symbol, top]
+    ) -> void
+
+    def self.required: (
+      Symbol name_sym,
+      ::Hash[Symbol, top]
+      | ^-> FinchAPI::Converter::input
+      | FinchAPI::Converter::input type_info,
+      ?::Hash[Symbol, top] spec
+    ) -> void
+
+    def self.optional: (
+      Symbol name_sym,
+      ::Hash[Symbol, top]
+      | ^-> FinchAPI::Converter::input
+      | FinchAPI::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: (
+      FinchAPI::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/finch-api/base_page.rbs

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

data/sig/finch-api/client.rbs

@@ -0,0 +1,54 @@
+module FinchAPI
+  class Client < FinchAPI::BaseClient
+    DEFAULT_MAX_RETRIES: 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS: Float
+
+    DEFAULT_INITIAL_RETRY_DELAY: Float
+
+    DEFAULT_MAX_RETRY_DELAY: Float
+
+    attr_reader access_token: String?
+
+    attr_reader client_id: String?
+
+    attr_reader client_secret: String?
+
+    attr_reader access_tokens: FinchAPI::Resources::AccessTokens
+
+    attr_reader hris: FinchAPI::Resources::HRIS
+
+    attr_reader providers: FinchAPI::Resources::Providers
+
+    attr_reader account: FinchAPI::Resources::Account
+
+    attr_reader webhooks: FinchAPI::Resources::Webhooks
+
+    attr_reader request_forwarding: FinchAPI::Resources::RequestForwarding
+
+    attr_reader jobs: FinchAPI::Resources::Jobs
+
+    attr_reader sandbox: FinchAPI::Resources::Sandbox
+
+    attr_reader payroll: FinchAPI::Resources::Payroll
+
+    attr_reader connect: FinchAPI::Resources::Connect
+
+    private def auth_headers: -> ::Hash[String, String]
+
+    private def bearer_auth: -> ::Hash[String, String]
+
+    private def basic_auth: -> ::Hash[String, String]
+
+    def initialize: (
+      base_url: String?,
+      access_token: String?,
+      client_id: String?,
+      client_secret: String?,
+      max_retries: Integer,
+      timeout: Float,
+      initial_retry_delay: Float,
+      max_retry_delay: Float
+    ) -> void
+  end
+end

data/sig/finch-api/errors.rbs

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

data/sig/finch-api/extern.rbs

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

data/sig/finch-api/individuals_page.rbs

@@ -0,0 +1,16 @@
+module FinchAPI
+  class IndividualsPage[Elem]
+    include FinchAPI::BasePage[Elem]
+
+    attr_accessor individuals: ::Array[Elem]
+
+    attr_accessor paging: FinchAPI::Models::Paging
+
+    def initialize: (
+      client: FinchAPI::BaseClient,
+      req: FinchAPI::BaseClient::request_components,
+      headers: ::Hash[String, String],
+      unwrapped: ::Hash[Symbol, top]
+    ) -> void
+  end
+end