method-ruby 0.1.0

data/lib/method_ruby/models/entity_update_params.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  module Models
+    # @see MethodRuby::Resources::Entities#update
+    class EntityUpdateParams < MethodRuby::Internal::Type::BaseModel
+      extend MethodRuby::Internal::Type::RequestParameters::Converter
+      include MethodRuby::Internal::Type::RequestParameters
+
+      # @!attribute ent_id
+      #
+      #   @return [String]
+      required :ent_id, String
+
+      # @!attribute address
+      #
+      #   @return [MethodRuby::Models::Address, nil]
+      optional :address, -> { MethodRuby::Address }
+
+      # @!attribute corporation
+      #
+      #   @return [MethodRuby::Models::EntityCorporation, nil]
+      optional :corporation, -> { MethodRuby::EntityCorporation }
+
+      # @!attribute individual
+      #
+      #   @return [MethodRuby::Models::EntityIndividual, nil]
+      optional :individual, -> { MethodRuby::EntityIndividual }
+
+      # @!attribute metadata
+      #   Custom metadata associated with the resource
+      #
+      #   @return [Hash{Symbol=>Object}, nil]
+      optional :metadata, MethodRuby::Internal::Type::HashOf[MethodRuby::Internal::Type::Unknown], nil?: true
+
+      # @!attribute idempotency_key
+      #
+      #   @return [String, nil]
+      optional :idempotency_key, String
+
+      # @!attribute method_version
+      #
+      #   @return [Symbol, MethodRuby::Models::EntityUpdateParams::MethodVersion, nil]
+      optional :method_version, enum: -> { MethodRuby::EntityUpdateParams::MethodVersion }
+
+      # @!method initialize(ent_id:, address: nil, corporation: nil, individual: nil, metadata: nil, idempotency_key: nil, method_version: nil, request_options: {})
+      #   @param ent_id [String]
+      #
+      #   @param address [MethodRuby::Models::Address]
+      #
+      #   @param corporation [MethodRuby::Models::EntityCorporation]
+      #
+      #   @param individual [MethodRuby::Models::EntityIndividual]
+      #
+      #   @param metadata [Hash{Symbol=>Object}, nil] Custom metadata associated with the resource
+      #
+      #   @param idempotency_key [String]
+      #
+      #   @param method_version [Symbol, MethodRuby::Models::EntityUpdateParams::MethodVersion]
+      #
+      #   @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}]
+
+      module MethodVersion
+        extend MethodRuby::Internal::Type::Enum
+
+        METHOD_VERSION_2024_04_04 = :"2024-04-04"
+        METHOD_VERSION_2025_07_04 = :"2025-07-04"
+        METHOD_VERSION_2025_12_01 = :"2025-12-01"
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/method_ruby/models/entity_update_response.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  module Models
+    # @see MethodRuby::Resources::Entities#update
+    class EntityUpdateResponse < MethodRuby::Internal::Type::BaseModel
+      # @!attribute data
+      #
+      #   @return [MethodRuby::Models::Entity, nil]
+      optional :data, -> { MethodRuby::Entity }
+
+      # @!attribute success
+      #
+      #   @return [Boolean, MethodRuby::Models::EntityUpdateResponse::Success, nil]
+      optional :success, enum: -> { MethodRuby::Models::EntityUpdateResponse::Success }
+
+      # @!method initialize(data: nil, success: nil)
+      #   @param data [MethodRuby::Models::Entity]
+      #   @param success [Boolean, MethodRuby::Models::EntityUpdateResponse::Success]
+
+      # @see MethodRuby::Models::EntityUpdateResponse#success
+      module Success
+        extend MethodRuby::Internal::Type::Enum
+
+        TRUE = true
+
+        # @!method self.values
+        #   @return [Array<Boolean>]
+      end
+    end
+  end
+end

data/lib/method_ruby/models/ping_check_params.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  module Models
+    # @see MethodRuby::Resources::Ping#check
+    class PingCheckParams < MethodRuby::Internal::Type::BaseModel
+      extend MethodRuby::Internal::Type::RequestParameters::Converter
+      include MethodRuby::Internal::Type::RequestParameters
+
+      # @!method initialize(request_options: {})
+      #   @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}]
+    end
+  end
+end

data/lib/method_ruby/models/ping_check_response.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  module Models
+    # @see MethodRuby::Resources::Ping#check
+    class PingCheckResponse < MethodRuby::Internal::Type::BaseModel
+      # @!attribute data
+      #
+      #   @return [MethodRuby::Models::PingCheckResponse::Data, nil]
+      optional :data, -> { MethodRuby::Models::PingCheckResponse::Data }
+
+      # @!attribute success
+      #
+      #   @return [Boolean, MethodRuby::Models::PingCheckResponse::Success, nil]
+      optional :success, enum: -> { MethodRuby::Models::PingCheckResponse::Success }
+
+      # @!method initialize(data: nil, success: nil)
+      #   @param data [MethodRuby::Models::PingCheckResponse::Data]
+      #   @param success [Boolean, MethodRuby::Models::PingCheckResponse::Success]
+
+      # @see MethodRuby::Models::PingCheckResponse#data
+      class Data < MethodRuby::Internal::Type::BaseModel
+        # @!attribute status
+        #
+        #   @return [String, nil]
+        optional :status, String
+
+        # @!attribute version
+        #
+        #   @return [String, nil]
+        optional :version, String
+
+        # @!method initialize(status: nil, version: nil)
+        #   @param status [String]
+        #   @param version [String]
+      end
+
+      # @see MethodRuby::Models::PingCheckResponse#success
+      module Success
+        extend MethodRuby::Internal::Type::Enum
+
+        TRUE = true
+
+        # @!method self.values
+        #   @return [Array<Boolean>]
+      end
+    end
+  end
+end

data/lib/method_ruby/models/resource_error.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  module Models
+    class ResourceError < MethodRuby::Internal::Type::BaseModel
+      # @!attribute code
+      #
+      #   @return [Integer, nil]
+      optional :code, Integer
+
+      # @!attribute message
+      #
+      #   @return [String, nil]
+      optional :message, String
+
+      # @!attribute sub_type
+      #
+      #   @return [String, nil]
+      optional :sub_type, String
+
+      # @!attribute type
+      #
+      #   @return [String, nil]
+      optional :type, String
+
+      # @!method initialize(code: nil, message: nil, sub_type: nil, type: nil)
+      #   @param code [Integer]
+      #   @param message [String]
+      #   @param sub_type [String]
+      #   @param type [String]
+    end
+  end
+end

data/lib/method_ruby/models.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  [MethodRuby::Internal::Type::BaseModel, *MethodRuby::Internal::Type::BaseModel.subclasses].each do |cls|
+    cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, MethodRuby::Internal::AnyHash) } }
+  end
+
+  MethodRuby::Internal::Util.walk_namespaces(MethodRuby::Models).each do |mod|
+    case mod
+    in MethodRuby::Internal::Type::Enum | MethodRuby::Internal::Type::Union
+      mod.constants.each do |name|
+        case mod.const_get(name)
+        in true | false
+          mod.define_sorbet_constant!(:TaggedBoolean) { T.type_alias { T::Boolean } }
+          mod.define_sorbet_constant!(:OrBoolean) { T.type_alias { T::Boolean } }
+        in Integer
+          mod.define_sorbet_constant!(:TaggedInteger) { T.type_alias { Integer } }
+          mod.define_sorbet_constant!(:OrInteger) { T.type_alias { Integer } }
+        in Float
+          mod.define_sorbet_constant!(:TaggedFloat) { T.type_alias { Float } }
+          mod.define_sorbet_constant!(:OrFloat) { T.type_alias { Float } }
+        in Symbol
+          mod.define_sorbet_constant!(:TaggedSymbol) { T.type_alias { Symbol } }
+          mod.define_sorbet_constant!(:OrSymbol) { T.type_alias { T.any(Symbol, String) } }
+        else
+        end
+      end
+    else
+    end
+  end
+
+  MethodRuby::Internal::Util.walk_namespaces(MethodRuby::Models)
+                            .lazy
+                            .grep(MethodRuby::Internal::Type::Union)
+                            .each do |mod|
+    const = :Variants
+    next if mod.sorbet_constant_defined?(const)
+
+    mod.define_sorbet_constant!(const) { T.type_alias { mod.to_sorbet_type } }
+  end
+
+  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/lib/method_ruby/request_options.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+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
+    # @api private
+    #
+    # @param opts [MethodRuby::RequestOptions, Hash{Symbol=>Object}]
+    #
+    # @raise [ArgumentError]
+    def self.validate!(opts)
+      case opts
+      in MethodRuby::RequestOptions | Hash
+        opts.to_h.each_key do |k|
+          unless fields.include?(k)
+            raise ArgumentError.new("Request `opts` keys must be one of #{fields.keys}, got #{k.inspect}")
+          end
+        end
+      else
+        raise ArgumentError.new("Request `opts` must be a Hash or RequestOptions, got #{opts.inspect}")
+      end
+    end
+
+    # @!attribute idempotency_key
+    #   Idempotency key to send with request and all associated retries. Will only be
+    #   sent for write requests.
+    #
+    #   @return [String, nil]
+    optional :idempotency_key, String
+
+    # @!attribute extra_query
+    #   Extra query params to send with the request. These are `.merge`’d into any
+    #   `query` given at the client level.
+    #
+    #   @return [Hash{String=>Array<String>, String, nil}, nil]
+    optional :extra_query, MethodRuby::Internal::Type::HashOf[MethodRuby::Internal::Type::ArrayOf[String]]
+
+    # @!attribute extra_headers
+    #   Extra headers to send with the request. These are `.merged`’d into any
+    #   `extra_headers` given at the client level.
+    #
+    #   @return [Hash{String=>String, nil}, nil]
+    optional :extra_headers, MethodRuby::Internal::Type::HashOf[String, nil?: true]
+
+    # @!attribute extra_body
+    #   Extra data to send with the request. These are deep merged into any data
+    #   generated as part of the normal request.
+    #
+    #   @return [Object, nil]
+    optional :extra_body, MethodRuby::Internal::Type::HashOf[MethodRuby::Internal::Type::Unknown]
+
+    # @!attribute max_retries
+    #   Maximum number of retries to attempt after a failed initial request.
+    #
+    #   @return [Integer, nil]
+    optional :max_retries, Integer
+
+    # @!attribute timeout
+    #   Request timeout in seconds.
+    #
+    #   @return [Float, nil]
+    optional :timeout, Float
+
+    # @!method initialize(values = {})
+    #   Returns a new instance of RequestOptions.
+    #
+    #   @param values [Hash{Symbol=>Object}]
+
+    define_sorbet_constant!(:OrHash) do
+      T.type_alias { T.any(MethodRuby::RequestOptions, MethodRuby::Internal::AnyHash) }
+    end
+  end
+end

data/lib/method_ruby/resources/entities.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+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.
+      #
+      # @overload create(body:, idempotency_key: nil, method_version: nil, request_options: {})
+      #
+      # @param body [MethodRuby::Models::EntityCreateParams::Body::Individual, MethodRuby::Models::EntityCreateParams::Body::Corporation] Body param
+      #
+      # @param idempotency_key [String] Header param: Unique key to ensure idempotent requests.
+      #
+      # @param method_version [Symbol, MethodRuby::Models::EntityCreateParams::MethodVersion] Header param: API version to use for this request.
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::EntityCreateResponse]
+      #
+      # @see MethodRuby::Models::EntityCreateParams
+      def create(params)
+        parsed, options = MethodRuby::EntityCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "entities",
+          headers: parsed.except(:body).transform_keys(
+            idempotency_key: "idempotency-key",
+            method_version: "method-version"
+          ),
+          body: parsed[:body],
+          model: MethodRuby::Models::EntityCreateResponse,
+          options: options
+        )
+      end
+
+      # Returns the Entity associated with the ID.
+      #
+      # @overload retrieve(ent_id, method_version: nil, request_options: {})
+      #
+      # @param ent_id [String] Entity identifier
+      #
+      # @param method_version [Symbol, MethodRuby::Models::EntityRetrieveParams::MethodVersion] API version to use for this request.
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::EntityRetrieveResponse]
+      #
+      # @see MethodRuby::Models::EntityRetrieveParams
+      def retrieve(ent_id, params = {})
+        parsed, options = MethodRuby::EntityRetrieveParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: ["entities/%1$s", ent_id],
+          headers: parsed.transform_keys(method_version: "method-version"),
+          model: MethodRuby::Models::EntityRetrieveResponse,
+          options: options
+        )
+      end
+
+      # Updates an Entity with the provided data.
+      #
+      # @overload update(ent_id, address: nil, corporation: nil, individual: nil, metadata: nil, idempotency_key: nil, method_version: nil, request_options: {})
+      #
+      # @param ent_id [String] Path param: Entity identifier
+      #
+      # @param address [MethodRuby::Models::Address] Body param
+      #
+      # @param corporation [MethodRuby::Models::EntityCorporation] Body param
+      #
+      # @param individual [MethodRuby::Models::EntityIndividual] Body param
+      #
+      # @param metadata [Hash{Symbol=>Object}, nil] Body param: Custom metadata associated with the resource
+      #
+      # @param idempotency_key [String] Header param: Unique key to ensure idempotent requests.
+      #
+      # @param method_version [Symbol, MethodRuby::Models::EntityUpdateParams::MethodVersion] Header param: API version to use for this request.
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::EntityUpdateResponse]
+      #
+      # @see MethodRuby::Models::EntityUpdateParams
+      def update(ent_id, params = {})
+        parsed, options = MethodRuby::EntityUpdateParams.dump_request(params)
+        header_params = {idempotency_key: "idempotency-key", method_version: "method-version"}
+        @client.request(
+          method: :put,
+          path: ["entities/%1$s", ent_id],
+          headers: parsed.slice(*header_params.keys).transform_keys(header_params),
+          body: parsed.except(*header_params.keys),
+          model: MethodRuby::Models::EntityUpdateResponse,
+          options: options
+        )
+      end
+
+      # Returns all entities associated with your team.
+      #
+      # @overload list(from_date: nil, page: nil, page_cursor: nil, page_limit: nil, to_date: nil, method_version: nil, request_options: {})
+      #
+      # @param from_date [Date] Query param
+      #
+      # @param page [Integer] Query param
+      #
+      # @param page_cursor [String] Query param
+      #
+      # @param page_limit [Integer] Query param
+      #
+      # @param to_date [Date] Query param
+      #
+      # @param method_version [Symbol, MethodRuby::Models::EntityListParams::MethodVersion] Header param: API version to use for this request.
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::EntityListResponse]
+      #
+      # @see MethodRuby::Models::EntityListParams
+      def list(params = {})
+        query_params = [:from_date, :page, :page_cursor, :page_limit, :to_date]
+        parsed, options = MethodRuby::EntityListParams.dump_request(params)
+        query = MethodRuby::Internal::Util.encode_query_params(parsed.slice(*query_params))
+        @client.request(
+          method: :get,
+          path: "entities",
+          query: query,
+          headers: parsed.except(*query_params).transform_keys(method_version: "method-version"),
+          model: MethodRuby::Models::EntityListResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [MethodRuby::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/method_ruby/resources/ping.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  module Resources
+    # API health check endpoint.
+    class Ping
+      # Returns the API health status and version.
+      #
+      # @overload check(request_options: {})
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::PingCheckResponse]
+      #
+      # @see MethodRuby::Models::PingCheckParams
+      def check(params = {})
+        @client.request(
+          method: :get,
+          path: "ping",
+          model: MethodRuby::Models::PingCheckResponse,
+          security: {},
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [MethodRuby::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/method_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  VERSION = "0.1.0"
+end

data/lib/method_ruby.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Standard libraries.
+# rubocop:disable Lint/RedundantRequireStatement
+require "English"
+require "base64"
+require "cgi"
+require "date"
+require "erb"
+require "etc"
+require "json"
+require "net/http"
+require "openssl"
+require "pathname"
+require "rbconfig"
+require "securerandom"
+require "set"
+require "stringio"
+require "time"
+require "uri"
+# rubocop:enable Lint/RedundantRequireStatement
+
+# We already ship the preferred sorbet manifests in the package itself.
+# `tapioca` currently does not offer us a way to opt out of unnecessary compilation.
+if Object.const_defined?(:Tapioca) &&
+   caller.chain([$PROGRAM_NAME]).chain(ARGV).any?(/tapioca/) &&
+   ARGV.none?(/dsl/)
+  return
+end
+
+# Gems.
+require "connection_pool"
+
+# Package files.
+require_relative "method_ruby/version"
+require_relative "method_ruby/internal/util"
+require_relative "method_ruby/internal/type/converter"
+require_relative "method_ruby/internal/type/unknown"
+require_relative "method_ruby/internal/type/boolean"
+require_relative "method_ruby/internal/type/file_input"
+require_relative "method_ruby/internal/type/enum"
+require_relative "method_ruby/internal/type/union"
+require_relative "method_ruby/internal/type/array_of"
+require_relative "method_ruby/internal/type/hash_of"
+require_relative "method_ruby/internal/type/base_model"
+require_relative "method_ruby/internal/type/base_page"
+require_relative "method_ruby/internal/type/request_parameters"
+require_relative "method_ruby/internal"
+require_relative "method_ruby/request_options"
+require_relative "method_ruby/file_part"
+require_relative "method_ruby/errors"
+require_relative "method_ruby/internal/transport/base_client"
+require_relative "method_ruby/internal/transport/pooled_net_requester"
+require_relative "method_ruby/client"
+require_relative "method_ruby/models/address"
+require_relative "method_ruby/models/entity"
+require_relative "method_ruby/models/entity_corporation"
+require_relative "method_ruby/models/entity_corporation_owner"
+require_relative "method_ruby/models/entity_create_params"
+require_relative "method_ruby/models/entity_create_response"
+require_relative "method_ruby/models/entity_individual"
+require_relative "method_ruby/models/entity_list_params"
+require_relative "method_ruby/models/entity_list_response"
+require_relative "method_ruby/models/entity_retrieve_params"
+require_relative "method_ruby/models/entity_retrieve_response"
+require_relative "method_ruby/models/entity_update_params"
+require_relative "method_ruby/models/entity_update_response"
+require_relative "method_ruby/models/ping_check_params"
+require_relative "method_ruby/models/ping_check_response"
+require_relative "method_ruby/models/resource_error"
+require_relative "method_ruby/models"
+require_relative "method_ruby/resources/entities"
+require_relative "method_ruby/resources/ping"

data/manifest.yaml

@@ -0,0 +1,17 @@
+dependencies:
+  - English
+  - base64
+  - cgi
+  - date
+  - erb
+  - etc
+  - json
+  - net/http
+  - openssl
+  - pathname
+  - rbconfig
+  - securerandom
+  - set
+  - stringio
+  - time
+  - uri