method-ruby 0.1.0

data/rbi/method_ruby/models/entity.rbi

@@ -0,0 +1,151 @@
+# typed: strong
+
+module MethodRuby
+  module Models
+    class Entity < MethodRuby::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(MethodRuby::Entity, MethodRuby::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(MethodRuby::Entity::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      sig { returns(MethodRuby::Entity::Type::TaggedSymbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(MethodRuby::Address)) }
+      attr_reader :address
+
+      sig { params(address: MethodRuby::Address::OrHash).void }
+      attr_writer :address
+
+      sig { returns(T.nilable(MethodRuby::EntityCorporation)) }
+      attr_reader :corporation
+
+      sig do
+        params(
+          corporation: T.nilable(MethodRuby::EntityCorporation::OrHash)
+        ).void
+      end
+      attr_writer :corporation
+
+      sig { returns(T.nilable(Time)) }
+      attr_reader :created_at
+
+      sig { params(created_at: Time).void }
+      attr_writer :created_at
+
+      sig { returns(T.nilable(MethodRuby::ResourceError)) }
+      attr_reader :error
+
+      sig { params(error: T.nilable(MethodRuby::ResourceError::OrHash)).void }
+      attr_writer :error
+
+      sig { returns(T.nilable(MethodRuby::EntityIndividual)) }
+      attr_reader :individual
+
+      sig do
+        params(individual: T.nilable(MethodRuby::EntityIndividual::OrHash)).void
+      end
+      attr_writer :individual
+
+      # Custom metadata associated with the resource
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_accessor :metadata
+
+      sig { returns(T.nilable(Time)) }
+      attr_reader :updated_at
+
+      sig { params(updated_at: Time).void }
+      attr_writer :updated_at
+
+      sig do
+        params(
+          id: String,
+          status: MethodRuby::Entity::Status::OrSymbol,
+          type: MethodRuby::Entity::Type::OrSymbol,
+          address: MethodRuby::Address::OrHash,
+          corporation: T.nilable(MethodRuby::EntityCorporation::OrHash),
+          created_at: Time,
+          error: T.nilable(MethodRuby::ResourceError::OrHash),
+          individual: T.nilable(MethodRuby::EntityIndividual::OrHash),
+          metadata: T.nilable(T::Hash[Symbol, T.anything]),
+          updated_at: Time
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        status:,
+        type:,
+        address: nil,
+        corporation: nil,
+        created_at: nil,
+        error: nil,
+        individual: nil,
+        # Custom metadata associated with the resource
+        metadata: nil,
+        updated_at: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            status: MethodRuby::Entity::Status::TaggedSymbol,
+            type: MethodRuby::Entity::Type::TaggedSymbol,
+            address: MethodRuby::Address,
+            corporation: T.nilable(MethodRuby::EntityCorporation),
+            created_at: Time,
+            error: T.nilable(MethodRuby::ResourceError),
+            individual: T.nilable(MethodRuby::EntityIndividual),
+            metadata: T.nilable(T::Hash[Symbol, T.anything]),
+            updated_at: Time
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Status
+        extend MethodRuby::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, MethodRuby::Entity::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACTIVE = T.let(:active, MethodRuby::Entity::Status::TaggedSymbol)
+        INCOMPLETE =
+          T.let(:incomplete, MethodRuby::Entity::Status::TaggedSymbol)
+        DISABLED = T.let(:disabled, MethodRuby::Entity::Status::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[MethodRuby::Entity::Status::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+
+      module Type
+        extend MethodRuby::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, MethodRuby::Entity::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        INDIVIDUAL = T.let(:individual, MethodRuby::Entity::Type::TaggedSymbol)
+        CORPORATION =
+          T.let(:corporation, MethodRuby::Entity::Type::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[MethodRuby::Entity::Type::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/method_ruby/models/entity_corporation.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module MethodRuby
+  module Models
+    class EntityCorporation < MethodRuby::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(MethodRuby::EntityCorporation, MethodRuby::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :dba
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :ein
+
+      sig { params(ein: String).void }
+      attr_writer :ein
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      sig { returns(T.nilable(T::Array[MethodRuby::EntityCorporationOwner])) }
+      attr_reader :owners
+
+      sig do
+        params(
+          owners: T::Array[MethodRuby::EntityCorporationOwner::OrHash]
+        ).void
+      end
+      attr_writer :owners
+
+      sig do
+        params(
+          dba: T.nilable(String),
+          ein: String,
+          name: String,
+          owners: T::Array[MethodRuby::EntityCorporationOwner::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(dba: nil, ein: nil, name: nil, owners: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            dba: T.nilable(String),
+            ein: String,
+            name: String,
+            owners: T::Array[MethodRuby::EntityCorporationOwner]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/method_ruby/models/entity_corporation_owner.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module MethodRuby
+  module Models
+    class EntityCorporationOwner < MethodRuby::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            MethodRuby::EntityCorporationOwner,
+            MethodRuby::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(MethodRuby::Address)) }
+      attr_reader :address
+
+      sig { params(address: MethodRuby::Address::OrHash).void }
+      attr_writer :address
+
+      sig { returns(T.nilable(Date)) }
+      attr_reader :dob
+
+      sig { params(dob: Date).void }
+      attr_writer :dob
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :email
+
+      sig { params(email: String).void }
+      attr_writer :email
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :first_name
+
+      sig { params(first_name: String).void }
+      attr_writer :first_name
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :last_name
+
+      sig { params(last_name: String).void }
+      attr_writer :last_name
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :phone
+
+      sig { params(phone: String).void }
+      attr_writer :phone
+
+      sig do
+        params(
+          address: MethodRuby::Address::OrHash,
+          dob: Date,
+          email: String,
+          first_name: String,
+          last_name: String,
+          phone: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        address: nil,
+        dob: nil,
+        email: nil,
+        first_name: nil,
+        last_name: nil,
+        phone: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            address: MethodRuby::Address,
+            dob: Date,
+            email: String,
+            first_name: String,
+            last_name: String,
+            phone: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/method_ruby/models/entity_create_params.rbi

@@ -0,0 +1,408 @@
+# typed: strong
+
+module MethodRuby
+  module Models
+    class EntityCreateParams < MethodRuby::Internal::Type::BaseModel
+      extend MethodRuby::Internal::Type::RequestParameters::Converter
+      include MethodRuby::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(MethodRuby::EntityCreateParams, MethodRuby::Internal::AnyHash)
+        end
+
+      sig do
+        returns(
+          T.any(
+            MethodRuby::EntityCreateParams::Body::Individual,
+            MethodRuby::EntityCreateParams::Body::Corporation
+          )
+        )
+      end
+      attr_accessor :body
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :idempotency_key
+
+      sig { params(idempotency_key: String).void }
+      attr_writer :idempotency_key
+
+      sig do
+        returns(
+          T.nilable(MethodRuby::EntityCreateParams::MethodVersion::OrSymbol)
+        )
+      end
+      attr_reader :method_version
+
+      sig do
+        params(
+          method_version:
+            MethodRuby::EntityCreateParams::MethodVersion::OrSymbol
+        ).void
+      end
+      attr_writer :method_version
+
+      sig do
+        params(
+          body:
+            T.any(
+              MethodRuby::EntityCreateParams::Body::Individual::OrHash,
+              MethodRuby::EntityCreateParams::Body::Corporation::OrHash
+            ),
+          idempotency_key: String,
+          method_version:
+            MethodRuby::EntityCreateParams::MethodVersion::OrSymbol,
+          request_options: MethodRuby::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        body:,
+        idempotency_key: nil,
+        method_version: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            body:
+              T.any(
+                MethodRuby::EntityCreateParams::Body::Individual,
+                MethodRuby::EntityCreateParams::Body::Corporation
+              ),
+            idempotency_key: String,
+            method_version:
+              MethodRuby::EntityCreateParams::MethodVersion::OrSymbol,
+            request_options: MethodRuby::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Body
+        extend MethodRuby::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              MethodRuby::EntityCreateParams::Body::Individual,
+              MethodRuby::EntityCreateParams::Body::Corporation
+            )
+          end
+
+        class Individual < MethodRuby::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                MethodRuby::EntityCreateParams::Body::Individual,
+                MethodRuby::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              MethodRuby::EntityCreateParams::Body::Individual::Individual
+            )
+          end
+          attr_reader :individual
+
+          sig do
+            params(
+              individual:
+                MethodRuby::EntityCreateParams::Body::Individual::Individual::OrHash
+            ).void
+          end
+          attr_writer :individual
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { returns(T.nilable(MethodRuby::Address)) }
+          attr_reader :address
+
+          sig { params(address: MethodRuby::Address::OrHash).void }
+          attr_writer :address
+
+          # Custom metadata associated with the resource
+          sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+          attr_accessor :metadata
+
+          sig do
+            params(
+              individual:
+                MethodRuby::EntityCreateParams::Body::Individual::Individual::OrHash,
+              address: MethodRuby::Address::OrHash,
+              metadata: T.nilable(T::Hash[Symbol, T.anything]),
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            individual:,
+            address: nil,
+            # Custom metadata associated with the resource
+            metadata: nil,
+            type: :individual
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                individual:
+                  MethodRuby::EntityCreateParams::Body::Individual::Individual,
+                type: Symbol,
+                address: MethodRuby::Address,
+                metadata: T.nilable(T::Hash[Symbol, T.anything])
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Individual < MethodRuby::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  MethodRuby::EntityCreateParams::Body::Individual::Individual,
+                  MethodRuby::Internal::AnyHash
+                )
+              end
+
+            sig { returns(String) }
+            attr_accessor :first_name
+
+            sig { returns(String) }
+            attr_accessor :last_name
+
+            sig { returns(T.nilable(Date)) }
+            attr_reader :dob
+
+            sig { params(dob: Date).void }
+            attr_writer :dob
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :email
+
+            sig { params(email: String).void }
+            attr_writer :email
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :phone
+
+            sig { params(phone: String).void }
+            attr_writer :phone
+
+            sig do
+              params(
+                first_name: String,
+                last_name: String,
+                dob: Date,
+                email: String,
+                phone: String
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              first_name:,
+              last_name:,
+              dob: nil,
+              email: nil,
+              phone: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  first_name: String,
+                  last_name: String,
+                  dob: Date,
+                  email: String,
+                  phone: String
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+        end
+
+        class Corporation < MethodRuby::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                MethodRuby::EntityCreateParams::Body::Corporation,
+                MethodRuby::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              MethodRuby::EntityCreateParams::Body::Corporation::Corporation
+            )
+          end
+          attr_reader :corporation
+
+          sig do
+            params(
+              corporation:
+                MethodRuby::EntityCreateParams::Body::Corporation::Corporation::OrHash
+            ).void
+          end
+          attr_writer :corporation
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { returns(T.nilable(MethodRuby::Address)) }
+          attr_reader :address
+
+          sig { params(address: MethodRuby::Address::OrHash).void }
+          attr_writer :address
+
+          # Custom metadata associated with the resource
+          sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+          attr_accessor :metadata
+
+          sig do
+            params(
+              corporation:
+                MethodRuby::EntityCreateParams::Body::Corporation::Corporation::OrHash,
+              address: MethodRuby::Address::OrHash,
+              metadata: T.nilable(T::Hash[Symbol, T.anything]),
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            corporation:,
+            address: nil,
+            # Custom metadata associated with the resource
+            metadata: nil,
+            type: :corporation
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                corporation:
+                  MethodRuby::EntityCreateParams::Body::Corporation::Corporation,
+                type: Symbol,
+                address: MethodRuby::Address,
+                metadata: T.nilable(T::Hash[Symbol, T.anything])
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Corporation < MethodRuby::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  MethodRuby::EntityCreateParams::Body::Corporation::Corporation,
+                  MethodRuby::Internal::AnyHash
+                )
+              end
+
+            sig { returns(String) }
+            attr_accessor :name
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :dba
+
+            sig { params(dba: String).void }
+            attr_writer :dba
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :ein
+
+            sig { params(ein: String).void }
+            attr_writer :ein
+
+            sig do
+              returns(T.nilable(T::Array[MethodRuby::EntityCorporationOwner]))
+            end
+            attr_reader :owners
+
+            sig do
+              params(
+                owners: T::Array[MethodRuby::EntityCorporationOwner::OrHash]
+              ).void
+            end
+            attr_writer :owners
+
+            sig do
+              params(
+                name: String,
+                dba: String,
+                ein: String,
+                owners: T::Array[MethodRuby::EntityCorporationOwner::OrHash]
+              ).returns(T.attached_class)
+            end
+            def self.new(name:, dba: nil, ein: nil, owners: nil)
+            end
+
+            sig do
+              override.returns(
+                {
+                  name: String,
+                  dba: String,
+                  ein: String,
+                  owners: T::Array[MethodRuby::EntityCorporationOwner]
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+        end
+
+        sig do
+          override.returns(
+            T::Array[MethodRuby::EntityCreateParams::Body::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+
+      module MethodVersion
+        extend MethodRuby::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, MethodRuby::EntityCreateParams::MethodVersion)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        METHOD_VERSION_2024_04_04 =
+          T.let(
+            :"2024-04-04",
+            MethodRuby::EntityCreateParams::MethodVersion::TaggedSymbol
+          )
+        METHOD_VERSION_2025_07_04 =
+          T.let(
+            :"2025-07-04",
+            MethodRuby::EntityCreateParams::MethodVersion::TaggedSymbol
+          )
+        METHOD_VERSION_2025_12_01 =
+          T.let(
+            :"2025-12-01",
+            MethodRuby::EntityCreateParams::MethodVersion::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              MethodRuby::EntityCreateParams::MethodVersion::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end