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

data/rbi/lib/finch-api/models/sandbox/connection_create_response.rbi

@@ -5,83 +5,50 @@ module FinchAPI
     module Sandbox
       class ConnectionCreateResponse < FinchAPI::BaseModel
         sig { returns(String) }
-        def access_token
-        end
-
-        sig { params(_: String).returns(String) }
-        def access_token=(_)
-        end
+        attr_accessor :access_token
 
+        # [DEPRECATED] Use `connection_id` to associate a connection with an access token
         sig { returns(String) }
-        def account_id
-        end
+        attr_accessor :account_id
 
-        sig { params(_: String).returns(String) }
-        def account_id=(_)
-        end
-
-        sig { returns(Symbol) }
-        def authentication_type
-        end
-
-        sig { params(_: Symbol).returns(Symbol) }
-        def authentication_type=(_)
-        end
+        sig { returns(FinchAPI::Models::Sandbox::ConnectionCreateResponse::AuthenticationType::TaggedSymbol) }
+        attr_accessor :authentication_type
 
+        # [DEPRECATED] Use `connection_id` to associate a connection with an access token
         sig { returns(String) }
-        def company_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def company_id=(_)
-        end
+        attr_accessor :company_id
 
+        # The ID of the new connection
         sig { returns(String) }
-        def connection_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def connection_id=(_)
-        end
+        attr_accessor :connection_id
 
         sig { returns(T::Array[String]) }
-        def products
-        end
-
-        sig { params(_: T::Array[String]).returns(T::Array[String]) }
-        def products=(_)
-        end
+        attr_accessor :products
 
+        # The ID of the provider associated with the `access_token`.
         sig { returns(String) }
-        def provider_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def provider_id=(_)
-        end
+        attr_accessor :provider_id
 
         sig { returns(T.nilable(String)) }
-        def token_type
-        end
+        attr_reader :token_type
 
-        sig { params(_: String).returns(String) }
-        def token_type=(_)
-        end
+        sig { params(token_type: String).void }
+        attr_writer :token_type
 
         sig do
           params(
             access_token: String,
             account_id: String,
-            authentication_type: Symbol,
+            authentication_type: FinchAPI::Models::Sandbox::ConnectionCreateResponse::AuthenticationType::OrSymbol,
             company_id: String,
             connection_id: String,
             products: T::Array[String],
             provider_id: String,
             token_type: String
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           access_token:,
           account_id:,
           authentication_type:,
@@ -99,7 +66,7 @@ module FinchAPI
               {
                 access_token: String,
                 account_id: String,
-                authentication_type: Symbol,
+                authentication_type: FinchAPI::Models::Sandbox::ConnectionCreateResponse::AuthenticationType::TaggedSymbol,
                 company_id: String,
                 connection_id: String,
                 products: T::Array[String],
@@ -111,15 +78,27 @@ module FinchAPI
         def to_hash
         end
 
-        class AuthenticationType < FinchAPI::Enum
-          abstract!
+        module AuthenticationType
+          extend FinchAPI::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, FinchAPI::Models::Sandbox::ConnectionCreateResponse::AuthenticationType) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, FinchAPI::Models::Sandbox::ConnectionCreateResponse::AuthenticationType::TaggedSymbol) }
 
-          CREDENTIAL = :credential
-          API_TOKEN = :api_token
-          OAUTH = :oauth
-          ASSISTED = :assisted
+          CREDENTIAL =
+            T.let(:credential, FinchAPI::Models::Sandbox::ConnectionCreateResponse::AuthenticationType::TaggedSymbol)
+          API_TOKEN =
+            T.let(:api_token, FinchAPI::Models::Sandbox::ConnectionCreateResponse::AuthenticationType::TaggedSymbol)
+          OAUTH =
+            T.let(:oauth, FinchAPI::Models::Sandbox::ConnectionCreateResponse::AuthenticationType::TaggedSymbol)
+          ASSISTED =
+            T.let(:assisted, FinchAPI::Models::Sandbox::ConnectionCreateResponse::AuthenticationType::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig do
+            override
+              .returns(T::Array[FinchAPI::Models::Sandbox::ConnectionCreateResponse::AuthenticationType::TaggedSymbol])
+          end
           def self.values
           end
         end

data/rbi/lib/finch-api/models/sandbox/connections/account_create_params.rbi

@@ -9,54 +9,46 @@ module FinchAPI
           include FinchAPI::RequestParameters
 
           sig { returns(String) }
-          def company_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def company_id=(_)
-          end
+          attr_accessor :company_id
 
+          # The provider associated with the `access_token`
           sig { returns(String) }
-          def provider_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def provider_id=(_)
-          end
+          attr_accessor :provider_id
 
-          sig { returns(T.nilable(Symbol)) }
-          def authentication_type
+          sig do
+            returns(
+              T.nilable(FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType::OrSymbol)
+            )
           end
+          attr_reader :authentication_type
 
-          sig { params(_: Symbol).returns(Symbol) }
-          def authentication_type=(_)
+          sig do
+            params(
+              authentication_type: FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType::OrSymbol
+            )
+              .void
           end
+          attr_writer :authentication_type
 
+          # Optional, defaults to Organization products (`company`, `directory`,
+          #   `employment`, `individual`)
           sig { returns(T.nilable(T::Array[String])) }
-          def products
-          end
+          attr_reader :products
 
-          sig { params(_: T::Array[String]).returns(T::Array[String]) }
-          def products=(_)
-          end
+          sig { params(products: T::Array[String]).void }
+          attr_writer :products
 
           sig do
             params(
               company_id: String,
               provider_id: String,
-              authentication_type: Symbol,
+              authentication_type: FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType::OrSymbol,
               products: 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(
-            company_id:,
-            provider_id:,
-            authentication_type: nil,
-            products: nil,
-            request_options: {}
-          )
+          def self.new(company_id:, provider_id:, authentication_type: nil, products: nil, request_options: {})
           end
 
           sig do
@@ -65,7 +57,7 @@ module FinchAPI
                 {
                   company_id: String,
                   provider_id: String,
-                  authentication_type: Symbol,
+                  authentication_type: FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType::OrSymbol,
                   products: T::Array[String],
                   request_options: FinchAPI::RequestOptions
                 }
@@ -74,15 +66,46 @@ module FinchAPI
           def to_hash
           end
 
-          class AuthenticationType < FinchAPI::Enum
-            abstract!
+          module AuthenticationType
+            extend FinchAPI::Enum
+
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType) }
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType::TaggedSymbol
+                )
+              end
 
-            CREDENTIAL = :credential
-            API_TOKEN = :api_token
-            OAUTH = :oauth
-            ASSISTED = :assisted
+            CREDENTIAL =
+              T.let(
+                :credential,
+                FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType::TaggedSymbol
+              )
+            API_TOKEN =
+              T.let(
+                :api_token,
+                FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType::TaggedSymbol
+              )
+            OAUTH =
+              T.let(
+                :oauth,
+                FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType::TaggedSymbol
+              )
+            ASSISTED =
+              T.let(
+                :assisted,
+                FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType::TaggedSymbol
+              )
 
-            sig { override.returns(T::Array[Symbol]) }
+            sig do
+              override
+                .returns(
+                  T::Array[FinchAPI::Models::Sandbox::Connections::AccountCreateParams::AuthenticationType::TaggedSymbol]
+                )
+            end
             def self.values
             end
           end

data/rbi/lib/finch-api/models/sandbox/connections/account_create_response.rbi

@@ -6,82 +6,43 @@ module FinchAPI
       module Connections
         class AccountCreateResponse < FinchAPI::BaseModel
           sig { returns(String) }
-          def access_token
-          end
-
-          sig { params(_: String).returns(String) }
-          def access_token=(_)
-          end
+          attr_accessor :access_token
 
+          # [DEPRECATED] Use `connection_id` to associate a connection with an access token
           sig { returns(String) }
-          def account_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def account_id=(_)
-          end
-
-          sig { returns(Symbol) }
-          def authentication_type
-          end
+          attr_accessor :account_id
 
-          sig { params(_: Symbol).returns(Symbol) }
-          def authentication_type=(_)
-          end
+          sig { returns(FinchAPI::Models::Sandbox::Connections::AccountCreateResponse::AuthenticationType::TaggedSymbol) }
+          attr_accessor :authentication_type
 
+          # [DEPRECATED] Use `connection_id` to associate a connection with an access token
           sig { returns(String) }
-          def company_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def company_id=(_)
-          end
+          attr_accessor :company_id
 
+          # The ID of the new connection
           sig { returns(String) }
-          def connection_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def connection_id=(_)
-          end
+          attr_accessor :connection_id
 
           sig { returns(T::Array[String]) }
-          def products
-          end
-
-          sig { params(_: T::Array[String]).returns(T::Array[String]) }
-          def products=(_)
-          end
+          attr_accessor :products
 
+          # The ID of the provider associated with the `access_token`
           sig { returns(String) }
-          def provider_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def provider_id=(_)
-          end
+          attr_accessor :provider_id
 
           sig do
             params(
               access_token: String,
               account_id: String,
-              authentication_type: Symbol,
+              authentication_type: FinchAPI::Models::Sandbox::Connections::AccountCreateResponse::AuthenticationType::OrSymbol,
               company_id: String,
               connection_id: String,
               products: T::Array[String],
               provider_id: String
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(
-            access_token:,
-            account_id:,
-            authentication_type:,
-            company_id:,
-            connection_id:,
-            products:,
-            provider_id:
-          )
+          def self.new(access_token:, account_id:, authentication_type:, company_id:, connection_id:, products:, provider_id:)
           end
 
           sig do
@@ -90,7 +51,7 @@ module FinchAPI
                 {
                   access_token: String,
                   account_id: String,
-                  authentication_type: Symbol,
+                  authentication_type: FinchAPI::Models::Sandbox::Connections::AccountCreateResponse::AuthenticationType::TaggedSymbol,
                   company_id: String,
                   connection_id: String,
                   products: T::Array[String],
@@ -101,15 +62,46 @@ module FinchAPI
           def to_hash
           end
 
-          class AuthenticationType < FinchAPI::Enum
-            abstract!
+          module AuthenticationType
+            extend FinchAPI::Enum
 
-            CREDENTIAL = :credential
-            API_TOKEN = :api_token
-            OAUTH = :oauth
-            ASSISTED = :assisted
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, FinchAPI::Models::Sandbox::Connections::AccountCreateResponse::AuthenticationType) }
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  FinchAPI::Models::Sandbox::Connections::AccountCreateResponse::AuthenticationType::TaggedSymbol
+                )
+              end
 
-            sig { override.returns(T::Array[Symbol]) }
+            CREDENTIAL =
+              T.let(
+                :credential,
+                FinchAPI::Models::Sandbox::Connections::AccountCreateResponse::AuthenticationType::TaggedSymbol
+              )
+            API_TOKEN =
+              T.let(
+                :api_token,
+                FinchAPI::Models::Sandbox::Connections::AccountCreateResponse::AuthenticationType::TaggedSymbol
+              )
+            OAUTH =
+              T.let(
+                :oauth,
+                FinchAPI::Models::Sandbox::Connections::AccountCreateResponse::AuthenticationType::TaggedSymbol
+              )
+            ASSISTED =
+              T.let(
+                :assisted,
+                FinchAPI::Models::Sandbox::Connections::AccountCreateResponse::AuthenticationType::TaggedSymbol
+              )
+
+            sig do
+              override
+                .returns(
+                  T::Array[FinchAPI::Models::Sandbox::Connections::AccountCreateResponse::AuthenticationType::TaggedSymbol]
+                )
+            end
             def self.values
             end
           end

data/rbi/lib/finch-api/models/sandbox/connections/account_update_params.rbi

@@ -8,25 +8,31 @@ module FinchAPI
           extend FinchAPI::RequestParameters::Converter
           include FinchAPI::RequestParameters
 
-          sig { returns(T.nilable(Symbol)) }
-          def connection_status
-          end
+          sig { returns(T.nilable(FinchAPI::Models::ConnectionStatusType::OrSymbol)) }
+          attr_reader :connection_status
 
-          sig { params(_: Symbol).returns(Symbol) }
-          def connection_status=(_)
-          end
+          sig { params(connection_status: FinchAPI::Models::ConnectionStatusType::OrSymbol).void }
+          attr_writer :connection_status
 
           sig do
             params(
-              connection_status: Symbol,
-              request_options: T.any(FinchAPI::RequestOptions, T::Hash[Symbol, T.anything])
+              connection_status: FinchAPI::Models::ConnectionStatusType::OrSymbol,
+              request_options: T.any(FinchAPI::RequestOptions, FinchAPI::Util::AnyHash)
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(connection_status: nil, request_options: {})
+          def self.new(connection_status: nil, request_options: {})
           end
 
-          sig { override.returns({connection_status: Symbol, request_options: FinchAPI::RequestOptions}) }
+          sig do
+            override
+              .returns(
+                {
+                  connection_status: FinchAPI::Models::ConnectionStatusType::OrSymbol,
+                  request_options: FinchAPI::RequestOptions
+                }
+              )
+          end
           def to_hash
           end
         end

data/rbi/lib/finch-api/models/sandbox/connections/account_update_response.rbi

@@ -5,73 +5,43 @@ module FinchAPI
     module Sandbox
       module Connections
         class AccountUpdateResponse < FinchAPI::BaseModel
+          # [DEPRECATED] Use `connection_id` to associate a connection with an access token
           sig { returns(String) }
-          def account_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def account_id=(_)
-          end
+          attr_accessor :account_id
 
-          sig { returns(Symbol) }
-          def authentication_type
-          end
-
-          sig { params(_: Symbol).returns(Symbol) }
-          def authentication_type=(_)
-          end
+          sig { returns(FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse::AuthenticationType::TaggedSymbol) }
+          attr_accessor :authentication_type
 
+          # [DEPRECATED] Use `connection_id` to associate a connection with an access token
           sig { returns(String) }
-          def company_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def company_id=(_)
-          end
+          attr_accessor :company_id
 
           sig { returns(T::Array[String]) }
-          def products
-          end
-
-          sig { params(_: T::Array[String]).returns(T::Array[String]) }
-          def products=(_)
-          end
+          attr_accessor :products
 
+          # The ID of the provider associated with the `access_token`
           sig { returns(String) }
-          def provider_id
-          end
-
-          sig { params(_: String).returns(String) }
-          def provider_id=(_)
-          end
+          attr_accessor :provider_id
 
+          # The ID of the new connection
           sig { returns(T.nilable(String)) }
-          def connection_id
-          end
+          attr_reader :connection_id
 
-          sig { params(_: String).returns(String) }
-          def connection_id=(_)
-          end
+          sig { params(connection_id: String).void }
+          attr_writer :connection_id
 
           sig do
             params(
               account_id: String,
-              authentication_type: Symbol,
+              authentication_type: FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse::AuthenticationType::OrSymbol,
               company_id: String,
               products: T::Array[String],
               provider_id: String,
               connection_id: String
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(
-            account_id:,
-            authentication_type:,
-            company_id:,
-            products:,
-            provider_id:,
-            connection_id: nil
-          )
+          def self.new(account_id:, authentication_type:, company_id:, products:, provider_id:, connection_id: nil)
           end
 
           sig do
@@ -79,7 +49,7 @@ module FinchAPI
               .returns(
                 {
                   account_id: String,
-                  authentication_type: Symbol,
+                  authentication_type: FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse::AuthenticationType::TaggedSymbol,
                   company_id: String,
                   products: T::Array[String],
                   provider_id: String,
@@ -90,15 +60,46 @@ module FinchAPI
           def to_hash
           end
 
-          class AuthenticationType < FinchAPI::Enum
-            abstract!
+          module AuthenticationType
+            extend FinchAPI::Enum
 
-            CREDENTIAL = :credential
-            API_TOKEN = :api_token
-            OAUTH = :oauth
-            ASSISTED = :assisted
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse::AuthenticationType) }
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse::AuthenticationType::TaggedSymbol
+                )
+              end
 
-            sig { override.returns(T::Array[Symbol]) }
+            CREDENTIAL =
+              T.let(
+                :credential,
+                FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse::AuthenticationType::TaggedSymbol
+              )
+            API_TOKEN =
+              T.let(
+                :api_token,
+                FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse::AuthenticationType::TaggedSymbol
+              )
+            OAUTH =
+              T.let(
+                :oauth,
+                FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse::AuthenticationType::TaggedSymbol
+              )
+            ASSISTED =
+              T.let(
+                :assisted,
+                FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse::AuthenticationType::TaggedSymbol
+              )
+
+            sig do
+              override
+                .returns(
+                  T::Array[FinchAPI::Models::Sandbox::Connections::AccountUpdateResponse::AuthenticationType::TaggedSymbol]
+                )
+            end
             def self.values
             end
           end