pq-api-matic-sdk 1.0.0

data/lib/pay_quicker_sdk/controllers/transfers_controller.rb

@@ -0,0 +1,259 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # TransfersController
+  class TransfersController < BaseController
+    # Retrieve a list of [transfers](page:resources/transfers) that supports
+    # filtering, sorting, and pagination through existing mechanisms.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [TransferListResult] Response from the API call.
+    def list_transfers(page,
+                       page_size,
+                       filter: nil,
+                       sort: nil,
+                       language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transfers',
+                                     Server::API)
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Create a new [transfer](page:resources/transfers) quote.
+    # @param [GatewayTransferQuote | PortalTransferQuote | nil] body Optional
+    # parameter: TODO: type description here
+    # @return [TransferResult] Response from the API call.
+    def create_transfer_quote(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transfers',
+                                     Server::API)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .validator(proc do |value|
+                                  UnionTypeLookUp.get(:TransferQuote)
+                                                 .validate(value)
+                                end))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(APIHelper.method(:json_serialize))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve details of a specific [transfer](page:resources/transfers)
+    # represented by a transfer token.
+    # @param [String] transfer_token Required parameter: Auto-generated unique
+    # identifier representing an individual transfer transaction, prefixed with
+    # `xfer-`.
+    # @return [TransferResult] Response from the API call.
+    def retrieve_transfer(transfer_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transfers/{transfer-token}',
+                                     Server::API)
+                   .template_param(new_parameter(transfer_token, key: 'transfer-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Accept a [transfer](page:resources/transfers) quote.
+    # @param [String] transfer_token Required parameter: Auto-generated unique
+    # identifier representing an individual transfer transaction, prefixed with
+    # `xfer-`.
+    # @return [TransferResult] Response from the API call.
+    def accept_transfer_quote(transfer_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transfers/{transfer-token}',
+                                     Server::API)
+                   .template_param(new_parameter(transfer_token, key: 'transfer-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Optional [transfer](page:resources/transfers) quote cancellation that
+    # auto-cancels after a period organically expires or when account activity
+    # invalidates the quote.
+    # @param [String] transfer_token Required parameter: Auto-generated unique
+    # identifier representing an individual transfer transaction, prefixed with
+    # `xfer-`.
+    # @return [TransferResult] Response from the API call.
+    def cancel_transfer_quote(transfer_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/transfers/{transfer-token}',
+                                     Server::API)
+                   .template_param(new_parameter(transfer_token, key: 'transfer-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a list of user [transfers](page:resources/transfers) that
+    # supports filtering, sorting, and pagination through existing mechanisms.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [TransferListResult] Response from the API call.
+    def list_user_transfers(user_token,
+                            page,
+                            page_size,
+                            filter: nil,
+                            sort: nil,
+                            language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/transfers',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferListResult.method(:from_hash)))
+        .execute
+    end
+
+    # Retrieve a specific user bank [transfer](page:resources/transfers).
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] transfer_token Required parameter: Auto-generated unique
+    # identifier representing a transfer, prefixed with `xfer-`.
+    # @return [TransferResult] Response from the API call.
+    def retrieve_user_transfer(user_token,
+                               transfer_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/transfers/{transfer-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(transfer_token, key: 'transfer-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end

data/lib/pay_quicker_sdk/controllers/users_controller.rb

@@ -0,0 +1,151 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # UsersController
+  class UsersController < BaseController
+    # Retrieve a list of [users](page:resources/user) that supports filtering,
+    # sorting, and pagination through existing mechanisms.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [UserListResult] Response from the API call.
+    def list_users(page,
+                   page_size,
+                   filter: nil,
+                   sort: nil,
+                   language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users',
+                                     Server::API)
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UserListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Create a new [user](page:resources/user).
+    # @param [CreateOrUpdateUser] body Optional parameter: TODO: type
+    # description here
+    # @return [UserResult] Response from the API call.
+    def create_user(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/users',
+                                     Server::API)
+                   .header_param(new_parameter('application/json', key: 'Content-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('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UserResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Update a [user](page:resources/user) object (change
+    # [email](#/rest/models/structures/email-address)],
+    # [address](#/rest/models/structures/address) change, etc.) using a user
+    # token.'
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [CreateOrUpdateUser] body Optional parameter: TODO: type
+    # description here
+    # @return [UserResult] Response from the API call.
+    def update_user(user_token,
+                    body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/users/{user-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-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('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UserResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a single [user](page:resources/user) record by user token.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @return [UserResult] Response from the API call.
+    def retrieve_user(user_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UserResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end

data/lib/pay_quicker_sdk/controllers/webhooks_controller.rb

@@ -0,0 +1,173 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # WebhooksController
+  class WebhooksController < BaseController
+    # Retrieve a list of all [webhook subscriptions](page:resources/webhooks)
+    # that supports filtering, sorting, and pagination through existing
+    # mechanisms
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [WebhookSubscriptionListResult] Response from the API call.
+    def list_subscriptions(page,
+                           page_size,
+                           filter: nil,
+                           sort: nil,
+                           language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/webhooks',
+                                     Server::API)
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(WebhookSubscriptionListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Update a [webhook subscription](page:resources/webhooks).
+    # @param [CreateWebhookRequest] body Optional parameter: TODO: type
+    # description here
+    # @return [WebhookSubscriptionResult] Response from the API call.
+    def update_subscription(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/webhooks',
+                                     Server::API)
+                   .header_param(new_parameter('application/json', key: 'Content-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('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(WebhookSubscriptionResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Create a [webhook subscription](page:resources/webhooks).
+    # @param [CreateWebhookRequest] body Optional parameter: TODO: type
+    # description here
+    # @return [WebhookSubscriptionResult] Response from the API call.
+    def create_subscription(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/webhooks',
+                                     Server::API)
+                   .header_param(new_parameter('application/json', key: 'Content-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('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(WebhookSubscriptionResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a single [webhook subscription](page:resources/webhooks) using
+    # the webhook token.
+    # @param [String] webhook_token Required parameter: Auto-generated unique
+    # identifier representing a webhook subscription, prefixed with `webh-`.
+    # @return [WebhookSubscriptionResult] Response from the API call.
+    def retrieve_subscription(webhook_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/webhooks/{webhook-token}',
+                                     Server::API)
+                   .template_param(new_parameter(webhook_token, key: 'webhook-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(WebhookSubscriptionResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Delete a [webhook subscription](page:resources/webhooks).
+    # @param [String] webhook_token Required parameter: Auto-generated unique
+    # identifier representing a webhook subscription, prefixed with `webh-`.
+    # @return [WebhookSubscriptionResult] Response from the API call.
+    def delete_subscription(webhook_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/webhooks/{webhook-token}',
+                                     Server::API)
+                   .template_param(new_parameter(webhook_token, key: 'webhook-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(WebhookSubscriptionResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end

data/lib/pay_quicker_sdk/exceptions/api_error_result_exception.rb

@@ -0,0 +1,80 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # _ApiErrorResult class.
+  class ApiErrorResultException < APIException
+    SKIP = Object.new
+    private_constant :SKIP
+
+    # Error Severity
+    # @return [String]
+    attr_accessor :severity
+
+    # Error Code Name
+    # @return [String]
+    attr_accessor :error
+
+    # Error Code Number
+    # @return [Float]
+    attr_accessor :code
+
+    # Description of the error.
+    # @return [String]
+    attr_accessor :message
+
+    # Reference ID for issue tracking.
+    # @return [String]
+    attr_accessor :reference_id
+
+    # Timestamp of when the error occurred.
+    # @return [String]
+    attr_accessor :timestamp
+
+    # Request reference for issue tracking.
+    # @return [String]
+    attr_accessor :request_ref
+
+    # The constructor.
+    # @param [String] reason The reason for raising an exception.
+    # @param [HttpResponse] response The HttpReponse of the API call.
+    def initialize(reason, response)
+      super(reason, response)
+      hash = APIHelper.json_deserialize(@response.raw_body)
+      unbox(hash)
+    end
+
+    # Populates this object by extracting properties from a hash.
+    # @param [Hash] hash The deserialized response sent by the server in the
+    # response body.
+    def unbox(hash)
+      return nil unless hash
+
+      @severity = hash.key?('severity') ? hash['severity'] : nil
+      @error = hash.key?('error') ? hash['error'] : nil
+      @code = hash.key?('code') ? hash['code'] : nil
+      @message = hash.key?('message') ? hash['message'] : nil
+      @reference_id = hash.key?('referenceId') ? hash['referenceId'] : nil
+      @timestamp = hash.key?('timestamp') ? hash['timestamp'] : nil
+      @request_ref = hash.key?('requestRef') ? hash['requestRef'] : SKIP
+    end
+
+    # Provides a human-readable string representation of the object.
+    def to_s
+      class_name = self.class.name.split('::').last
+      "<#{class_name} severity: #{@severity}, error: #{@error}, code: #{@code}, message:"\
+      " #{@message}, reference_id: #{@reference_id}, timestamp: #{@timestamp}, request_ref:"\
+      " #{@request_ref}>"
+    end
+
+    # Provides a debugging-friendly string with detailed object information.
+    def inspect
+      class_name = self.class.name.split('::').last
+      "<#{class_name} severity: #{@severity.inspect}, error: #{@error.inspect}, code:"\
+      " #{@code.inspect}, message: #{@message.inspect}, reference_id: #{@reference_id.inspect},"\
+      " timestamp: #{@timestamp.inspect}, request_ref: #{@request_ref.inspect}>"
+    end
+  end
+end