finch-api 0.1.0.pre.alpha.1

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

@@ -0,0 +1,476 @@
+# typed: strong
+
+module FinchAPI
+  module Converter
+    abstract!
+
+    Input = T.type_alias { T.any(FinchAPI::Converter, T::Class[T.anything]) }
+
+    sig { overridable.params(value: T.anything).returns(T.anything) }
+    def coerce(value)
+    end
+
+    sig { overridable.params(value: T.anything).returns(T.anything) }
+    def dump(value)
+    end
+
+    sig do
+      overridable
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def try_strict_coerce(value)
+    end
+
+    sig do
+      params(
+        spec: T.any(
+          {
+            const: T.nilable(T.any(NilClass, T::Boolean, Integer, Float, Symbol)),
+            enum: T.nilable(T.proc.returns(FinchAPI::Converter::Input)),
+            union: T.nilable(T.proc.returns(FinchAPI::Converter::Input))
+          },
+          T.proc.returns(FinchAPI::Converter::Input),
+          FinchAPI::Converter::Input
+        )
+      )
+        .returns(T.proc.returns(T.anything).void)
+    end
+    def self.type_info(spec)
+    end
+
+    sig { params(target: FinchAPI::Converter::Input, value: T.anything).returns(T.anything) }
+    def self.coerce(target, value)
+    end
+
+    sig { params(target: FinchAPI::Converter::Input, value: T.anything).returns(T.anything) }
+    def self.dump(target, value)
+    end
+
+    sig { params(target: FinchAPI::Converter::Input, value: T.anything).returns(T.anything) }
+    def self.try_strict_coerce(target, value)
+    end
+  end
+
+  class Unknown
+    abstract!
+
+    extend FinchAPI::Converter
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.==(other)
+    end
+
+    sig { override.params(value: T.anything).returns(T.anything) }
+    def self.coerce(value)
+    end
+
+    sig { override.params(value: T.anything).returns(T.anything) }
+    def self.dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def self.try_strict_coerce(value)
+    end
+  end
+
+  class BooleanModel
+    abstract!
+
+    extend FinchAPI::Converter
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.==(other)
+    end
+
+    sig { override.params(value: T.any(T::Boolean, T.anything)).returns(T.any(T::Boolean, T.anything)) }
+    def self.coerce(value)
+    end
+
+    sig { override.params(value: T.any(T::Boolean, T.anything)).returns(T.any(T::Boolean, T.anything)) }
+    def self.dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def self.try_strict_coerce(value)
+    end
+  end
+
+  class Enum
+    abstract!
+
+    extend FinchAPI::Converter
+
+    sig { overridable.returns(T::Array[T.any(NilClass, T::Boolean, Integer, Float, Symbol)]) }
+    def self.values
+    end
+
+    sig { void }
+    private_class_method def self.finalize!
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.==(other)
+    end
+
+    sig { override.params(value: T.any(String, Symbol, T.anything)).returns(T.any(Symbol, T.anything)) }
+    def self.coerce(value)
+    end
+
+    sig { override.params(value: T.any(Symbol, T.anything)).returns(T.any(Symbol, T.anything)) }
+    def self.dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def self.try_strict_coerce(value)
+    end
+  end
+
+  class Union
+    abstract!
+
+    extend FinchAPI::Converter
+
+    sig { returns(T::Array[[T.nilable(Symbol), Proc]]) }
+    private_class_method def self.known_variants
+    end
+
+    sig { overridable.returns(T::Array[[T.nilable(Symbol), T.anything]]) }
+    private_class_method def self.variants
+    end
+
+    sig { params(property: Symbol).void }
+    private_class_method def self.discriminator(property)
+    end
+
+    sig do
+      params(
+        key: T.any(
+          Symbol,
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(FinchAPI::Converter::Input),
+          FinchAPI::Converter::Input
+        ),
+        spec: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(FinchAPI::Converter::Input),
+          FinchAPI::Converter::Input
+        )
+      )
+        .void
+    end
+    private_class_method def self.variant(key, spec = nil)
+    end
+
+    sig { params(value: T.anything).returns(T.nilable(FinchAPI::Converter::Input)) }
+    private_class_method def self.resolve_variant(value)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.==(other)
+    end
+
+    sig { override.params(value: T.anything).returns(T.anything) }
+    def self.coerce(value)
+    end
+
+    sig { override.params(value: T.anything).returns(T.anything) }
+    def self.dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def self.try_strict_coerce(value)
+    end
+  end
+
+  class ArrayOf
+    abstract!
+
+    include FinchAPI::Converter
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ==(other)
+    end
+
+    sig do
+      override
+        .params(value: T.any(T::Enumerable[T.anything], T.anything))
+        .returns(T.any(T::Array[T.anything], T.anything))
+    end
+    def coerce(value)
+    end
+
+    sig do
+      override
+        .params(value: T.any(T::Enumerable[T.anything], T.anything))
+        .returns(T.any(T::Array[T.anything], T.anything))
+    end
+    def dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def try_strict_coerce(value)
+    end
+
+    sig { returns(FinchAPI::Converter::Input) }
+    protected def item_type
+    end
+
+    sig do
+      params(
+        type_info: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(FinchAPI::Converter::Input),
+          FinchAPI::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      )
+        .void
+    end
+    def initialize(type_info, spec = {})
+    end
+  end
+
+  class HashOf
+    abstract!
+
+    include FinchAPI::Converter
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ==(other)
+    end
+
+    sig do
+      override
+        .params(value: T.any(T::Hash[T.anything, T.anything], T.anything))
+        .returns(T.any(T::Hash[Symbol, T.anything], T.anything))
+    end
+    def coerce(value)
+    end
+
+    sig do
+      override
+        .params(value: T.any(T::Hash[T.anything, T.anything], T.anything))
+        .returns(T.any(T::Hash[Symbol, T.anything], T.anything))
+    end
+    def dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def try_strict_coerce(value)
+    end
+
+    sig { returns(FinchAPI::Converter::Input) }
+    protected def item_type
+    end
+
+    sig do
+      params(
+        type_info: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(FinchAPI::Converter::Input),
+          FinchAPI::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      )
+        .void
+    end
+    def initialize(type_info, spec = {})
+    end
+  end
+
+  class BaseModel
+    abstract!
+
+    extend FinchAPI::Converter
+
+    KnownFieldShape = T.type_alias { {mode: T.nilable(Symbol), required: T::Boolean} }
+
+    sig do
+      returns(
+        T::Hash[Symbol,
+                T.all(
+                  FinchAPI::BaseModel::KnownFieldShape,
+                  {type_fn: T.proc.returns(FinchAPI::Converter::Input)}
+                )]
+      )
+    end
+    def self.known_fields
+    end
+
+    sig do
+      returns(
+        T::Hash[Symbol,
+                T.all(FinchAPI::BaseModel::KnownFieldShape, {type: FinchAPI::Converter::Input})]
+      )
+    end
+    def self.fields
+    end
+
+    sig { returns(T::Hash[Symbol, T.proc.returns(T::Class[T.anything])]) }
+    def self.defaults
+    end
+
+    sig do
+      params(
+        name_sym: Symbol,
+        required: T::Boolean,
+        type_info: T.any(
+          {
+            const: T.nilable(T.any(NilClass, T::Boolean, Integer, Float, Symbol)),
+            enum: T.nilable(T.proc.returns(FinchAPI::Converter::Input)),
+            union: T.nilable(T.proc.returns(FinchAPI::Converter::Input)),
+            api_name: Symbol,
+            nil?: T::Boolean
+          },
+          T.proc.returns(FinchAPI::Converter::Input),
+          FinchAPI::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      )
+        .void
+    end
+    private_class_method def self.add_field(name_sym, required:, type_info:, spec:)
+    end
+
+    sig do
+      params(
+        name_sym: Symbol,
+        type_info: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(FinchAPI::Converter::Input),
+          FinchAPI::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      )
+        .void
+    end
+    def self.required(name_sym, type_info, spec = {})
+    end
+
+    sig do
+      params(
+        name_sym: Symbol,
+        type_info: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(FinchAPI::Converter::Input),
+          FinchAPI::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      )
+        .void
+    end
+    def self.optional(name_sym, type_info, spec = {})
+    end
+
+    sig { params(blk: T.proc.void).void }
+    private_class_method def self.request_only(&blk)
+    end
+
+    sig { params(blk: T.proc.void).void }
+    private_class_method def self.response_only(&blk)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ==(other)
+    end
+
+    sig do
+      override
+        .params(value: T.any(FinchAPI::BaseModel, T::Hash[T.anything, T.anything], T.anything))
+        .returns(T.any(T.attached_class, T.anything))
+    end
+    def self.coerce(value)
+    end
+
+    sig do
+      override
+        .params(value: T.any(T.attached_class, T.anything))
+        .returns(T.any(T::Hash[T.anything, T.anything], T.anything))
+    end
+    def self.dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def self.try_strict_coerce(value)
+    end
+
+    sig { params(key: Symbol).returns(T.nilable(T.anything)) }
+    def [](key)
+    end
+
+    sig { overridable.returns(T::Hash[Symbol, T.anything]) }
+    def to_h
+    end
+
+    alias_method :to_hash, :to_h
+
+    sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.anything]) }
+    def deconstruct_keys(keys)
+    end
+
+    sig { params(data: T.any(T::Hash[Symbol, T.anything], T.self_type)).void }
+    def initialize(data = {})
+    end
+
+    sig { returns(String) }
+    def to_s
+    end
+
+    sig { returns(String) }
+    def inspect
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# typed: strong
+
+module FinchAPI
+  module BasePage
+    abstract!
+
+    Elem = type_member(:out)
+
+    sig { overridable.returns(T::Boolean) }
+    def next_page?
+    end
+
+    sig { overridable.returns(T.self_type) }
+    def next_page
+    end
+
+    sig { overridable.params(blk: T.proc.params(arg0: Elem).void).void }
+    def auto_paging_each(&blk)
+    end
+
+    sig { returns(T::Enumerable[Elem]) }
+    def to_enum
+    end
+
+    alias_method :enum_for, :to_enum
+
+    sig do
+      params(
+        client: FinchAPI::BaseClient,
+        req: FinchAPI::BaseClient::RequestComponentsShape,
+        headers: T.any(T::Hash[String, String], Net::HTTPHeader),
+        unwrapped: T.anything
+      )
+        .void
+    end
+    def initialize(client:, req:, headers:, unwrapped:)
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# typed: strong
+
+module FinchAPI
+  class Client < FinchAPI::BaseClient
+    DEFAULT_MAX_RETRIES = 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS = T.let(60.0, Float)
+
+    DEFAULT_INITIAL_RETRY_DELAY = T.let(0.5, Float)
+
+    DEFAULT_MAX_RETRY_DELAY = T.let(8.0, Float)
+
+    sig { returns(T.nilable(String)) }
+    def access_token
+    end
+
+    sig { returns(T.nilable(String)) }
+    def client_id
+    end
+
+    sig { returns(T.nilable(String)) }
+    def client_secret
+    end
+
+    sig { returns(FinchAPI::Resources::AccessTokens) }
+    def access_tokens
+    end
+
+    sig { returns(FinchAPI::Resources::HRIS) }
+    def hris
+    end
+
+    sig { returns(FinchAPI::Resources::Providers) }
+    def providers
+    end
+
+    sig { returns(FinchAPI::Resources::Account) }
+    def account
+    end
+
+    sig { returns(FinchAPI::Resources::Webhooks) }
+    def webhooks
+    end
+
+    sig { returns(FinchAPI::Resources::RequestForwarding) }
+    def request_forwarding
+    end
+
+    sig { returns(FinchAPI::Resources::Jobs) }
+    def jobs
+    end
+
+    sig { returns(FinchAPI::Resources::Sandbox) }
+    def sandbox
+    end
+
+    sig { returns(FinchAPI::Resources::Payroll) }
+    def payroll
+    end
+
+    sig { returns(FinchAPI::Resources::Connect) }
+    def connect
+    end
+
+    sig { override.returns(T::Hash[String, String]) }
+    private def auth_headers
+    end
+
+    sig { returns(T::Hash[String, String]) }
+    private def bearer_auth
+    end
+
+    sig { returns(T::Hash[String, String]) }
+    private def basic_auth
+    end
+
+    sig do
+      params(
+        base_url: T.nilable(String),
+        access_token: T.nilable(String),
+        client_id: T.nilable(String),
+        client_secret: T.nilable(String),
+        max_retries: Integer,
+        timeout: Float,
+        initial_retry_delay: Float,
+        max_retry_delay: Float
+      )
+        .void
+    end
+    def initialize(
+      base_url: nil,
+      access_token: nil,
+      client_id: ENV["FINCH_CLIENT_ID"],
+      client_secret: ENV["FINCH_CLIENT_SECRET"],
+      max_retries: DEFAULT_MAX_RETRIES,
+      timeout: DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: DEFAULT_MAX_RETRY_DELAY
+    )
+    end
+  end
+end