apimatic-plaid-sdk 0.0.1

data/lib/plaid/apis/item_api.rb

@@ -0,0 +1,267 @@
+# plaid
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module Plaid
+  # ItemApi
+  class ItemApi < BaseApi
+    # By default, the `access_token` associated with an Item does not expire and
+    # should be stored in a persistent, secure manner.
+    # You can use the `/item/access_token/invalidate` endpoint to rotate the
+    # `access_token` associated with an Item. The endpoint returns a new
+    # `access_token` and immediately invalidates the previous `access_token`.
+    # @param [ItemAccessTokenInvalidateRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def item_access_token_invalidate(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/item/access_token/invalidate',
+                                     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(ItemAccessTokenInvalidateResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # The `/item/remove`  endpoint allows you to remove an Item. Once removed,
+    # the `access_token`  associated with the Item is no longer valid and cannot
+    # be used to access any data that was associated with the Item.
+    # Note that in the Development environment, issuing an `/item/remove`
+    # request will not decrement your live credential count. To increase your
+    # credential account in Development, contact Support.
+    # Also note that for certain OAuth-based institutions, an Item removed via
+    # `/item/remove` may still show as an active connection in the institution's
+    # OAuth permission manager.
+    # @param [ItemRemoveRequest] body Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def item_remove(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/item/remove',
+                                     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(ItemRemoveResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response.',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # List a user’s connected applications
+    # @param [ItemApplicationListRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def item_application_list(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/item/application/list',
+                                     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(ItemApplicationListResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response.',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Exchange a Link `public_token` for an API `access_token`. Link hands off
+    # the `public_token` client-side via the `onSuccess` callback once a user
+    # has successfully created an Item. The `public_token` is ephemeral and
+    # expires after 30 minutes.
+    # The response also includes an `item_id` that should be stored with the
+    # `access_token`. The `item_id` is used to identify an Item in a webhook.
+    # The `item_id` can also be retrieved by making an `/item/get` request.
+    # @param [ItemPublicTokenExchangeRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def item_public_token_exchange(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/item/public_token/exchange',
+                                     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(ItemPublicTokenExchangeResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Returns information about the status of an Item.
+    # @param [ItemGetRequest] body Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def item_get(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/item/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(ItemGetResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response.',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # Note: As of July 2020, the `/item/public_token/create` endpoint is
+    # deprecated. Instead, use `/link/token/create` with an `access_token` to
+    # create a Link token for use with [update
+    # mode](https://plaid.com/docs/link/update-mode).
+    # If you need your user to take action to restore or resolve an error
+    # associated with an Item, generate a public token with the
+    # `/item/public_token/create` endpoint and then initialize Link with that
+    # `public_token`.
+    # A `public_token` is one-time use and expires after 30 minutes. You use a
+    # `public_token` to initialize Link in [update
+    # mode](https://plaid.com/docs/link/update-mode) for a particular Item. You
+    # can generate a `public_token` for an Item even if you did not use Link to
+    # create the Item originally.
+    # The `/item/public_token/create` endpoint is **not** used to create your
+    # initial `public_token`. If you have not already received an `access_token`
+    # for a specific Item, use Link to obtain your `public_token` instead. See
+    # the [Quickstart](https://plaid.com/docs/quickstart) for more information.
+    # @param [ItemPublicTokenCreateRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def item_create_public_token(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/item/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(ItemPublicTokenCreateResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Enable consumers to update product access on selected accounts for an
+    # application.
+    # @param [ItemApplicationScopesUpdateRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def item_application_scopes_update(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/item/application/scopes/update',
+                                     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(ItemApplicationScopesUpdateResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('default',
+                                 'Error response.',
+                                 ErrorErrorException))
+        .execute
+    end
+
+    # The POST `/item/webhook/update` allows you to update the webhook URL
+    # associated with an Item. This request triggers a
+    # [`WEBHOOK_UPDATE_ACKNOWLEDGED`](https://plaid.com/docs/api/webhooks/#item-
+    # webhook-url-updated) webhook to the newly specified webhook URL.
+    # @param [ItemWebhookUpdateRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def item_webhook_update(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/item/webhook/update',
+                                     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(ItemWebhookUpdateResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # `/item/import` creates an Item via your Plaid Exchange Integration and
+    # returns an `access_token`. As part of an `/item/import` request, you will
+    # include a User ID (`user_auth.user_id`) and Authentication Token
+    # (`user_auth.auth_token`) that enable data aggregation through your Plaid
+    # Exchange API endpoints. These authentication principals are to be chosen
+    # by you.
+    # Upon creating an Item via `/item/import`, Plaid will automatically begin
+    # an extraction of that Item through the Plaid Exchange infrastructure you
+    # have already integrated. This will automatically generate the Plaid native
+    # account ID for the account the user will switch their direct deposit to
+    # (`target_account_id`).
+    # @param [ItemImportRequest] body Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def item_import(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/item/import',
+                                     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(ItemImportResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end

data/lib/plaid/apis/liabilities_api.rb

@@ -0,0 +1,47 @@
+# plaid
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module Plaid
+  # LiabilitiesApi
+  class LiabilitiesApi < BaseApi
+    # The `/liabilities/get` endpoint returns various details about an Item with
+    # loan or credit accounts. Liabilities data is available primarily for US
+    # financial institutions, with some limited coverage of Canadian
+    # institutions. Currently supported account types are account type `credit`
+    # with account subtype `credit card` or `paypal`, and account type `loan`
+    # with account subtype `student` or `mortgage`. To limit accounts listed in
+    # Link to types and subtypes supported by Liabilities, you can use the
+    # `account_filters` parameter when [creating a Link
+    # token](https://plaid.com/docs/api/tokens/#linktokencreate).
+    # The types of information returned by Liabilities can include balances and
+    # due dates, loan terms, and account details such as original loan amount
+    # and guarantor. Data is refreshed approximately once per day; the latest
+    # data can be retrieved by calling `/liabilities/get`.
+    # Note: This request may take some time to complete if `liabilities` was not
+    # specified as an initial product when creating the Item. This is because
+    # Plaid must communicate directly with the institution to retrieve the
+    # additional data.
+    # @param [LiabilitiesGetRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def liabilities_get(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/liabilities/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(LiabilitiesGetResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end

data/lib/plaid/apis/link_api.rb

@@ -0,0 +1,62 @@
+# plaid
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module Plaid
+  # LinkApi
+  class LinkApi < BaseApi
+    # The `/link/token/get` endpoint gets information about a previously-created
+    # `link_token` using the
+    # `/link/token/create` endpoint. It can be useful for debugging purposes.
+    # @param [LinkTokenGetRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def link_token_get(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/link/token/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(LinkTokenGetResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # The `/link/token/create` endpoint creates a `link_token`, which is
+    # required as a parameter when initializing Link. Once Link has been
+    # initialized, it returns a `public_token`, which can then be exchanged for
+    # an `access_token` via `/item/public_token/exchange` as part of the main
+    # Link flow.
+    # A `link_token` generated by `/link/token/create` is also used to
+    # initialize other Link flows, such as the update mode flow for tokens with
+    # expired credentials, or the Payment Initiation (Europe) flow.
+    # @param [LinkTokenCreateRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def link_token_create(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/link/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(LinkTokenCreateResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end

data/lib/plaid/apis/payment_initiation_api.rb

@@ -0,0 +1,236 @@
+# plaid
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module Plaid
+  # PaymentInitiationApi
+  class PaymentInitiationApi < BaseApi
+    # Reverse a previously initiated payment.
+    # A payment can only be reversed once and will be refunded to the original
+    # sender's account.
+    # @param [PaymentInitiationPaymentReverseRequest] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def payment_initiation_payment_reverse(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payment_initiation/payment/reverse',
+                                     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(PaymentInitiationPaymentReverseResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Create a payment recipient for payment initiation.  The recipient must be
+    # in Europe, within a country that is a member of the Single Euro Payment
+    # Area (SEPA).  For a standing order (recurring) payment, the recipient must
+    # be in the UK.
+    # The endpoint is idempotent: if a developer has already made a request with
+    # the same payment details, Plaid will return the same `recipient_id`.
+    # @param [PaymentInitiationRecipientCreateRequest] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def payment_initiation_recipient_create(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payment_initiation/recipient/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(PaymentInitiationRecipientCreateResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # The `/payment_initiation/recipient/list` endpoint list the payment
+    # recipients that you have previously created.
+    # @param [PaymentInitiationRecipientListRequest] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def payment_initiation_recipient_list(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payment_initiation/recipient/list',
+                                     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(PaymentInitiationRecipientListResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Get details about a payment recipient you have previously created.
+    # @param [PaymentInitiationRecipientGetRequest] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def payment_initiation_recipient_get(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payment_initiation/recipient/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(PaymentInitiationRecipientGetResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # After creating a payment recipient, you can use the
+    # `/payment_initiation/payment/create` endpoint to create a payment to that
+    # recipient.  Payments can be one-time or standing order (recurring) and can
+    # be denominated in either EUR or GBP.  If making domestic GBP-denominated
+    # payments, your recipient must have been created with BACS numbers. In
+    # general, EUR-denominated payments will be sent via SEPA Credit Transfer
+    # and GBP-denominated payments will be sent via the Faster Payments network,
+    # but the payment network used will be determined by the institution.
+    # Payments sent via Faster Payments will typically arrive immediately, while
+    # payments sent via SEPA Credit Transfer will typically arrive in one
+    # business day.
+    # Standing orders (recurring payments) must be denominated in GBP and can
+    # only be sent to recipients in the UK. Once created, standing order
+    # payments cannot be modified or canceled via the API. An end user can
+    # cancel or modify a standing order directly on their banking application or
+    # website, or by contacting the bank. Standing orders will follow the
+    # payment rules of the underlying rails (Faster Payments in UK). Payments
+    # can be sent Monday to Friday, excluding bank holidays. If the pre-arranged
+    # date falls on a weekend or bank holiday, the payment is made on the next
+    # working day. It is not possible to guarantee the exact time the payment
+    # will reach the recipient’s account, although at least 90% of standing
+    # order payments are sent by 6am.
+    # In the Development environment, payments must be below 5 GBP / EUR. For
+    # details on any payment limits in Production, contact your Plaid Account
+    # Manager.
+    # @param [PaymentInitiationPaymentCreateRequest] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def payment_initiation_payment_create(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payment_initiation/payment/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(PaymentInitiationPaymentCreateResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # The `/payment_initiation/payment/get` endpoint can be used to check the
+    # status of a payment, as well as to receive basic information such as
+    # recipient and payment amount. In the case of standing orders, the
+    # `/payment_initiation/payment/get` endpoint will provide information about
+    # the status of the overall standing order itself; the API cannot be used to
+    # retrieve payment status for individual payments within a standing order.
+    # @param [PaymentInitiationPaymentGetRequest] body Required parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def payment_initiation_payment_get(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payment_initiation/payment/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(PaymentInitiationPaymentGetResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # The `/payment_initiation/payment/token/create` endpoint has been
+    # deprecated. New Plaid customers will be unable to use this endpoint, and
+    # existing customers are encouraged to migrate to the newer,
+    # `link_token`-based flow. The recommended flow is to provide the
+    # `payment_id` to `/link/token/create`, which returns a `link_token` used to
+    # initialize Link.
+    # The `/payment_initiation/payment/token/create` is used to create a
+    # `payment_token`, which can then be used in Link initialization to enter a
+    # payment initiation flow. You can only use a `payment_token` once. If this
+    # attempt fails, the end user aborts the flow, or the token expires, you
+    # will need to create a new payment token. Creating a new payment token does
+    # not require end user input.
+    # @param [PaymentInitiationPaymentTokenCreateRequest] body Required
+    # parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_payment_token(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payment_initiation/payment/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(PaymentInitiationPaymentTokenCreateResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # The `/payment_initiation/payment/list` endpoint can be used to retrieve
+    # all created payments. By default, the 10 most recent payments are
+    # returned. You can request more payments and paginate through the results
+    # using the optional `count` and `cursor` parameters.
+    # @param [PaymentInitiationPaymentListRequest] body Required parameter:
+    # TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def payment_initiation_payment_list(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payment_initiation/payment/list',
+                                     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(PaymentInitiationPaymentListResponse.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end