straddle 0.4.0 → 1.0.0

data/rbi/straddle/models/paykey_reveal_params.rbi

@@ -14,18 +14,21 @@ module Straddle
       sig { returns(String) }
       attr_accessor :id
 
+      # Optional client-generated identifier for tracing a series of related requests.
       sig { returns(T.nilable(String)) }
       attr_reader :correlation_id
 
       sig { params(correlation_id: String).void }
       attr_writer :correlation_id
 
+      # Optional client-generated identifier for tracing one request.
       sig { returns(T.nilable(String)) }
       attr_reader :request_id
 
       sig { params(request_id: String).void }
       attr_writer :request_id
 
+      # For platform requests, the embedded account UUID that sets the request scope.
       sig { returns(T.nilable(String)) }
       attr_reader :straddle_account_id
 
@@ -43,8 +46,11 @@ module Straddle
       end
       def self.new(
         id:,
+        # Optional client-generated identifier for tracing a series of related requests.
         correlation_id: nil,
+        # Optional client-generated identifier for tracing one request.
         request_id: nil,
+        # For platform requests, the embedded account UUID that sets the request scope.
         straddle_account_id: nil,
         request_options: {}
       )

data/rbi/straddle/models/paykey_source.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Straddle
+  module Models
+    module PaykeySource
+      extend Straddle::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Straddle::PaykeySource) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      BANK_ACCOUNT = T.let(:bank_account, Straddle::PaykeySource::TaggedSymbol)
+      STRADDLE = T.let(:straddle, Straddle::PaykeySource::TaggedSymbol)
+      MX = T.let(:mx, Straddle::PaykeySource::TaggedSymbol)
+      PLAID = T.let(:plaid, Straddle::PaykeySource::TaggedSymbol)
+      TAN = T.let(:tan, Straddle::PaykeySource::TaggedSymbol)
+      QUILTT = T.let(:quiltt, Straddle::PaykeySource::TaggedSymbol)
+
+      sig { override.returns(T::Array[Straddle::PaykeySource::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/straddle/models/paykey_status.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Straddle
+  module Models
+    module PaykeyStatus
+      extend Straddle::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Straddle::PaykeyStatus) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      PENDING = T.let(:pending, Straddle::PaykeyStatus::TaggedSymbol)
+      ACTIVE = T.let(:active, Straddle::PaykeyStatus::TaggedSymbol)
+      INACTIVE = T.let(:inactive, Straddle::PaykeyStatus::TaggedSymbol)
+      REJECTED = T.let(:rejected, Straddle::PaykeyStatus::TaggedSymbol)
+      REVIEW = T.let(:review, Straddle::PaykeyStatus::TaggedSymbol)
+      BLOCKED = T.let(:blocked, Straddle::PaykeyStatus::TaggedSymbol)
+
+      sig { override.returns(T::Array[Straddle::PaykeyStatus::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/straddle/models/paykey_summary.rbi

@@ -0,0 +1,154 @@
+# typed: strong
+
+module Straddle
+  module Models
+    class PaykeySummary < Straddle::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Straddle::PaykeySummary, Straddle::Internal::AnyHash)
+        end
+
+      # Unique identifier for the paykey.
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(Straddle::PaykeyConfiguration) }
+      attr_reader :config
+
+      sig { params(config: Straddle::PaykeyConfiguration::OrHash).void }
+      attr_writer :config
+
+      # Timestamp of when the paykey was created.
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # Display label combining the bank name and masked account number.
+      sig { returns(String) }
+      attr_accessor :label
+
+      # Masked paykey value.
+      sig { returns(String) }
+      attr_accessor :paykey
+
+      sig { returns(Straddle::PaykeySource::TaggedSymbol) }
+      attr_accessor :source
+
+      sig { returns(Straddle::PaykeyStatus::TaggedSymbol) }
+      attr_accessor :status
+
+      # Timestamp of the most recent update to the paykey.
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      sig { returns(T.nilable(Straddle::PaykeyBankDetails)) }
+      attr_reader :bank_data
+
+      sig { params(bank_data: Straddle::PaykeyBankDetails::OrHash).void }
+      attr_writer :bank_data
+
+      # Unique identifier for the customer associated with the paykey.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :customer_id
+
+      # Expiration date and time of the paykey, if applicable.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :expires_at
+
+      # Unique identifier for the paykey in your system.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :external_id
+
+      # Name of the financial institution.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :institution_name
+
+      sig { returns(T.nilable(Straddle::PaymentStatusDetails)) }
+      attr_reader :status_details
+
+      sig do
+        params(status_details: Straddle::PaymentStatusDetails::OrHash).void
+      end
+      attr_writer :status_details
+
+      # Whether the paykey is eligible for client-initiated unblocking. `true` only when
+      # the paykey is blocked by an `R29` return and has not been unblocked before.
+      # `false` for other blocked paykeys. `null` when the paykey is not blocked.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :unblock_eligible
+
+      sig do
+        params(
+          id: String,
+          config: Straddle::PaykeyConfiguration::OrHash,
+          created_at: Time,
+          label: String,
+          paykey: String,
+          source: Straddle::PaykeySource::OrSymbol,
+          status: Straddle::PaykeyStatus::OrSymbol,
+          updated_at: Time,
+          bank_data: Straddle::PaykeyBankDetails::OrHash,
+          customer_id: T.nilable(String),
+          expires_at: T.nilable(Time),
+          external_id: T.nilable(String),
+          institution_name: T.nilable(String),
+          status_details: Straddle::PaymentStatusDetails::OrHash,
+          unblock_eligible: T.nilable(T::Boolean)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the paykey.
+        id:,
+        config:,
+        # Timestamp of when the paykey was created.
+        created_at:,
+        # Display label combining the bank name and masked account number.
+        label:,
+        # Masked paykey value.
+        paykey:,
+        source:,
+        status:,
+        # Timestamp of the most recent update to the paykey.
+        updated_at:,
+        bank_data: nil,
+        # Unique identifier for the customer associated with the paykey.
+        customer_id: nil,
+        # Expiration date and time of the paykey, if applicable.
+        expires_at: nil,
+        # Unique identifier for the paykey in your system.
+        external_id: nil,
+        # Name of the financial institution.
+        institution_name: nil,
+        status_details: nil,
+        # Whether the paykey is eligible for client-initiated unblocking. `true` only when
+        # the paykey is blocked by an `R29` return and has not been unblocked before.
+        # `false` for other blocked paykeys. `null` when the paykey is not blocked.
+        unblock_eligible: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            config: Straddle::PaykeyConfiguration,
+            created_at: Time,
+            label: String,
+            paykey: String,
+            source: Straddle::PaykeySource::TaggedSymbol,
+            status: Straddle::PaykeyStatus::TaggedSymbol,
+            updated_at: Time,
+            bank_data: Straddle::PaykeyBankDetails,
+            customer_id: T.nilable(String),
+            expires_at: T.nilable(Time),
+            external_id: T.nilable(String),
+            institution_name: T.nilable(String),
+            status_details: Straddle::PaymentStatusDetails,
+            unblock_eligible: T.nilable(T::Boolean)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/straddle/models/paykey_summary_list.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Straddle
+  module Models
+    class PaykeySummaryList < Straddle::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Straddle::PaykeySummaryList, Straddle::Internal::AnyHash)
+        end
+
+      # The `data` field contains the paykeys on this page.
+      sig { returns(T::Array[Straddle::PaykeySummary]) }
+      attr_accessor :data
+
+      # Metadata for an API request and a page of results.
+      sig { returns(Straddle::PageMetadata) }
+      attr_reader :meta
+
+      sig { params(meta: Straddle::PageMetadata::OrHash).void }
+      attr_writer :meta
+
+      # Shape of the response envelope.
+      #
+      # - `object` means `data` contains one JSON object.
+      # - `array` means `data` contains an array of JSON objects.
+      # - `error` means `error` contains the error details.
+      # - `none` means the response contains no data.
+      sig { returns(Straddle::ResponseType::TaggedSymbol) }
+      attr_accessor :response_type
+
+      sig do
+        params(
+          data: T::Array[Straddle::PaykeySummary::OrHash],
+          meta: Straddle::PageMetadata::OrHash,
+          response_type: Straddle::ResponseType::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The `data` field contains the paykeys on this page.
+        data:,
+        # Metadata for an API request and a page of results.
+        meta:,
+        # Shape of the response envelope.
+        #
+        # - `object` means `data` contains one JSON object.
+        # - `array` means `data` contains an array of JSON objects.
+        # - `error` means `error` contains the error details.
+        # - `none` means the response contains no data.
+        response_type:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T::Array[Straddle::PaykeySummary],
+            meta: Straddle::PageMetadata,
+            response_type: Straddle::ResponseType::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/straddle/models/paykey_unblock_params.rbi

@@ -0,0 +1,93 @@
+# typed: strong
+
+module Straddle
+  module Models
+    class PaykeyUnblockParams < Straddle::Internal::Type::BaseModel
+      extend Straddle::Internal::Type::RequestParameters::Converter
+      include Straddle::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Straddle::PaykeyUnblockParams, Straddle::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Optional message describing the reason for unblocking.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :message
+
+      # Optional client-generated identifier for tracing a series of related requests.
+      sig { returns(T.nilable(String)) }
+      attr_reader :correlation_id
+
+      sig { params(correlation_id: String).void }
+      attr_writer :correlation_id
+
+      # Optional client-generated key for an idempotent request.
+      sig { returns(T.nilable(String)) }
+      attr_reader :idempotency_key
+
+      sig { params(idempotency_key: String).void }
+      attr_writer :idempotency_key
+
+      # Optional client-generated identifier for tracing one request.
+      sig { returns(T.nilable(String)) }
+      attr_reader :request_id
+
+      sig { params(request_id: String).void }
+      attr_writer :request_id
+
+      # For platform requests, the embedded account UUID that sets the request scope.
+      sig { returns(T.nilable(String)) }
+      attr_reader :straddle_account_id
+
+      sig { params(straddle_account_id: String).void }
+      attr_writer :straddle_account_id
+
+      sig do
+        params(
+          id: String,
+          message: T.nilable(String),
+          correlation_id: String,
+          idempotency_key: String,
+          request_id: String,
+          straddle_account_id: String,
+          request_options: Straddle::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        # Optional message describing the reason for unblocking.
+        message: nil,
+        # Optional client-generated identifier for tracing a series of related requests.
+        correlation_id: nil,
+        # Optional client-generated key for an idempotent request.
+        idempotency_key: nil,
+        # Optional client-generated identifier for tracing one request.
+        request_id: nil,
+        # For platform requests, the embedded account UUID that sets the request scope.
+        straddle_account_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            message: T.nilable(String),
+            correlation_id: String,
+            idempotency_key: String,
+            request_id: String,
+            straddle_account_id: String,
+            request_options: Straddle::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/straddle/models/paykeys/account_name_match_details.rbi

@@ -0,0 +1,91 @@
+# typed: strong
+
+module Straddle
+  module Models
+    module Paykeys
+      class AccountNameMatchDetails < Straddle::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Straddle::Paykeys::AccountNameMatchDetails,
+              Straddle::Internal::AnyHash
+            )
+          end
+
+        # Result codes returned by the name-match check.
+        sig { returns(T::Array[String]) }
+        attr_accessor :codes
+
+        sig do
+          returns(Straddle::Paykeys::PaykeyVerificationResult::TaggedSymbol)
+        end
+        attr_accessor :decision
+
+        # Strength of the match between the customer name and account-holder names.
+        sig { returns(T.nilable(Float)) }
+        attr_accessor :correlation_score
+
+        # Customer name evaluated during account verification.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :customer_name
+
+        # Account-holder name that matched the customer record.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :matched_name
+
+        # Account-holder names returned by the financial institution.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :names_on_account
+
+        # Reason for the name-match decision.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason
+
+        sig do
+          params(
+            codes: T::Array[String],
+            decision: Straddle::Paykeys::PaykeyVerificationResult::OrSymbol,
+            correlation_score: T.nilable(Float),
+            customer_name: T.nilable(String),
+            matched_name: T.nilable(String),
+            names_on_account: T.nilable(T::Array[String]),
+            reason: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Result codes returned by the name-match check.
+          codes:,
+          decision:,
+          # Strength of the match between the customer name and account-holder names.
+          correlation_score: nil,
+          # Customer name evaluated during account verification.
+          customer_name: nil,
+          # Account-holder name that matched the customer record.
+          matched_name: nil,
+          # Account-holder names returned by the financial institution.
+          names_on_account: nil,
+          # Reason for the name-match decision.
+          reason: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              codes: T::Array[String],
+              decision:
+                Straddle::Paykeys::PaykeyVerificationResult::TaggedSymbol,
+              correlation_score: T.nilable(Float),
+              customer_name: T.nilable(String),
+              matched_name: T.nilable(String),
+              names_on_account: T.nilable(T::Array[String]),
+              reason: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/straddle/models/paykeys/account_validation_details.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Straddle
+  module Models
+    module Paykeys
+      class AccountValidationDetails < Straddle::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Straddle::Paykeys::AccountValidationDetails,
+              Straddle::Internal::AnyHash
+            )
+          end
+
+        # Result codes returned by the account-validation check.
+        sig { returns(T::Array[String]) }
+        attr_accessor :codes
+
+        sig do
+          returns(Straddle::Paykeys::PaykeyVerificationResult::TaggedSymbol)
+        end
+        attr_accessor :decision
+
+        # Reason for the account-validation decision.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason
+
+        sig do
+          params(
+            codes: T::Array[String],
+            decision: Straddle::Paykeys::PaykeyVerificationResult::OrSymbol,
+            reason: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Result codes returned by the account-validation check.
+          codes:,
+          decision:,
+          # Reason for the account-validation decision.
+          reason: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              codes: T::Array[String],
+              decision:
+                Straddle::Paykeys::PaykeyVerificationResult::TaggedSymbol,
+              reason: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/straddle/models/paykeys/paykey_review.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module Straddle
+  module Models
+    PaykeyReview = Paykeys::PaykeyReview
+
+    module Paykeys
+      class PaykeyReview < Straddle::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Straddle::Paykeys::PaykeyReview, Straddle::Internal::AnyHash)
+          end
+
+        sig { returns(Straddle::Paykey) }
+        attr_reader :paykey_details
+
+        sig { params(paykey_details: Straddle::Paykey::OrHash).void }
+        attr_writer :paykey_details
+
+        sig { returns(T.nilable(Straddle::Paykeys::PaykeyVerificationDetails)) }
+        attr_reader :verification_details
+
+        sig do
+          params(
+            verification_details:
+              Straddle::Paykeys::PaykeyVerificationDetails::OrHash
+          ).void
+        end
+        attr_writer :verification_details
+
+        sig do
+          params(
+            paykey_details: Straddle::Paykey::OrHash,
+            verification_details:
+              Straddle::Paykeys::PaykeyVerificationDetails::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(paykey_details:, verification_details: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              paykey_details: Straddle::Paykey,
+              verification_details: Straddle::Paykeys::PaykeyVerificationDetails
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/straddle/models/paykeys/paykey_review_response.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Straddle
+  module Models
+    PaykeyReviewResponse = Paykeys::PaykeyReviewResponse
+
+    module Paykeys
+      class PaykeyReviewResponse < Straddle::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Straddle::Paykeys::PaykeyReviewResponse,
+              Straddle::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Straddle::Paykeys::PaykeyReview) }
+        attr_reader :data
+
+        sig { params(data: Straddle::Paykeys::PaykeyReview::OrHash).void }
+        attr_writer :data
+
+        # Metadata for an API request.
+        sig { returns(Straddle::ResponseMetadata) }
+        attr_reader :meta
+
+        sig { params(meta: Straddle::ResponseMetadata::OrHash).void }
+        attr_writer :meta
+
+        # Shape of the response envelope.
+        #
+        # - `object` means `data` contains one JSON object.
+        # - `array` means `data` contains an array of JSON objects.
+        # - `error` means `error` contains the error details.
+        # - `none` means the response contains no data.
+        sig { returns(Straddle::ResponseType::TaggedSymbol) }
+        attr_accessor :response_type
+
+        sig do
+          params(
+            data: Straddle::Paykeys::PaykeyReview::OrHash,
+            meta: Straddle::ResponseMetadata::OrHash,
+            response_type: Straddle::ResponseType::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          data:,
+          # Metadata for an API request.
+          meta:,
+          # Shape of the response envelope.
+          #
+          # - `object` means `data` contains one JSON object.
+          # - `array` means `data` contains an array of JSON objects.
+          # - `error` means `error` contains the error details.
+          # - `none` means the response contains no data.
+          response_type:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              data: Straddle::Paykeys::PaykeyReview,
+              meta: Straddle::ResponseMetadata,
+              response_type: Straddle::ResponseType::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end