fdx-api-sdk-ruby 1.0.0

data/lib/fdx_api/controllers/recipients_controller.rb

@@ -0,0 +1,197 @@
+# fdx_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module FdxApi
+  # RecipientsController
+  class RecipientsController < BaseController
+    # Request to Register Recipient by Creating a Recipient Record
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @param [RecipientRequest] body Optional parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_recipient(x_fapi_interaction_id,
+                         fdx_api_actor_type: nil,
+                         body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/register',
+                                     Server::RECIPIENTREGISTRATION)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(RecipientProvider.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Get a specific recipient data identified with clientId
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [String] client_id Required parameter: Client Identifier. Uniquely
+    # identifies a Client
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_recipient(x_fapi_interaction_id,
+                      client_id,
+                      fdx_api_actor_type: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/register/{clientId}',
+                                     Server::RECIPIENTREGISTRATION)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .template_param(new_parameter(client_id, key: 'clientId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(RecipientProvider.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Update data for a specific recipient identified with clientId
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [String] client_id Required parameter: Client Identifier. Uniquely
+    # identifies a Client
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @param [RecipientRequest] body Optional parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_recipient(x_fapi_interaction_id,
+                         client_id,
+                         fdx_api_actor_type: nil,
+                         body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/register/{clientId}',
+                                     Server::RECIPIENTREGISTRATION)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .template_param(new_parameter(client_id, key: 'clientId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(RecipientProvider.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Delete data for a specific recipient identified with clientId
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [String] client_id Required parameter: Client Identifier. Uniquely
+    # identifies a Client
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def delete_recipient(x_fapi_interaction_id,
+                         client_id,
+                         fdx_api_actor_type: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/register/{clientId}',
+                                     Server::RECIPIENTREGISTRATION)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .template_param(new_parameter(client_id, key: 'clientId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Get recipients
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @param [String] offset Optional parameter: Opaque cursor used by the
+    # provider to send the next set of records
+    # @param [Integer] limit Optional parameter: Number of elements that the
+    # consumer wishes to receive. Providers should implement reasonable
+    # default/maximum/minimum values based on their internal architecture and
+    # update their documentation accordingly
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_registry_recipients(x_fapi_interaction_id,
+                                fdx_api_actor_type: nil,
+                                offset: nil,
+                                limit: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/recipients',
+                                     Server::REGISTRY)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .query_param(new_parameter(offset, key: 'offset'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(RecipientRecordsAtEcosystemRegistry.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # Get a specific recipient
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [String] recipient_id Required parameter: Recipient Identifier.
+    # Uniquely identifies a Recipient
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_registry_recipient(x_fapi_interaction_id,
+                               recipient_id,
+                               fdx_api_actor_type: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/recipients/{recipientId}',
+                                     Server::REGISTRY)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .template_param(new_parameter(recipient_id, key: 'recipientId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(RecipientRecordAtEcosystemRegistry.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end

data/lib/fdx_api/controllers/recurring_payments_controller.rb

@@ -0,0 +1,339 @@
+# fdx_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module FdxApi
+  # RecurringPaymentsController
+  class RecurringPaymentsController < BaseController
+    # Search for recurring payments
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @param [String] updated_since Optional parameter: Return items that have
+    # been created or updated since the nextUpdateId
+    # @param [String] offset Optional parameter: Opaque cursor used by the
+    # provider to send the next set of records
+    # @param [Integer] limit Optional parameter: Number of elements that the
+    # consumer wishes to receive. Providers should implement reasonable
+    # default/maximum/minimum values based on their internal architecture and
+    # update their documentation accordingly
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def search_for_recurring_payments(x_fapi_interaction_id,
+                                      fdx_api_actor_type: nil,
+                                      updated_since: nil,
+                                      offset: nil,
+                                      limit: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/recurring-payments',
+                                     Server::MONEYMOVEMENT)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .query_param(new_parameter(updated_since, key: 'updatedSince'))
+                   .query_param(new_parameter(offset, key: 'offset'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(RecurringPaymentsEntity.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('404',
+                                 'Data not found for request parameters',
+                                 ErrorException)
+                    .local_error('500',
+                                 'Catch-all exception where request was not processed due to an'\
+                                  ' internal outage/issue. Consider other more specific errors'\
+                                  ' before using this error',
+                                 ErrorException)
+                    .local_error('501',
+                                 'Error when FdxVersion in Header is not one of those'\
+                                  ' implemented at backend',
+                                 ErrorException)
+                    .local_error('503',
+                                 'System is down for maintenance',
+                                 ErrorException))
+        .execute
+    end
+
+    # Schedule a recurring payment
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [String] idempotency_key Required parameter: Used to de-duplicate
+    # requests
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @param [RecurringPaymentForUpdateEntity1] body Optional parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def schedule_recurring_payment(x_fapi_interaction_id,
+                                   idempotency_key,
+                                   fdx_api_actor_type: nil,
+                                   body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/recurring-payments',
+                                     Server::MONEYMOVEMENT)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .header_param(new_parameter(idempotency_key, key: 'idempotency-key')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(RecurringPaymentEntity.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Request is invalid',
+                                 ErrorException)
+                    .local_error('404',
+                                 'Requested payment is invalid',
+                                 ErrorException)
+                    .local_error('409',
+                                 'Duplicate Request',
+                                 RecurringPaymentEntityErrorException)
+                    .local_error('422',
+                                 'Account type not supported',
+                                 ErrorException)
+                    .local_error('500',
+                                 'Catch-all exception where request was not processed due to an'\
+                                  ' internal outage/issue. Consider other more specific errors'\
+                                  ' before using this error',
+                                 ErrorException)
+                    .local_error('501',
+                                 'Error when FdxVersion in Header is not one of those'\
+                                  ' implemented at backend',
+                                 ErrorException)
+                    .local_error('503',
+                                 'System is down for maintenance',
+                                 ErrorException))
+        .execute
+    end
+
+    # Get a recurring payment
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [String] recurring_payment_id Required parameter: Recurring Payment
+    # Identifier. Uniquely identifies a recurring payment
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_recurring_payment(x_fapi_interaction_id,
+                              recurring_payment_id,
+                              fdx_api_actor_type: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/recurring-payments/{recurringPaymentId}',
+                                     Server::MONEYMOVEMENT)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .template_param(new_parameter(recurring_payment_id, key: 'recurringPaymentId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(RecurringPaymentEntity.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('404',
+                                 'A recurring payment with provided ID was not found',
+                                 ErrorException)
+                    .local_error('500',
+                                 'Catch-all exception where request was not processed due to an'\
+                                  ' internal outage/issue. Consider other more specific errors'\
+                                  ' before using this error',
+                                 ErrorException)
+                    .local_error('501',
+                                 'Error when FdxVersion in Header is not one of those'\
+                                  ' implemented at backend',
+                                 ErrorException)
+                    .local_error('503',
+                                 'System is down for maintenance',
+                                 ErrorException))
+        .execute
+    end
+
+    # Update a recurring payment
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [String] recurring_payment_id Required parameter: Recurring Payment
+    # Identifier. Uniquely identifies a recurring payment
+    # @param [String] idempotency_key Required parameter: Used to de-duplicate
+    # requests
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @param [RecurringPaymentForUpdateEntity2] body Optional parameter: TODO:
+    # type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_recurring_payment(x_fapi_interaction_id,
+                                 recurring_payment_id,
+                                 idempotency_key,
+                                 fdx_api_actor_type: nil,
+                                 body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/recurring-payments/{recurringPaymentId}',
+                                     Server::MONEYMOVEMENT)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .template_param(new_parameter(recurring_payment_id, key: 'recurringPaymentId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(idempotency_key, key: 'idempotency-key')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(RecurringPaymentEntity.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Request is invalid',
+                                 ErrorException)
+                    .local_error('404',
+                                 'Requested recurring payment change is invalid',
+                                 ErrorException)
+                    .local_error('409',
+                                 'Duplicate Request',
+                                 RecurringPaymentEntityErrorException)
+                    .local_error('422',
+                                 'Account type not supported',
+                                 ErrorException)
+                    .local_error('500',
+                                 'Catch-all exception where request was not processed due to an'\
+                                  ' internal outage/issue. Consider other more specific errors'\
+                                  ' before using this error',
+                                 ErrorException)
+                    .local_error('501',
+                                 'Error when FdxVersion in Header is not one of those'\
+                                  ' implemented at backend',
+                                 ErrorException)
+                    .local_error('503',
+                                 'System is down for maintenance',
+                                 ErrorException))
+        .execute
+    end
+
+    # Cancel a recurring payment
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [String] recurring_payment_id Required parameter: Recurring Payment
+    # Identifier. Uniquely identifies a recurring payment
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def cancel_recurring_payment(x_fapi_interaction_id,
+                                 recurring_payment_id,
+                                 fdx_api_actor_type: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/recurring-payments/{recurringPaymentId}',
+                                     Server::MONEYMOVEMENT)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .template_param(new_parameter(recurring_payment_id, key: 'recurringPaymentId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(RecurringPaymentEntity.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Recurring payment cannot be modified or cancelled at this time'\
+                                  '. Likely due to the state that it is in',
+                                 ErrorException)
+                    .local_error('404',
+                                 'A recurring payment with provided ID was not found',
+                                 ErrorException)
+                    .local_error('500',
+                                 'Catch-all exception where request was not processed due to an'\
+                                  ' internal outage/issue. Consider other more specific errors'\
+                                  ' before using this error',
+                                 ErrorException)
+                    .local_error('501',
+                                 'Error when FdxVersion in Header is not one of those'\
+                                  ' implemented at backend',
+                                 ErrorException)
+                    .local_error('503',
+                                 'System is down for maintenance',
+                                 ErrorException))
+        .execute
+    end
+
+    # Search for payments associated with the recurring payment
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [String] recurring_payment_id Required parameter: Recurring Payment
+    # Identifier. Uniquely identifies a recurring payment
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @param [String] updated_since Optional parameter: Return items that have
+    # been created or updated since the nextUpdateId
+    # @param [String] offset Optional parameter: Opaque cursor used by the
+    # provider to send the next set of records
+    # @param [Integer] limit Optional parameter: Number of elements that the
+    # consumer wishes to receive. Providers should implement reasonable
+    # default/maximum/minimum values based on their internal architecture and
+    # update their documentation accordingly
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_payments_for_recurring_payment(x_fapi_interaction_id,
+                                           recurring_payment_id,
+                                           fdx_api_actor_type: nil,
+                                           updated_since: nil,
+                                           offset: nil,
+                                           limit: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/recurring-payments/{recurringPaymentId}/payments',
+                                     Server::MONEYMOVEMENT)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .template_param(new_parameter(recurring_payment_id, key: 'recurringPaymentId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .query_param(new_parameter(updated_since, key: 'updatedSince'))
+                   .query_param(new_parameter(offset, key: 'offset'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentsEntity.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('404',
+                                 'A recurring payment with provided ID was not found',
+                                 ErrorException)
+                    .local_error('500',
+                                 'Catch-all exception where request was not processed due to an'\
+                                  ' internal outage/issue. Consider other more specific errors'\
+                                  ' before using this error',
+                                 ErrorException)
+                    .local_error('501',
+                                 'Error when FdxVersion in Header is not one of those'\
+                                  ' implemented at backend',
+                                 ErrorException)
+                    .local_error('503',
+                                 'System is down for maintenance',
+                                 ErrorException))
+        .execute
+    end
+  end
+end

data/lib/fdx_api/controllers/resource_information_controller.rb

@@ -0,0 +1,121 @@
+# fdx_api
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module FdxApi
+  # ResourceInformationController
+  class ResourceInformationController < BaseController
+    # Retrieve all the resources
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @param [ResultType] result_type Optional parameter: Flag to indicate if
+    # you want a lightweight array of metadata (AccountDescriptor or Tax or
+    # Operations) or full item details (Account or a Tax subclass or
+    # Availability details). If set to 'lightweight', should only return the
+    # fields associated with the metadata entity. This field is not required,
+    # defaults to lightweight
+    # @param [String] offset Optional parameter: Opaque cursor used by the
+    # provider to send the next set of records
+    # @param [Integer] limit Optional parameter: Number of elements that the
+    # consumer wishes to receive. Providers should implement reasonable
+    # default/maximum/minimum values based on their internal architecture and
+    # update their documentation accordingly
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_resources(x_fapi_interaction_id,
+                      fdx_api_actor_type: nil,
+                      result_type: ResultType::LIGHTWEIGHT,
+                      offset: nil,
+                      limit: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/resources',
+                                     Server::RESOURCE)
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .query_param(new_parameter(result_type, key: 'resultType'))
+                   .query_param(new_parameter(offset, key: 'offset'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ResourceListEntity.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Input sent by client does not satisfy API specification',
+                                 ErrorException)
+                    .local_error('401',
+                                 'Request lacks valid authentication credentials for the target'\
+                                  ' resource',
+                                 ErrorException)
+                    .local_error('404',
+                                 'Data not found for request parameters',
+                                 ErrorException)
+                    .local_error('500',
+                                 'Catch-all exception where request was not processed due to an'\
+                                  ' internal outage/issue. Consider other more specific errors'\
+                                  ' before using this error',
+                                 ErrorException)
+                    .local_error('501',
+                                 'Error when FdxVersion in Header is not one of those'\
+                                  ' implemented at backend',
+                                 ErrorException)
+                    .local_error('503',
+                                 'System is down for maintenance',
+                                 ErrorException))
+        .execute
+    end
+
+    # Retrieve the details of the identified resource
+    # @param [String] resource_id Required parameter: Specific resourceId for
+    # which to retrieve details
+    # @param [UUID | String] x_fapi_interaction_id Required parameter: Unique
+    # identifier for this interaction
+    # @param [FdxApiActorType] fdx_api_actor_type Optional parameter: Identifies
+    # whether the customer is present (USER) or it is a BATCH operation
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_resource(resource_id,
+                     x_fapi_interaction_id,
+                     fdx_api_actor_type: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/resources/{resourceId}',
+                                     Server::RESOURCE)
+                   .template_param(new_parameter(resource_id, key: 'resourceId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_fapi_interaction_id, key: 'x-fapi-interaction-id')
+                                  .is_required(true))
+                   .header_param(new_parameter(fdx_api_actor_type, key: 'FDX-API-Actor-Type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearerAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ResourceEntity.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Required input data not sent',
+                                 ErrorException)
+                    .local_error('404',
+                                 'Resource with provided ID was not found',
+                                 ErrorException)
+                    .local_error('500',
+                                 'Catch-all exception where request was not processed due to an'\
+                                  ' internal outage/issue. Consider other more specific errors'\
+                                  ' before using this error',
+                                 ErrorException)
+                    .local_error('501',
+                                 'Error when FdxVersion in Header is not one of those'\
+                                  ' implemented at backend',
+                                 ErrorException)
+                    .local_error('503',
+                                 'System is down for maintenance',
+                                 ErrorException))
+        .execute
+    end
+  end
+end