method-ruby 0.1.0

data/rbi/method_ruby/models/entity_update_response.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module MethodRuby
+  module Models
+    class EntityUpdateResponse < MethodRuby::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            MethodRuby::Models::EntityUpdateResponse,
+            MethodRuby::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(MethodRuby::Entity)) }
+      attr_reader :data
+
+      sig { params(data: MethodRuby::Entity::OrHash).void }
+      attr_writer :data
+
+      sig do
+        returns(
+          T.nilable(
+            MethodRuby::Models::EntityUpdateResponse::Success::TaggedBoolean
+          )
+        )
+      end
+      attr_reader :success
+
+      sig do
+        params(
+          success: MethodRuby::Models::EntityUpdateResponse::Success::OrBoolean
+        ).void
+      end
+      attr_writer :success
+
+      sig do
+        params(
+          data: MethodRuby::Entity::OrHash,
+          success: MethodRuby::Models::EntityUpdateResponse::Success::OrBoolean
+        ).returns(T.attached_class)
+      end
+      def self.new(data: nil, success: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            data: MethodRuby::Entity,
+            success:
+              MethodRuby::Models::EntityUpdateResponse::Success::TaggedBoolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Success
+        extend MethodRuby::Internal::Type::Enum
+
+        TaggedBoolean =
+          T.type_alias do
+            T.all(T::Boolean, MethodRuby::Models::EntityUpdateResponse::Success)
+          end
+        OrBoolean = T.type_alias { T::Boolean }
+
+        TRUE =
+          T.let(
+            true,
+            MethodRuby::Models::EntityUpdateResponse::Success::TaggedBoolean
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              MethodRuby::Models::EntityUpdateResponse::Success::TaggedBoolean
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/method_ruby/models/ping_check_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module MethodRuby
+  module Models
+    class PingCheckParams < MethodRuby::Internal::Type::BaseModel
+      extend MethodRuby::Internal::Type::RequestParameters::Converter
+      include MethodRuby::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(MethodRuby::PingCheckParams, MethodRuby::Internal::AnyHash)
+        end
+
+      sig do
+        params(request_options: MethodRuby::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: MethodRuby::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/method_ruby/models/ping_check_response.rbi

@@ -0,0 +1,118 @@
+# typed: strong
+
+module MethodRuby
+  module Models
+    class PingCheckResponse < MethodRuby::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            MethodRuby::Models::PingCheckResponse,
+            MethodRuby::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(MethodRuby::Models::PingCheckResponse::Data)) }
+      attr_reader :data
+
+      sig do
+        params(data: MethodRuby::Models::PingCheckResponse::Data::OrHash).void
+      end
+      attr_writer :data
+
+      sig do
+        returns(
+          T.nilable(
+            MethodRuby::Models::PingCheckResponse::Success::TaggedBoolean
+          )
+        )
+      end
+      attr_reader :success
+
+      sig do
+        params(
+          success: MethodRuby::Models::PingCheckResponse::Success::OrBoolean
+        ).void
+      end
+      attr_writer :success
+
+      sig do
+        params(
+          data: MethodRuby::Models::PingCheckResponse::Data::OrHash,
+          success: MethodRuby::Models::PingCheckResponse::Success::OrBoolean
+        ).returns(T.attached_class)
+      end
+      def self.new(data: nil, success: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            data: MethodRuby::Models::PingCheckResponse::Data,
+            success:
+              MethodRuby::Models::PingCheckResponse::Success::TaggedBoolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < MethodRuby::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              MethodRuby::Models::PingCheckResponse::Data,
+              MethodRuby::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :status
+
+        sig { params(status: String).void }
+        attr_writer :status
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :version
+
+        sig { params(version: String).void }
+        attr_writer :version
+
+        sig do
+          params(status: String, version: String).returns(T.attached_class)
+        end
+        def self.new(status: nil, version: nil)
+        end
+
+        sig { override.returns({ status: String, version: String }) }
+        def to_hash
+        end
+      end
+
+      module Success
+        extend MethodRuby::Internal::Type::Enum
+
+        TaggedBoolean =
+          T.type_alias do
+            T.all(T::Boolean, MethodRuby::Models::PingCheckResponse::Success)
+          end
+        OrBoolean = T.type_alias { T::Boolean }
+
+        TRUE =
+          T.let(
+            true,
+            MethodRuby::Models::PingCheckResponse::Success::TaggedBoolean
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              MethodRuby::Models::PingCheckResponse::Success::TaggedBoolean
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/method_ruby/models/resource_error.rbi

@@ -0,0 +1,55 @@
+# typed: strong
+
+module MethodRuby
+  module Models
+    class ResourceError < MethodRuby::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(MethodRuby::ResourceError, MethodRuby::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :code
+
+      sig { params(code: Integer).void }
+      attr_writer :code
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :message
+
+      sig { params(message: String).void }
+      attr_writer :message
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :sub_type
+
+      sig { params(sub_type: String).void }
+      attr_writer :sub_type
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :type
+
+      sig { params(type: String).void }
+      attr_writer :type
+
+      sig do
+        params(
+          code: Integer,
+          message: String,
+          sub_type: String,
+          type: String
+        ).returns(T.attached_class)
+      end
+      def self.new(code: nil, message: nil, sub_type: nil, type: nil)
+      end
+
+      sig do
+        override.returns(
+          { code: Integer, message: String, sub_type: String, type: String }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/method_ruby/models.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module MethodRuby
+  Address = MethodRuby::Models::Address
+
+  Entity = MethodRuby::Models::Entity
+
+  EntityCorporation = MethodRuby::Models::EntityCorporation
+
+  EntityCorporationOwner = MethodRuby::Models::EntityCorporationOwner
+
+  EntityCreateParams = MethodRuby::Models::EntityCreateParams
+
+  EntityIndividual = MethodRuby::Models::EntityIndividual
+
+  EntityListParams = MethodRuby::Models::EntityListParams
+
+  EntityRetrieveParams = MethodRuby::Models::EntityRetrieveParams
+
+  EntityUpdateParams = MethodRuby::Models::EntityUpdateParams
+
+  PingCheckParams = MethodRuby::Models::PingCheckParams
+
+  ResourceError = MethodRuby::Models::ResourceError
+end

data/rbi/method_ruby/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module MethodRuby
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < MethodRuby::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(MethodRuby::RequestOptions, MethodRuby::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: MethodRuby::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: MethodRuby::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/method_ruby/resources/entities.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+
+module MethodRuby
+  module Resources
+    # Entities represent your application's end-users. An Entity is the legal holder
+    # of an Account and can be either an individual or a corporation.
+    class Entities
+      # Creates a new Entity.
+      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(MethodRuby::Models::EntityCreateResponse)
+      end
+      def create(
+        # Body param
+        body:,
+        # Header param: Unique key to ensure idempotent requests.
+        idempotency_key: nil,
+        # Header param: API version to use for this request.
+        method_version: nil,
+        request_options: {}
+      )
+      end
+
+      # Returns the Entity associated with the ID.
+      sig do
+        params(
+          ent_id: String,
+          method_version:
+            MethodRuby::EntityRetrieveParams::MethodVersion::OrSymbol,
+          request_options: MethodRuby::RequestOptions::OrHash
+        ).returns(MethodRuby::Models::EntityRetrieveResponse)
+      end
+      def retrieve(
+        # Entity identifier
+        ent_id,
+        # API version to use for this request.
+        method_version: nil,
+        request_options: {}
+      )
+      end
+
+      # Updates an Entity with the provided data.
+      sig do
+        params(
+          ent_id: String,
+          address: MethodRuby::Address::OrHash,
+          corporation: MethodRuby::EntityCorporation::OrHash,
+          individual: MethodRuby::EntityIndividual::OrHash,
+          metadata: T.nilable(T::Hash[Symbol, T.anything]),
+          idempotency_key: String,
+          method_version:
+            MethodRuby::EntityUpdateParams::MethodVersion::OrSymbol,
+          request_options: MethodRuby::RequestOptions::OrHash
+        ).returns(MethodRuby::Models::EntityUpdateResponse)
+      end
+      def update(
+        # Path param: Entity identifier
+        ent_id,
+        # Body param
+        address: nil,
+        # Body param
+        corporation: nil,
+        # Body param
+        individual: nil,
+        # Body param: Custom metadata associated with the resource
+        metadata: nil,
+        # Header param: Unique key to ensure idempotent requests.
+        idempotency_key: nil,
+        # Header param: API version to use for this request.
+        method_version: nil,
+        request_options: {}
+      )
+      end
+
+      # Returns all entities associated with your team.
+      sig do
+        params(
+          from_date: Date,
+          page: Integer,
+          page_cursor: String,
+          page_limit: Integer,
+          to_date: Date,
+          method_version: MethodRuby::EntityListParams::MethodVersion::OrSymbol,
+          request_options: MethodRuby::RequestOptions::OrHash
+        ).returns(MethodRuby::Models::EntityListResponse)
+      end
+      def list(
+        # Query param
+        from_date: nil,
+        # Query param
+        page: nil,
+        # Query param
+        page_cursor: nil,
+        # Query param
+        page_limit: nil,
+        # Query param
+        to_date: nil,
+        # Header param: API version to use for this request.
+        method_version: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: MethodRuby::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/method_ruby/resources/ping.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module MethodRuby
+  module Resources
+    # API health check endpoint.
+    class Ping
+      # Returns the API health status and version.
+      sig do
+        params(request_options: MethodRuby::RequestOptions::OrHash).returns(
+          MethodRuby::Models::PingCheckResponse
+        )
+      end
+      def check(request_options: {})
+      end
+
+      # @api private
+      sig { params(client: MethodRuby::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/method_ruby/version.rbi

@@ -0,0 +1,5 @@
+# typed: strong
+
+module MethodRuby
+  VERSION = T.let(T.unsafe(nil), String)
+end

data/sig/method_ruby/client.rbs

@@ -0,0 +1,39 @@
+module MethodRuby
+  class Client < MethodRuby::Internal::Transport::BaseClient
+    DEFAULT_MAX_RETRIES: 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS: Float
+
+    DEFAULT_INITIAL_RETRY_DELAY: Float
+
+    DEFAULT_MAX_RETRY_DELAY: Float
+
+    ENVIRONMENTS: {
+      production: "https://production.methodfi.com",
+      sandbox: "https://sandbox.methodfi.com",
+      dev: "https://dev.methodfi.com"
+    }
+
+    attr_reader api_key: String
+
+    attr_reader entities: MethodRuby::Resources::Entities
+
+    attr_reader ping: MethodRuby::Resources::Ping
+
+    private def auth_headers: (
+      security: { bearer_auth: bool }
+    ) -> ::Hash[String, String]
+
+    private def bearer_auth: -> ::Hash[String, String]
+
+    def initialize: (
+      ?api_key: String?,
+      ?environment: :production | :sandbox | :dev | nil,
+      ?base_url: String?,
+      ?max_retries: Integer,
+      ?timeout: Float,
+      ?initial_retry_delay: Float,
+      ?max_retry_delay: Float
+    ) -> void
+  end
+end

data/sig/method_ruby/errors.rbs

@@ -0,0 +1,117 @@
+module MethodRuby
+  module Errors
+    class Error < StandardError
+      attr_accessor cause: StandardError?
+    end
+
+    class ConversionError < MethodRuby::Errors::Error
+      def cause: -> StandardError?
+
+      def initialize: (
+        on: Class,
+        method: Symbol,
+        target: top,
+        value: top,
+        ?cause: StandardError?
+      ) -> void
+    end
+
+    class APIError < MethodRuby::Errors::Error
+      attr_accessor url: URI::Generic
+
+      attr_accessor status: Integer?
+
+      attr_accessor headers: ::Hash[String, String]?
+
+      attr_accessor body: top?
+
+      def initialize: (
+        url: URI::Generic,
+        ?status: Integer?,
+        ?headers: ::Hash[String, String]?,
+        ?body: Object?,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APIConnectionError < MethodRuby::Errors::APIError
+      def initialize: (
+        url: URI::Generic,
+        ?status: nil,
+        ?headers: ::Hash[String, String]?,
+        ?body: nil,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APITimeoutError < MethodRuby::Errors::APIConnectionError
+      def initialize: (
+        url: URI::Generic,
+        ?status: nil,
+        ?headers: ::Hash[String, String]?,
+        ?body: nil,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APIStatusError < MethodRuby::Errors::APIError
+      def self.for: (
+        url: URI::Generic,
+        status: Integer,
+        headers: ::Hash[String, String]?,
+        body: Object?,
+        request: nil,
+        response: nil,
+        ?message: String?
+      ) -> instance
+
+      def initialize: (
+        url: URI::Generic,
+        status: Integer,
+        headers: ::Hash[String, String]?,
+        body: Object?,
+        request: nil,
+        response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class BadRequestError < MethodRuby::Errors::APIStatusError
+      HTTP_STATUS: 400
+    end
+
+    class AuthenticationError < MethodRuby::Errors::APIStatusError
+      HTTP_STATUS: 401
+    end
+
+    class PermissionDeniedError < MethodRuby::Errors::APIStatusError
+      HTTP_STATUS: 403
+    end
+
+    class NotFoundError < MethodRuby::Errors::APIStatusError
+      HTTP_STATUS: 404
+    end
+
+    class ConflictError < MethodRuby::Errors::APIStatusError
+      HTTP_STATUS: 409
+    end
+
+    class UnprocessableEntityError < MethodRuby::Errors::APIStatusError
+      HTTP_STATUS: 422
+    end
+
+    class RateLimitError < MethodRuby::Errors::APIStatusError
+      HTTP_STATUS: 429
+    end
+
+    class InternalServerError < MethodRuby::Errors::APIStatusError
+      HTTP_STATUS: Range[Integer]
+    end
+  end
+end

data/sig/method_ruby/file_part.rbs

@@ -0,0 +1,21 @@
+module MethodRuby
+  class FilePart
+    attr_reader content: Pathname | StringIO | IO | String
+
+    attr_reader content_type: String?
+
+    attr_reader filename: String?
+
+    private def read: -> String
+
+    def to_json: (*top a) -> String
+
+    def to_yaml: (*top a) -> String
+
+    def initialize: (
+      Pathname | StringIO | IO | String content,
+      ?filename: (Pathname | String)?,
+      ?content_type: String?
+    ) -> void
+  end
+end