apimatic-plaid-sdk 0.0.1

data/lib/plaid/apis/processor_api.rb

@@ -0,0 +1,189 @@
+# plaid
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module Plaid
+  # ProcessorApi
+  class ProcessorApi < BaseApi
+    # Use the `/processor/bank_transfer/create` endpoint to initiate a new bank
+    # transfer as a processor
+    # @param [ProcessorBankTransferCreateRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def processor_bank_transfer_create(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/processor/bank_transfer/create',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ProcessorBankTransferCreateResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # The `/processor/balance/get` endpoint returns the real-time balance for
+    # each of an Item's accounts. While other endpoints may return a balance
+    # object, only `/processor/balance/get` forces the available and current
+    # balance fields to be refreshed rather than cached.
+    # @param [ProcessorBalanceGetRequest] body Required parameter: The
+    # `/processor/balance/get` endpoint returns the real-time balance for the
+    # account associated with a given `processor_token`.  The current balance is
+    # the total amount of funds in the account. The available balance is the
+    # current balance less any outstanding holds or debits that have not yet
+    # posted to the account.  Note that not all institutions calculate the
+    # available balance. In the event that available balance is unavailable from
+    # the institution, Plaid will return an available balance value of `null`.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def processor_balance_get(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/processor/balance/get',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ProcessorBalanceGetResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # The `/processor/auth/get` endpoint returns the bank account and bank
+    # identification number (such as the routing number, for US accounts), for a
+    # checking or savings account that's associated with a given
+    # `processor_token`. The endpoint also returns high-level account data and
+    # balances when available.
+    # @param [ProcessorAuthGetRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def processor_auth_get(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/processor/auth/get',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ProcessorAuthGetResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # The `/processor/identity/get` endpoint allows you to retrieve various
+    # account holder information on file with the financial institution,
+    # including names, emails, phone numbers, and addresses.
+    # @param [ProcessorIdentityGetRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def processor_identity_get(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/processor/identity/get',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ProcessorIdentityGetResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Used to create a token suitable for sending to Apex to enable Plaid-Apex
+    # integrations.
+    # @param [ProcessorApexProcessorTokenCreateRequest] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def processor_apex_processor_token_create(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/processor/apex/processor_token/create',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ProcessorTokenCreateResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Used to create a token suitable for sending to one of Plaid's partners to
+    # enable integrations. Note that Stripe partnerships use bank account tokens
+    # instead; see `/processor/stripe/bank_account_token/create` for creating
+    # tokens for use with Stripe integrations.
+    # @param [ProcessorTokenCreateRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def processor_token_create(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/processor/token/create',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ProcessorTokenCreateResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Used to create a token suitable for sending to Stripe to enable
+    # Plaid-Stripe integrations. For a detailed guide on integrating Stripe, see
+    # [Add Stripe to your
+    # app](https://plaid.com/docs/auth/partnerships/stripe/).
+    # @param [ProcessorStripeBankAccountTokenCreateRequest] body Required
+    # parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def processor_stripe_bank_account_token_create(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/processor/stripe/bank_account_token/create',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ProcessorStripeBankAccountTokenCreateResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end

data/lib/plaid/apis/sandbox_api.rb

@@ -0,0 +1,302 @@
+# plaid
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module Plaid
+  # SandboxApi
+  class SandboxApi < BaseApi
+    # The `/sandbox/item/set_verification_status` endpoint can be used to change
+    # the verification status of an Item in in the Sandbox in order to simulate
+    # the Automated Micro-deposit flow.
+    # Note that not all Plaid developer accounts are enabled for micro-deposit
+    # based verification by default. Your account must be enabled for this
+    # feature in order to test it in Sandbox. To enable this features or check
+    # your status, contact your account manager or [submit a product access
+    # Support
+    # ticket](https://dashboard.plaid.com/support/new/product-and-development/pr
+    # oduct-troubleshooting/request-product-access).
+    # For more information on testing Automated Micro-deposits in Sandbox, see
+    # [Auth full coverage
+    # testing](https://plaid.com/docs/auth/coverage/testing#).
+    # @param [SandboxItemSetVerificationStatusRequest] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def sandbox_item_set_verification_status(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/sandbox/item/set_verification_status',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SandboxItemSetVerificationStatusResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Use the `/sandbox/public_token/create`  endpoint to create a valid
+    # `public_token`  for an arbitrary institution ID, initial products, and
+    # test credentials. The created `public_token` maps to a new Sandbox Item.
+    # You can then call `/item/public_token/exchange` to exchange the
+    # `public_token` for an `access_token` and perform all API actions.
+    # `/sandbox/public_token/create` can also be used with the [`user_custom`
+    # test username](https://plaid.com/docs/sandbox/user-custom) to generate a
+    # test account with custom data.
+    # @param [SandboxPublicTokenCreateRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def sandbox_public_token_create(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/sandbox/public_token/create',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SandboxPublicTokenCreateResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response.',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Use the `/sandbox/processor_token/create` endpoint to create a valid
+    # `processor_token` for an arbitrary institution ID and test credentials.
+    # The created `processor_token` corresponds to a new Sandbox Item. You can
+    # then use this `processor_token` with the `/processor/` API endpoints in
+    # Sandbox. You can also use `/sandbox/processor_token/create` with the
+    # [`user_custom` test username](https://plaid.com/docs/sandbox/user-custom)
+    # to generate a test account with custom data.
+    # @param [SandboxProcessorTokenCreateRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def sandbox_processor_token_create(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/sandbox/processor_token/create',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SandboxProcessorTokenCreateResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response.',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # The `/sandbox/item/fire_webhook` endpoint is used to test that code
+    # correctly handles webhooks. Calling this endpoint triggers a Transactions
+    # `DEFAULT_UPDATE` webhook to be fired for a given Sandbox Item. If the Item
+    # does not support Transactions, a `SANDBOX_PRODUCT_NOT_ENABLED` error will
+    # result.
+    # @param [SandboxItemFireWebhookRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def sandbox_item_fire_webhook(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/sandbox/item/fire_webhook',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SandboxItemFireWebhookResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response.',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # `/sandbox/item/reset_login/` forces an Item into an `ITEM_LOGIN_REQUIRED`
+    # state in order to simulate an Item whose login is no longer valid. This
+    # makes it easy to test Link's [update
+    # mode](https://plaid.com/docs/link/update-mode) flow in the Sandbox
+    # environment.  After calling `/sandbox/item/reset_login`, You can then use
+    # Plaid Link update mode to restore the Item to a good state. An
+    # `ITEM_LOGIN_REQUIRED` webhook will also be fired after a call to this
+    # endpoint, if one is associated with the Item.
+    # In the Sandbox, Items will transition to an `ITEM_LOGIN_REQUIRED` error
+    # state automatically after 30 days, even if this endpoint is not called.
+    # @param [SandboxItemResetLoginRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def sandbox_item_reset_login(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/sandbox/item/reset_login',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SandboxItemResetLoginResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Use the `/sandbox/income/fire_webhook` endpoint to manually trigger an
+    # Income webhook in the Sandbox environment.
+    # @param [SandboxIncomeFireWebhookRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def sandbox_income_fire_webhook(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/sandbox/income/fire_webhook',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SandboxIncomeFireWebhookResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Save the selected accounts when connecting to the Platypus Oauth
+    # institution
+    # @param [SandboxOauthSelectAccountsRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def sandbox_oauth_select_accounts(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/sandbox/oauth/select_accounts',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:json_deserialize))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response.',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Use the `/sandbox/transfer/simulate` endpoint to simulate a transfer event
+    # in the Sandbox environment.  Note that while an event will be simulated
+    # and will appear when using endpoints such as `/transfer/event/sync` or
+    # `/transfer/event/list`, no transactions will actually take place and funds
+    # will not move between accounts, even within the Sandbox.
+    # @param [SandboxTransferSimulateRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def sandbox_transfer_simulate(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/sandbox/transfer/simulate',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SandboxTransferSimulateResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Use the `/sandbox/bank_transfer/fire_webhook` endpoint to manually trigger
+    # a Bank Transfers webhook in the Sandbox environment.
+    # @param [SandboxBankTransferFireWebhookRequest] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def sandbox_bank_transfer_fire_webhook(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/sandbox/bank_transfer/fire_webhook',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SandboxBankTransferFireWebhookResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Use the `/sandbox/bank_transfer/simulate` endpoint to simulate a bank
+    # transfer event in the Sandbox environment.  Note that while an event will
+    # be simulated and will appear when using endpoints such as
+    # `/bank_transfer/event/sync` or `/bank_transfer/event/list`, no
+    # transactions will actually take place and funds will not move between
+    # accounts, even within the Sandbox.
+    # @param [SandboxBankTransferSimulateRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def sandbox_bank_transfer_simulate(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/sandbox/bank_transfer/simulate',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SandboxBankTransferSimulateResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response',
+                                 ErrorErrorException))
+        .execute
+    end
+  end
+end

data/lib/plaid/apis/signal_api.rb

@@ -0,0 +1,97 @@
+# plaid
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module Plaid
+  # SignalApi
+  class SignalApi < BaseApi
+    # Use `/signal/evaluate` to evaluate a planned ACH transaction to get a
+    # return risk assessment (such as a risk score and risk tier) and additional
+    # risk signals.
+    # In order to obtain a valid score for an ACH transaction, Plaid must have
+    # an access token for the account, and the Item must be healthy (receiving
+    # product updates) or have recently been in a healthy state. If the
+    # transaction does not meet eligibility requirements, an error will be
+    # returned corresponding to the underlying cause.
+    # @param [SignalEvaluateRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def signal_evaluate(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/signal/evaluate',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SignalEvaluateResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response.',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # After calling `/signal/evaluate`, call `/signal/decision/report` to report
+    # whether the transaction was initiated. This endpoint will return an
+    # `INVALID_REQUEST` error if called a second time with a different value for
+    # `initiated`.
+    # @param [SignalDecisionReportRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def signal_decision_report(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/signal/decision/report',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SignalDecisionReportResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response.',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Call the `/signal/return/report` endpoint to report a returned transaction
+    # that was previously sent to the `/signal/evaluate` endpoint. Your feedback
+    # will be used by the model to incorporate the latest risk trend in your
+    # portfolio.
+    # @param [SignalReturnReportRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def signal_return_report(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/signal/return/report',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(And.new('PLAID-CLIENT-ID', 'PLAID-SECRET', 'Plaid-Version')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SignalReturnReportResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response.',
+                                 ErrorErrorException))
+        .execute
+    end
+  end
+end