finch-api 0.1.0.pre.alpha.1 → 0.1.0.pre.alpha.2

data/rbi/lib/finch-api/models/location.rbi

@@ -3,69 +3,35 @@
 module FinchAPI
   module Models
     class Location < FinchAPI::BaseModel
+      # City, district, suburb, town, or village.
       sig { returns(T.nilable(String)) }
-      def city
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def city=(_)
-      end
+      attr_accessor :city
 
+      # The 2-letter ISO 3166 country code.
       sig { returns(T.nilable(String)) }
-      def country
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def country=(_)
-      end
+      attr_accessor :country
 
+      # Street address or PO box.
       sig { returns(T.nilable(String)) }
-      def line1
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def line1=(_)
-      end
+      attr_accessor :line1
 
+      # Apartment, suite, unit, or building.
       sig { returns(T.nilable(String)) }
-      def line2
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def line2=(_)
-      end
+      attr_accessor :line2
 
       sig { returns(T.nilable(String)) }
-      def name
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def name=(_)
-      end
+      attr_accessor :name
 
+      # The postal code or zip code.
       sig { returns(T.nilable(String)) }
-      def postal_code
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def postal_code=(_)
-      end
+      attr_accessor :postal_code
 
       sig { returns(T.nilable(String)) }
-      def source_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def source_id=(_)
-      end
+      attr_accessor :source_id
 
+      # The state code.
       sig { returns(T.nilable(String)) }
-      def state
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def state=(_)
-      end
+      attr_accessor :state
 
       sig do
         params(
@@ -78,18 +44,9 @@ module FinchAPI
           source_id: T.nilable(String),
           state: T.nilable(String)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
-        city: nil,
-        country: nil,
-        line1: nil,
-        line2: nil,
-        name: nil,
-        postal_code: nil,
-        source_id: nil,
-        state: nil
-      )
+      def self.new(city: nil, country: nil, line1: nil, line2: nil, name: nil, postal_code: nil, source_id: nil, state: nil)
       end
 
       sig do

data/rbi/lib/finch-api/models/money.rbi

@@ -3,24 +3,18 @@
 module FinchAPI
   module Models
     class Money < FinchAPI::BaseModel
+      # Amount for money object (in cents)
       sig { returns(T.nilable(Integer)) }
-      def amount
-      end
-
-      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-      def amount=(_)
-      end
+      attr_accessor :amount
 
       sig { returns(T.nilable(String)) }
-      def currency
-      end
+      attr_reader :currency
 
-      sig { params(_: String).returns(String) }
-      def currency=(_)
-      end
+      sig { params(currency: String).void }
+      attr_writer :currency
 
-      sig { params(amount: T.nilable(Integer), currency: String).void }
-      def initialize(amount: nil, currency: nil)
+      sig { params(amount: T.nilable(Integer), currency: String).returns(T.attached_class) }
+      def self.new(amount: nil, currency: nil)
       end
 
       sig { override.returns({amount: T.nilable(Integer), currency: String}) }

data/rbi/lib/finch-api/models/operation_support.rbi

@@ -2,15 +2,26 @@
 
 module FinchAPI
   module Models
-    class OperationSupport < FinchAPI::Enum
-      abstract!
+    # - `supported`: This operation is supported by both the provider and Finch
+    #   - `not_supported_by_finch`: This operation is not supported by Finch but
+    #     supported by the provider
+    #   - `not_supported_by_provider`: This operation is not supported by the provider,
+    #     so Finch cannot support
+    #   - `client_access_only`: This behavior is supported by the provider, but only
+    #     available to the client and not to Finch
+    module OperationSupport
+      extend FinchAPI::Enum
 
-      SUPPORTED = :supported
-      NOT_SUPPORTED_BY_FINCH = :not_supported_by_finch
-      NOT_SUPPORTED_BY_PROVIDER = :not_supported_by_provider
-      CLIENT_ACCESS_ONLY = :client_access_only
+      TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::OperationSupport) }
+      OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::OperationSupport::TaggedSymbol) }
 
-      sig { override.returns(T::Array[Symbol]) }
+      SUPPORTED = T.let(:supported, FinchAPI::Models::OperationSupport::TaggedSymbol)
+      NOT_SUPPORTED_BY_FINCH = T.let(:not_supported_by_finch, FinchAPI::Models::OperationSupport::TaggedSymbol)
+      NOT_SUPPORTED_BY_PROVIDER =
+        T.let(:not_supported_by_provider, FinchAPI::Models::OperationSupport::TaggedSymbol)
+      CLIENT_ACCESS_ONLY = T.let(:client_access_only, FinchAPI::Models::OperationSupport::TaggedSymbol)
+
+      sig { override.returns(T::Array[FinchAPI::Models::OperationSupport::TaggedSymbol]) }
       def self.values
       end
     end

data/rbi/lib/finch-api/models/operation_support_matrix.rbi

@@ -3,43 +3,81 @@
 module FinchAPI
   module Models
     class OperationSupportMatrix < FinchAPI::BaseModel
-      sig { returns(T.nilable(Symbol)) }
-      def create
-      end
+      # - `supported`: This operation is supported by both the provider and Finch
+      #   - `not_supported_by_finch`: This operation is not supported by Finch but
+      #     supported by the provider
+      #   - `not_supported_by_provider`: This operation is not supported by the provider,
+      #     so Finch cannot support
+      #   - `client_access_only`: This behavior is supported by the provider, but only
+      #     available to the client and not to Finch
+      sig { returns(T.nilable(FinchAPI::Models::OperationSupport::TaggedSymbol)) }
+      attr_reader :create
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def create=(_)
-      end
+      sig { params(create: FinchAPI::Models::OperationSupport::OrSymbol).void }
+      attr_writer :create
 
-      sig { returns(T.nilable(Symbol)) }
-      def delete
-      end
+      # - `supported`: This operation is supported by both the provider and Finch
+      #   - `not_supported_by_finch`: This operation is not supported by Finch but
+      #     supported by the provider
+      #   - `not_supported_by_provider`: This operation is not supported by the provider,
+      #     so Finch cannot support
+      #   - `client_access_only`: This behavior is supported by the provider, but only
+      #     available to the client and not to Finch
+      sig { returns(T.nilable(FinchAPI::Models::OperationSupport::TaggedSymbol)) }
+      attr_reader :delete
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def delete=(_)
-      end
+      sig { params(delete: FinchAPI::Models::OperationSupport::OrSymbol).void }
+      attr_writer :delete
 
-      sig { returns(T.nilable(Symbol)) }
-      def read
-      end
+      # - `supported`: This operation is supported by both the provider and Finch
+      #   - `not_supported_by_finch`: This operation is not supported by Finch but
+      #     supported by the provider
+      #   - `not_supported_by_provider`: This operation is not supported by the provider,
+      #     so Finch cannot support
+      #   - `client_access_only`: This behavior is supported by the provider, but only
+      #     available to the client and not to Finch
+      sig { returns(T.nilable(FinchAPI::Models::OperationSupport::TaggedSymbol)) }
+      attr_reader :read
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def read=(_)
-      end
+      sig { params(read: FinchAPI::Models::OperationSupport::OrSymbol).void }
+      attr_writer :read
 
-      sig { returns(T.nilable(Symbol)) }
-      def update
-      end
+      # - `supported`: This operation is supported by both the provider and Finch
+      #   - `not_supported_by_finch`: This operation is not supported by Finch but
+      #     supported by the provider
+      #   - `not_supported_by_provider`: This operation is not supported by the provider,
+      #     so Finch cannot support
+      #   - `client_access_only`: This behavior is supported by the provider, but only
+      #     available to the client and not to Finch
+      sig { returns(T.nilable(FinchAPI::Models::OperationSupport::TaggedSymbol)) }
+      attr_reader :update
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def update=(_)
-      end
+      sig { params(update: FinchAPI::Models::OperationSupport::OrSymbol).void }
+      attr_writer :update
 
-      sig { params(create: Symbol, delete: Symbol, read: Symbol, update: Symbol).void }
-      def initialize(create: nil, delete: nil, read: nil, update: nil)
+      sig do
+        params(
+          create: FinchAPI::Models::OperationSupport::OrSymbol,
+          delete: FinchAPI::Models::OperationSupport::OrSymbol,
+          read: FinchAPI::Models::OperationSupport::OrSymbol,
+          update: FinchAPI::Models::OperationSupport::OrSymbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(create: nil, delete: nil, read: nil, update: nil)
       end
 
-      sig { override.returns({create: Symbol, delete: Symbol, read: Symbol, update: Symbol}) }
+      sig do
+        override
+          .returns(
+            {
+              create: FinchAPI::Models::OperationSupport::TaggedSymbol,
+              delete: FinchAPI::Models::OperationSupport::TaggedSymbol,
+              read: FinchAPI::Models::OperationSupport::TaggedSymbol,
+              update: FinchAPI::Models::OperationSupport::TaggedSymbol
+            }
+          )
+      end
       def to_hash
       end
     end

data/rbi/lib/finch-api/models/paging.rbi

@@ -3,24 +3,22 @@
 module FinchAPI
   module Models
     class Paging < FinchAPI::BaseModel
+      # The total number of elements for the entire query (not just the given page)
       sig { returns(T.nilable(Integer)) }
-      def count
-      end
+      attr_reader :count
 
-      sig { params(_: Integer).returns(Integer) }
-      def count=(_)
-      end
+      sig { params(count: Integer).void }
+      attr_writer :count
 
+      # The current start index of the returned list of elements
       sig { returns(T.nilable(Integer)) }
-      def offset
-      end
+      attr_reader :offset
 
-      sig { params(_: Integer).returns(Integer) }
-      def offset=(_)
-      end
+      sig { params(offset: Integer).void }
+      attr_writer :offset
 
-      sig { params(count: Integer, offset: Integer).void }
-      def initialize(count: nil, offset: nil)
+      sig { params(count: Integer, offset: Integer).returns(T.attached_class) }
+      def self.new(count: nil, offset: nil)
       end
 
       sig { override.returns({count: Integer, offset: Integer}) }

data/rbi/lib/finch-api/models/pay_statement_event.rbi

@@ -4,48 +4,56 @@ module FinchAPI
   module Models
     class PayStatementEvent < FinchAPI::Models::BaseWebhookEvent
       sig { returns(T.nilable(FinchAPI::Models::PayStatementEvent::Data)) }
-      def data
-      end
+      attr_reader :data
 
-      sig { params(_: FinchAPI::Models::PayStatementEvent::Data).returns(FinchAPI::Models::PayStatementEvent::Data) }
-      def data=(_)
-      end
+      sig { params(data: T.any(FinchAPI::Models::PayStatementEvent::Data, FinchAPI::Util::AnyHash)).void }
+      attr_writer :data
 
-      sig { returns(T.nilable(Symbol)) }
-      def event_type
-      end
+      sig { returns(T.nilable(FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol)) }
+      attr_reader :event_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def event_type=(_)
-      end
+      sig { params(event_type: FinchAPI::Models::PayStatementEvent::EventType::OrSymbol).void }
+      attr_writer :event_type
 
-      sig { params(data: FinchAPI::Models::PayStatementEvent::Data, event_type: Symbol).void }
-      def initialize(data: nil, event_type: nil)
+      sig do
+        params(
+          data: T.any(FinchAPI::Models::PayStatementEvent::Data, FinchAPI::Util::AnyHash),
+          event_type: FinchAPI::Models::PayStatementEvent::EventType::OrSymbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(data: nil, event_type: nil)
       end
 
-      sig { override.returns({data: FinchAPI::Models::PayStatementEvent::Data, event_type: Symbol}) }
+      sig do
+        override
+          .returns(
+            {
+              data: FinchAPI::Models::PayStatementEvent::Data,
+              event_type: FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol
+            }
+          )
+      end
       def to_hash
       end
 
       class Data < FinchAPI::BaseModel
+        # The ID of the individual associated with the pay statement.
         sig { returns(T.nilable(String)) }
-        def individual_id
-        end
+        attr_reader :individual_id
 
-        sig { params(_: String).returns(String) }
-        def individual_id=(_)
-        end
+        sig { params(individual_id: String).void }
+        attr_writer :individual_id
 
+        # The ID of the payment associated with the pay statement.
         sig { returns(T.nilable(String)) }
-        def payment_id
-        end
+        attr_reader :payment_id
 
-        sig { params(_: String).returns(String) }
-        def payment_id=(_)
-        end
+        sig { params(payment_id: String).void }
+        attr_writer :payment_id
 
-        sig { params(individual_id: String, payment_id: String).void }
-        def initialize(individual_id: nil, payment_id: nil)
+        sig { params(individual_id: String, payment_id: String).returns(T.attached_class) }
+        def self.new(individual_id: nil, payment_id: nil)
         end
 
         sig { override.returns({individual_id: String, payment_id: String}) }
@@ -53,14 +61,20 @@ module FinchAPI
         end
       end
 
-      class EventType < FinchAPI::Enum
-        abstract!
+      module EventType
+        extend FinchAPI::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::PayStatementEvent::EventType) }
+        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol) }
 
-        PAY_STATEMENT_CREATED = :"pay_statement.created"
-        PAY_STATEMENT_UPDATED = :"pay_statement.updated"
-        PAY_STATEMENT_DELETED = :"pay_statement.deleted"
+        PAY_STATEMENT_CREATED =
+          T.let(:"pay_statement.created", FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol)
+        PAY_STATEMENT_UPDATED =
+          T.let(:"pay_statement.updated", FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol)
+        PAY_STATEMENT_DELETED =
+          T.let(:"pay_statement.deleted", FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[FinchAPI::Models::PayStatementEvent::EventType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/finch-api/models/payment_event.rbi

@@ -4,48 +4,50 @@ module FinchAPI
   module Models
     class PaymentEvent < FinchAPI::Models::BaseWebhookEvent
       sig { returns(T.nilable(FinchAPI::Models::PaymentEvent::Data)) }
-      def data
-      end
+      attr_reader :data
 
-      sig { params(_: FinchAPI::Models::PaymentEvent::Data).returns(FinchAPI::Models::PaymentEvent::Data) }
-      def data=(_)
-      end
+      sig { params(data: T.any(FinchAPI::Models::PaymentEvent::Data, FinchAPI::Util::AnyHash)).void }
+      attr_writer :data
 
-      sig { returns(T.nilable(Symbol)) }
-      def event_type
-      end
+      sig { returns(T.nilable(FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol)) }
+      attr_reader :event_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def event_type=(_)
-      end
+      sig { params(event_type: FinchAPI::Models::PaymentEvent::EventType::OrSymbol).void }
+      attr_writer :event_type
 
-      sig { params(data: FinchAPI::Models::PaymentEvent::Data, event_type: Symbol).void }
-      def initialize(data: nil, event_type: nil)
+      sig do
+        params(
+          data: T.any(FinchAPI::Models::PaymentEvent::Data, FinchAPI::Util::AnyHash),
+          event_type: FinchAPI::Models::PaymentEvent::EventType::OrSymbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(data: nil, event_type: nil)
       end
 
-      sig { override.returns({data: FinchAPI::Models::PaymentEvent::Data, event_type: Symbol}) }
+      sig do
+        override
+          .returns(
+            {
+              data: FinchAPI::Models::PaymentEvent::Data,
+              event_type: FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol
+            }
+          )
+      end
       def to_hash
       end
 
       class Data < FinchAPI::BaseModel
+        # The date of the payment.
         sig { returns(String) }
-        def pay_date
-        end
-
-        sig { params(_: String).returns(String) }
-        def pay_date=(_)
-        end
+        attr_accessor :pay_date
 
+        # The ID of the payment.
         sig { returns(String) }
-        def payment_id
-        end
+        attr_accessor :payment_id
 
-        sig { params(_: String).returns(String) }
-        def payment_id=(_)
-        end
-
-        sig { params(pay_date: String, payment_id: String).void }
-        def initialize(pay_date:, payment_id:)
+        sig { params(pay_date: String, payment_id: String).returns(T.attached_class) }
+        def self.new(pay_date:, payment_id:)
         end
 
         sig { override.returns({pay_date: String, payment_id: String}) }
@@ -53,14 +55,17 @@ module FinchAPI
         end
       end
 
-      class EventType < FinchAPI::Enum
-        abstract!
+      module EventType
+        extend FinchAPI::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, FinchAPI::Models::PaymentEvent::EventType) }
+        OrSymbol = T.type_alias { T.any(Symbol, FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol) }
 
-        PAYMENT_CREATED = :"payment.created"
-        PAYMENT_UPDATED = :"payment.updated"
-        PAYMENT_DELETED = :"payment.deleted"
+        PAYMENT_CREATED = T.let(:"payment.created", FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol)
+        PAYMENT_UPDATED = T.let(:"payment.updated", FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol)
+        PAYMENT_DELETED = T.let(:"payment.deleted", FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[FinchAPI::Models::PaymentEvent::EventType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/finch-api/models/payroll/pay_group_list_params.rbi

@@ -8,30 +8,26 @@ module FinchAPI
         include FinchAPI::RequestParameters
 
         sig { returns(T.nilable(String)) }
-        def individual_id
-        end
+        attr_reader :individual_id
 
-        sig { params(_: String).returns(String) }
-        def individual_id=(_)
-        end
+        sig { params(individual_id: String).void }
+        attr_writer :individual_id
 
         sig { returns(T.nilable(T::Array[String])) }
-        def pay_frequencies
-        end
+        attr_reader :pay_frequencies
 
-        sig { params(_: T::Array[String]).returns(T::Array[String]) }
-        def pay_frequencies=(_)
-        end
+        sig { params(pay_frequencies: T::Array[String]).void }
+        attr_writer :pay_frequencies
 
         sig do
           params(
             individual_id: String,
             pay_frequencies: T::Array[String],
-            request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+            request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(individual_id: nil, pay_frequencies: nil, request_options: {})
+        def self.new(individual_id: nil, pay_frequencies: nil, request_options: {})
         end
 
         sig do