method-ruby 0.1.0 → 0.2.0

data/lib/method_ruby/resources/entities.rb

@@ -2,18 +2,60 @@
 
 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.
+    # Individuals, corporations, and receive-only entities
     class Entities
-      # Creates a new Entity.
+      # Attribute data for entities
+      # @return [MethodRuby::Resources::Entities::Attributes]
+      attr_reader :attributes
+
+      # Credit score data for entities
+      # @return [MethodRuby::Resources::Entities::CreditScores]
+      attr_reader :credit_scores
+
+      # Consent management for entities
+      # @return [MethodRuby::Resources::Entities::Consent]
+      attr_reader :consent
+
+      # Vehicle data for entities
+      # @return [MethodRuby::Resources::Entities::Vehicles]
+      attr_reader :vehicles
+
+      # Products associated with entities
+      # @return [MethodRuby::Resources::Entities::Products]
+      attr_reader :products
+
+      # Subscriptions for entities
+      # @return [MethodRuby::Resources::Entities::Subscriptions]
+      attr_reader :subscriptions
+
+      # Account connection sessions for entities
+      # @return [MethodRuby::Resources::Entities::Connect]
+      attr_reader :connect
+
+      # Account connection sessions for entities
+      # @return [MethodRuby::Resources::Entities::ManualConnect]
+      attr_reader :manual_connect
+
+      # Identity verification data for entities
+      # @return [MethodRuby::Resources::Entities::Identities]
+      attr_reader :identities
+
+      # Verification sessions for entities
+      # @return [MethodRuby::Resources::Entities::VerificationSessions]
+      attr_reader :verification_sessions
+
+      # Some parameter documentations has been truncated, see
+      # {MethodRuby::Models::EntityCreateParams} for more details.
+      #
+      # Creates a new entity.
       #
-      # @overload create(body:, idempotency_key: nil, method_version: nil, request_options: {})
+      # @overload create(body:, method_version:, idempotency_key: nil, request_options: {})
       #
-      # @param body [MethodRuby::Models::EntityCreateParams::Body::Individual, MethodRuby::Models::EntityCreateParams::Body::Corporation] Body param
+      # @param body [MethodRuby::Models::EntityCreateParams::Body::Individual, MethodRuby::Models::EntityCreateParams::Body::Corporation] Body param: Request body for creating an entity.
       #
-      # @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. This spec targets `2025-12-01
       #
-      # @param method_version [Symbol, MethodRuby::Models::EntityCreateParams::MethodVersion] Header param: API version to use for this request.
+      # @param idempotency_key [String] Header param: Idempotency key for safely retrying a write request. Reuse the sam
       #
       # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
       #
@@ -26,98 +68,133 @@ module MethodRuby
           method: :post,
           path: "entities",
           headers: parsed.except(:body).transform_keys(
-            idempotency_key: "idempotency-key",
-            method_version: "method-version"
+            method_version: "method-version",
+            idempotency_key: "idempotency-key"
           ),
           body: parsed[:body],
           model: MethodRuby::Models::EntityCreateResponse,
+          security: {secret_key: true},
           options: options
         )
       end
 
-      # Returns the Entity associated with the ID.
+      # Some parameter documentations has been truncated, see
+      # {MethodRuby::Models::EntityRetrieveParams} for more details.
       #
-      # @overload retrieve(ent_id, method_version: nil, request_options: {})
+      # Returns a single entity by its identifier.
       #
-      # @param ent_id [String] Entity identifier
+      # @overload retrieve(entity_id, method_version:, expand: nil, request_options: {})
       #
-      # @param method_version [Symbol, MethodRuby::Models::EntityRetrieveParams::MethodVersion] API version to use for this request.
+      # @param entity_id [String] Path param: Unique identifier for the entity.
+      #
+      # @param method_version [Symbol, MethodRuby::Models::EntityRetrieveParams::MethodVersion] Header param: API version to use for this request. This spec targets `2025-12-01
+      #
+      # @param expand [Array<Symbol, MethodRuby::Models::EntityRetrieveParams::Expand>] Query param: Expand related entity resources inline. Supports the entity expanda
       #
       # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
       #
       # @return [MethodRuby::Models::EntityRetrieveResponse]
       #
       # @see MethodRuby::Models::EntityRetrieveParams
-      def retrieve(ent_id, params = {})
+      def retrieve(entity_id, params)
+        query_params = [:expand]
         parsed, options = MethodRuby::EntityRetrieveParams.dump_request(params)
+        query = MethodRuby::Internal::Util.encode_query_params(parsed.slice(*query_params))
         @client.request(
           method: :get,
-          path: ["entities/%1$s", ent_id],
-          headers: parsed.transform_keys(method_version: "method-version"),
+          path: ["entities/%1$s", entity_id],
+          query: query,
+          headers: parsed.except(*query_params).transform_keys(method_version: "method-version"),
           model: MethodRuby::Models::EntityRetrieveResponse,
+          security: {secret_key: true},
           options: options
         )
       end
 
-      # Updates an Entity with the provided data.
+      # Some parameter documentations has been truncated, see
+      # {MethodRuby::Models::EntityUpdateParams} for more details.
+      #
+      # Updates an existing entity.
       #
-      # @overload update(ent_id, address: nil, corporation: nil, individual: nil, metadata: nil, idempotency_key: nil, method_version: nil, request_options: {})
+      # @overload update(entity_id, method_version:, address: nil, corporation: nil, individual: nil, metadata: nil, idempotency_key: nil, request_options: {})
       #
-      # @param ent_id [String] Path param: Entity identifier
+      # @param entity_id [String] Path param: Unique identifier for the entity.
       #
-      # @param address [MethodRuby::Models::Address] Body param
+      # @param method_version [Symbol, MethodRuby::Models::EntityUpdateParams::MethodVersion] Header param: API version to use for this request. This spec targets `2025-12-01
       #
-      # @param corporation [MethodRuby::Models::EntityCorporation] Body param
+      # @param address [MethodRuby::Models::Address] Body param: Postal mailing address.
       #
-      # @param individual [MethodRuby::Models::EntityIndividual] Body param
+      # @param corporation [MethodRuby::Models::EntityUpdateParams::Corporation] Body param
       #
-      # @param metadata [Hash{Symbol=>Object}, nil] Body param: Custom metadata associated with the resource
+      # @param individual [MethodRuby::Models::EntityUpdateParams::Individual] Body param
       #
-      # @param idempotency_key [String] Header param: Unique key to ensure idempotent requests.
+      # @param metadata [Hash{Symbol=>Object}, nil] Body param: Arbitrary key-value metadata attached to the resource.
       #
-      # @param method_version [Symbol, MethodRuby::Models::EntityUpdateParams::MethodVersion] Header param: API version to use for this request.
+      # @param idempotency_key [String] Header param: Idempotency key for safely retrying a write request. Reuse the sam
       #
       # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
       #
       # @return [MethodRuby::Models::EntityUpdateResponse]
       #
       # @see MethodRuby::Models::EntityUpdateParams
-      def update(ent_id, params = {})
+      def update(entity_id, params)
         parsed, options = MethodRuby::EntityUpdateParams.dump_request(params)
-        header_params = {idempotency_key: "idempotency-key", method_version: "method-version"}
+        header_params = {method_version: "method-version", idempotency_key: "idempotency-key"}
         @client.request(
           method: :put,
-          path: ["entities/%1$s", ent_id],
+          path: ["entities/%1$s", entity_id],
           headers: parsed.slice(*header_params.keys).transform_keys(header_params),
           body: parsed.except(*header_params.keys),
           model: MethodRuby::Models::EntityUpdateResponse,
+          security: {secret_key: true},
           options: options
         )
       end
 
-      # Returns all entities associated with your team.
+      # Some parameter documentations has been truncated, see
+      # {MethodRuby::Models::EntityListParams} for more details.
+      #
+      # Returns a paginated list of entities.
+      #
+      # @overload list(method_version:, expand: nil, from_date: nil, name: nil, page: nil, page_cursor: nil, page_limit: nil, status: nil, to_date: nil, type: nil, request_options: {})
+      #
+      # @param method_version [Symbol, MethodRuby::Models::EntityListParams::MethodVersion] Header param: API version to use for this request. This spec targets `2025-12-01
+      #
+      # @param expand [Array<Symbol, MethodRuby::Models::EntityListParams::Expand>] Query param: Expand related entity resources inline. Supports the entity expanda
+      #
+      # @param from_date [Date] Query param: Filter results from this date (inclusive, YYYY-MM-DD format).
       #
-      # @overload list(from_date: nil, page: nil, page_cursor: nil, page_limit: nil, to_date: nil, method_version: nil, request_options: {})
+      # @param name [String] Query param: Filter entities by their name.
       #
-      # @param from_date [Date] Query param
+      # @param page [Integer] Query param: Page number for pagination (1-indexed).
       #
-      # @param page [Integer] Query param
+      # @param page_cursor [String] Query param: Cursor for cursor-based pagination. Use the value from `Pagination-
       #
-      # @param page_cursor [String] Query param
+      # @param page_limit [Integer] Query param: Number of items per page.
       #
-      # @param page_limit [Integer] Query param
+      # @param status [Symbol, MethodRuby::Models::EntityListParams::Status] Query param: Filter entities by status.
       #
-      # @param to_date [Date] Query param
+      # @param to_date [Date] Query param: Filter results to this date (inclusive, YYYY-MM-DD format).
       #
-      # @param method_version [Symbol, MethodRuby::Models::EntityListParams::MethodVersion] Header param: API version to use for this request.
+      # @param type [Symbol, MethodRuby::Models::EntityListParams::Type] Query param: Filter entities by type.
       #
       # @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]
+      def list(params)
+        query_params = [
+          :expand,
+          :from_date,
+          :name,
+          :page,
+          :page_cursor,
+          :page_limit,
+          :status,
+          :to_date,
+          :type
+        ]
         parsed, options = MethodRuby::EntityListParams.dump_request(params)
         query = MethodRuby::Internal::Util.encode_query_params(parsed.slice(*query_params))
         @client.request(
@@ -126,6 +203,7 @@ module MethodRuby
           query: query,
           headers: parsed.except(*query_params).transform_keys(method_version: "method-version"),
           model: MethodRuby::Models::EntityListResponse,
+          security: {secret_key: true},
           options: options
         )
       end
@@ -135,6 +213,16 @@ module MethodRuby
       # @param client [MethodRuby::Client]
       def initialize(client:)
         @client = client
+        @attributes = MethodRuby::Resources::Entities::Attributes.new(client: client)
+        @credit_scores = MethodRuby::Resources::Entities::CreditScores.new(client: client)
+        @consent = MethodRuby::Resources::Entities::Consent.new(client: client)
+        @vehicles = MethodRuby::Resources::Entities::Vehicles.new(client: client)
+        @products = MethodRuby::Resources::Entities::Products.new(client: client)
+        @subscriptions = MethodRuby::Resources::Entities::Subscriptions.new(client: client)
+        @connect = MethodRuby::Resources::Entities::Connect.new(client: client)
+        @manual_connect = MethodRuby::Resources::Entities::ManualConnect.new(client: client)
+        @identities = MethodRuby::Resources::Entities::Identities.new(client: client)
+        @verification_sessions = MethodRuby::Resources::Entities::VerificationSessions.new(client: client)
       end
     end
   end

data/lib/method_ruby/resources/events.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  module Resources
+    # Webhook event log
+    class Events
+      # Some parameter documentations has been truncated, see
+      # {MethodRuby::Models::EventRetrieveParams} for more details.
+      #
+      # Returns a single event by its identifier.
+      #
+      # @overload retrieve(evt_id, method_version:, request_options: {})
+      #
+      # @param evt_id [String] Unique identifier for the event.
+      #
+      # @param method_version [Symbol, MethodRuby::Models::EventRetrieveParams::MethodVersion] API version to use for this request. This spec targets `2025-12-01`.
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::EventRetrieveResponse]
+      #
+      # @see MethodRuby::Models::EventRetrieveParams
+      def retrieve(evt_id, params)
+        parsed, options = MethodRuby::EventRetrieveParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: ["events/%1$s", evt_id],
+          headers: parsed.transform_keys(method_version: "method-version"),
+          model: MethodRuby::Models::EventRetrieveResponse,
+          security: {secret_key: true},
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {MethodRuby::Models::EventListParams} for more details.
+      #
+      # Returns a paginated list of webhook event records.
+      #
+      # @overload list(method_version:, from_date: nil, page: nil, page_cursor: nil, page_limit: nil, to_date: nil, type: nil, request_options: {})
+      #
+      # @param method_version [Symbol, MethodRuby::Models::EventListParams::MethodVersion] Header param: API version to use for this request. This spec targets `2025-12-01
+      #
+      # @param from_date [Date] Query param: Filter results from this date (inclusive, YYYY-MM-DD format).
+      #
+      # @param page [Integer] Query param: Page number for pagination (1-indexed).
+      #
+      # @param page_cursor [String] Query param: Cursor for cursor-based pagination. Use the value from `Pagination-
+      #
+      # @param page_limit [Integer] Query param: Number of items per page.
+      #
+      # @param to_date [Date] Query param: Filter results to this date (inclusive, YYYY-MM-DD format).
+      #
+      # @param type [String] Query param: Filter events by event type.
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::EventListResponse]
+      #
+      # @see MethodRuby::Models::EventListParams
+      def list(params)
+        query_params = [:from_date, :page, :page_cursor, :page_limit, :to_date, :type]
+        parsed, options = MethodRuby::EventListParams.dump_request(params)
+        query = MethodRuby::Internal::Util.encode_query_params(parsed.slice(*query_params))
+        @client.request(
+          method: :get,
+          path: "events",
+          query: query,
+          headers: parsed.except(*query_params).transform_keys(method_version: "method-version"),
+          model: MethodRuby::Models::EventListResponse,
+          security: {secret_key: true},
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [MethodRuby::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/method_ruby/resources/forwarding_requests.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  module Resources
+    # Request forwarding with sensitive data injection
+    class ForwardingRequests
+      # Some parameter documentations has been truncated, see
+      # {MethodRuby::Models::ForwardingRequestCreateParams} for more details.
+      #
+      # Creates a new forwarding request that proxies an HTTP request to a third-party
+      # endpoint with sensitive data injection.
+      #
+      # Forwarding-specific validation and execution failures are returned in the
+      # standard error envelope. Common forwarding `sub_type` values include
+      # `URL_NOT_ALLOWED`, `INVALID_METHOD`, `BODY_JSON_INVALID`, `BINDING_NOT_FOUND`,
+      # `FORWARDED_REQUEST_NETWORK_ERROR`, and `FORWARDED_REQUEST_TIMEOUT`.
+      #
+      # @overload create(bindings:, body:, headers:, method_:, url:, method_version:, metadata: nil, idempotency_key: nil, request_options: {})
+      #
+      # @param bindings [Hash{Symbol=>String}] Body param: Key-value map of secret bindings to inject into the request.
+      #
+      # @param body [String] Body param: Body to send with the forwarded request.
+      #
+      # @param headers [Hash{Symbol=>String}] Body param: HTTP headers to include in the forwarded request.
+      #
+      # @param method_ [Symbol, MethodRuby::Models::ForwardingRequestCreateParams::Method] Body param: HTTP method to use.
+      #
+      # @param url [String] Body param: The destination URL for the forwarded request.
+      #
+      # @param method_version [Symbol, MethodRuby::Models::ForwardingRequestCreateParams::MethodVersion] Header param: API version to use for this request. This spec targets `2025-12-01
+      #
+      # @param metadata [Object, nil] Body param: Optional metadata to attach to the forwarding request.
+      #
+      # @param idempotency_key [String] Header param: Idempotency key for safely retrying a write request. Reuse the sam
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::ForwardingRequestCreateResponse]
+      #
+      # @see MethodRuby::Models::ForwardingRequestCreateParams
+      def create(params)
+        parsed, options = MethodRuby::ForwardingRequestCreateParams.dump_request(params)
+        header_params = {method_version: "method-version", idempotency_key: "idempotency-key"}
+        @client.request(
+          method: :post,
+          path: "forwarding_requests",
+          headers: parsed.slice(*header_params.keys).transform_keys(header_params),
+          body: parsed.except(*header_params.keys),
+          model: MethodRuby::Models::ForwardingRequestCreateResponse,
+          security: {secret_key: true},
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {MethodRuby::Models::ForwardingRequestRetrieveParams} for more details.
+      #
+      # Returns a single forwarding request by its identifier.
+      #
+      # @overload retrieve(id, method_version:, request_options: {})
+      #
+      # @param id [String] Unique identifier for the forwarding request.
+      #
+      # @param method_version [Symbol, MethodRuby::Models::ForwardingRequestRetrieveParams::MethodVersion] API version to use for this request. This spec targets `2025-12-01`.
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::ForwardingRequestRetrieveResponse]
+      #
+      # @see MethodRuby::Models::ForwardingRequestRetrieveParams
+      def retrieve(id, params)
+        parsed, options = MethodRuby::ForwardingRequestRetrieveParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: ["forwarding_requests/%1$s", id],
+          headers: parsed.transform_keys(method_version: "method-version"),
+          model: MethodRuby::Models::ForwardingRequestRetrieveResponse,
+          security: {secret_key: true},
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [MethodRuby::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/method_ruby/resources/managed_accounts/transactions.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  module Resources
+    class ManagedAccounts
+      # Method-managed accounts
+      class Transactions
+        # Some parameter documentations has been truncated, see
+        # {MethodRuby::Models::ManagedAccounts::TransactionListParams} for more details.
+        #
+        # Returns a paginated list of transactions for a specific managed account.
+        #
+        # @overload list(macc_id, method_version:, from_date: nil, page: nil, page_cursor: nil, page_limit: nil, to_date: nil, request_options: {})
+        #
+        # @param macc_id [String] Path param: Unique identifier for the managed account.
+        #
+        # @param method_version [Symbol, MethodRuby::Models::ManagedAccounts::TransactionListParams::MethodVersion] Header param: API version to use for this request. This spec targets `2025-12-01
+        #
+        # @param from_date [Date] Query param: Filter results from this date (inclusive, YYYY-MM-DD format).
+        #
+        # @param page [Integer] Query param: Page number for pagination (1-indexed).
+        #
+        # @param page_cursor [String] Query param: Cursor for cursor-based pagination. Use the value from `Pagination-
+        #
+        # @param page_limit [Integer] Query param: Number of items per page.
+        #
+        # @param to_date [Date] Query param: Filter results to this date (inclusive, YYYY-MM-DD format).
+        #
+        # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [MethodRuby::Models::ManagedAccounts::TransactionListResponse]
+        #
+        # @see MethodRuby::Models::ManagedAccounts::TransactionListParams
+        def list(macc_id, params)
+          query_params = [:from_date, :page, :page_cursor, :page_limit, :to_date]
+          parsed, options = MethodRuby::ManagedAccounts::TransactionListParams.dump_request(params)
+          query = MethodRuby::Internal::Util.encode_query_params(parsed.slice(*query_params))
+          @client.request(
+            method: :get,
+            path: ["managed_accounts/%1$s/transactions", macc_id],
+            query: query,
+            headers: parsed.except(*query_params).transform_keys(method_version: "method-version"),
+            model: MethodRuby::Models::ManagedAccounts::TransactionListResponse,
+            security: {secret_key: true},
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [MethodRuby::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/method_ruby/resources/managed_accounts.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  module Resources
+    # Method-managed accounts
+    class ManagedAccounts
+      # Method-managed accounts
+      # @return [MethodRuby::Resources::ManagedAccounts::Transactions]
+      attr_reader :transactions
+
+      # Some parameter documentations has been truncated, see
+      # {MethodRuby::Models::ManagedAccountRetrieveParams} for more details.
+      #
+      # Returns a single managed account by its identifier.
+      #
+      # @overload retrieve(macc_id, method_version:, request_options: {})
+      #
+      # @param macc_id [String] Unique identifier for the managed account.
+      #
+      # @param method_version [Symbol, MethodRuby::Models::ManagedAccountRetrieveParams::MethodVersion] API version to use for this request. This spec targets `2025-12-01`.
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::ManagedAccountRetrieveResponse]
+      #
+      # @see MethodRuby::Models::ManagedAccountRetrieveParams
+      def retrieve(macc_id, params)
+        parsed, options = MethodRuby::ManagedAccountRetrieveParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: ["managed_accounts/%1$s", macc_id],
+          headers: parsed.transform_keys(method_version: "method-version"),
+          model: MethodRuby::Models::ManagedAccountRetrieveResponse,
+          security: {secret_key: true},
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {MethodRuby::Models::ManagedAccountListParams} for more details.
+      #
+      # Returns all managed accounts for the team.
+      #
+      # @overload list(method_version:, request_options: {})
+      #
+      # @param method_version [Symbol, MethodRuby::Models::ManagedAccountListParams::MethodVersion] API version to use for this request. This spec targets `2025-12-01`.
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::ManagedAccountListResponse]
+      #
+      # @see MethodRuby::Models::ManagedAccountListParams
+      def list(params)
+        parsed, options = MethodRuby::ManagedAccountListParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "managed_accounts",
+          headers: parsed.transform_keys(method_version: "method-version"),
+          model: MethodRuby::Models::ManagedAccountListResponse,
+          security: {secret_key: true},
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [MethodRuby::Client]
+      def initialize(client:)
+        @client = client
+        @transactions = MethodRuby::Resources::ManagedAccounts::Transactions.new(client: client)
+      end
+    end
+  end
+end

data/lib/method_ruby/resources/merchants.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module MethodRuby
+  module Resources
+    # Merchant directory
+    class Merchants
+      # Some parameter documentations has been truncated, see
+      # {MethodRuby::Models::MerchantRetrieveParams} for more details.
+      #
+      # Returns a single merchant by its identifier.
+      #
+      # @overload retrieve(mch_id, method_version:, request_options: {})
+      #
+      # @param mch_id [String] Unique identifier for the merchant.
+      #
+      # @param method_version [Symbol, MethodRuby::Models::MerchantRetrieveParams::MethodVersion] API version to use for this request. This spec targets `2025-12-01`.
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::MerchantRetrieveResponse]
+      #
+      # @see MethodRuby::Models::MerchantRetrieveParams
+      def retrieve(mch_id, params)
+        parsed, options = MethodRuby::MerchantRetrieveParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: ["merchants/%1$s", mch_id],
+          headers: parsed.transform_keys(method_version: "method-version"),
+          model: MethodRuby::Models::MerchantRetrieveResponse,
+          security: {secret_key: true},
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {MethodRuby::Models::MerchantListParams} for more details.
+      #
+      # Returns a list of merchants from the Method merchant directory.
+      #
+      # @overload list(method_version:, name: nil, type: nil, request_options: {})
+      #
+      # @param method_version [Symbol, MethodRuby::Models::MerchantListParams::MethodVersion] Header param: API version to use for this request. This spec targets `2025-12-01
+      #
+      # @param name [String] Query param: Search merchants by name.
+      #
+      # @param type [Symbol, MethodRuby::Models::MerchantListParams::Type] Query param: Filter merchants by account type.
+      #
+      # @param request_options [MethodRuby::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [MethodRuby::Models::MerchantListResponse]
+      #
+      # @see MethodRuby::Models::MerchantListParams
+      def list(params)
+        query_params = [:name, :type]
+        parsed, options = MethodRuby::MerchantListParams.dump_request(params)
+        query = MethodRuby::Internal::Util.encode_query_params(parsed.slice(*query_params))
+        @client.request(
+          method: :get,
+          path: "merchants",
+          query: query,
+          headers: parsed.except(*query_params).transform_keys(method_version: "method-version"),
+          model: MethodRuby::Models::MerchantListResponse,
+          security: {secret_key: true},
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [MethodRuby::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end