@mojaloop/api-snippets 17.6.0-snapshot.2 → 17.6.0

package/lib/sdk-scheme-adapter/v2_1_0/outbound/openapi.d.ts

@@ -4,27 +4,64 @@
  */
 export interface paths {
     "/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         /**
          * Health check endpoint
          * @description This endpoint allows a user of the SDK scheme adapter to check the outbound transfers service is listening.
          */
         get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
             responses: {
                 /** @description Returns empty body if the scheme adapter outbound transfers service is running. */
                 200: {
-                    content: never;
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
                 };
             };
         };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/accounts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Create accounts on the Account Lookup Service
          * @description The HTTP request `POST /accounts` is used to create account information on the Account Lookup Service (ALS) regarding the provided list of identities.
          *
-         * Caller DFSP is used as the account source FSP information
+         *     Caller DFSP is used as the account source FSP information
          */
         post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
             /** @description Identities list request body */
             requestBody: {
                 content: {
@@ -38,13 +75,33 @@ export interface paths {
                 504: components["responses"]["accountsCreationTimeout"];
             };
         };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/bulkQuotes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Request bulk quotes for the provided financial transactions
          * @description The HTTP request `POST /bulkQuotes` is used to request a bulk quote to fascilitate funds transfer from payer DFSP to payees' DFSP.
+         *
          */
         post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
             /** @description Bulk quote request body */
             requestBody: {
                 content: {
@@ -58,40 +115,84 @@ export interface paths {
                 504: components["responses"]["bulkQuoteTimeout"];
             };
         };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/bulkQuotes/{bulkQuoteId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         /**
          * Retrieves information for a specific bulk quote
          * @description The HTTP request `GET /bulkQuotes/{bulktQuoteId}` is used to get information regarding a bulk quote created or requested earlier. The `{bulkQuoteId}` in the URI should contain the `bulkQuoteId` that was used for the creation of the bulk quote.
          */
         get: {
             parameters: {
+                query?: never;
+                header?: never;
                 path: {
+                    /** @description Identifier of the bulk transfer to continue as returned in the response to a `POST /bulkTransfers` request. */
                     bulkQuoteId: components["parameters"]["bulkQuoteId"];
                 };
+                cookie?: never;
             };
+            requestBody?: never;
             responses: {
                 /** @description Bulk quote information successfully retrieved */
                 200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
                     content: {
                         "application/json": components["schemas"]["bulkQuoteStatusResponse"];
                     };
                 };
                 /** @description An error occurred processing the bulk quote */
                 500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
                     content: {
                         "application/json": components["schemas"]["errorResponse"];
                     };
                 };
             };
         };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/bulkTransactions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Sends money from one account to multiple accounts
          * @description The HTTP request `POST /bulkTransactions` is used to request the movement of funds from payer DFSP to payees' DFSP.
+         *
          */
         post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
             /** @description Bulk transfer request body */
             requestBody: {
                 content: {
@@ -104,17 +205,33 @@ export interface paths {
                 500: components["responses"]["errorResponse"];
             };
         };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/bulkTransactions/{bulkTransactionId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Amends the bulk transaction request
          * @description The HTTP request `PUT /bulkTransactions/{bulkTransactionId}` is used to amend information regarding a bulk transaction, i.e. when autoAcceptParty or autoAcceptQuote  is false then the payer need to provide confirmation to proceed with further processing of the request. The `{bulkTransactionId}` in the URI should contain the `bulkTransactionId` that was used for the creation of the bulk transfer.
          */
         put: {
             parameters: {
+                query?: never;
+                header?: never;
                 path: {
+                    /** @description Identifier of the bulk transaction to continue as returned in the response to a `POST /bulkTransaction` request. */
                     bulkTransactionId: components["parameters"]["bulkTransactionId"];
                 };
+                cookie?: never;
             };
             /** @description Bulk transaction request body */
             requestBody: {
@@ -125,24 +242,51 @@ export interface paths {
             responses: {
                 /** @description Bulk transaction information successfully amended */
                 202: {
-                    content: never;
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
                 };
                 400: components["responses"]["bulkTransactionPutBadRequest"];
                 /** @description An error occurred processing the bulk transaction */
                 500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
                     content: {
                         "application/json": components["schemas"]["errorResponse"];
                     };
                 };
             };
         };
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/bulkTransfers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Sends money from one account to multiple accounts
          * @description The HTTP request `POST /bulkTransfers` is used to request the movement of funds from payer DFSP to payees' DFSP.
+         *
          */
         post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
             /** @description Bulk transfer request body */
             requestBody: {
                 content: {
@@ -155,78 +299,160 @@ export interface paths {
                 500: components["responses"]["errorResponse"];
             };
         };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/bulkTransfers/{bulkTransferId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         /**
          * Retrieves information for a specific bulk transfer
          * @description The HTTP request `GET /bulkTransfers/{bulkTransferId}` is used to get information regarding a bulk transfer created or requested earlier. The `{bulkTransferId}` in the URI should contain the `bulkTransferId` that was used for the creation of the bulk transfer.
          */
         get: {
             parameters: {
+                query?: never;
+                header?: never;
                 path: {
+                    /** @description Identifier of the bulk transfer to continue as returned in the response to a `POST /bulkTransfers` request. */
                     bulkTransferId: components["parameters"]["bulkTransferId"];
                 };
+                cookie?: never;
             };
+            requestBody?: never;
             responses: {
                 /** @description Bulk transfer information successfully retrieved */
                 200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
                     content: {
                         "application/json": components["schemas"]["bulkTransferStatusResponse"];
                     };
                 };
                 /** @description An error occurred processing the bulk transfer */
                 500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
                     content: {
                         "application/json": components["schemas"]["errorResponse"];
                     };
                 };
             };
         };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/parties/{Type}/{ID}": {
-        /**
-         * PartiesByTypeAndID
-         * @description The HTTP request GET /parties// (or GET /parties///) is used to lookup information regarding the requested Party, defined by ,  and optionally (for example, GET /parties/MSISDN/123456789, or GET /parties/BUSINESS/shoecompany/employee1).
-         */
-        get: operations["PartiesByTypeAndID"];
         parameters: {
+            query?: never;
+            header?: never;
             path: {
+                /** @description The type of the party identifier. For example, `MSISDN`, `PERSONAL_ID`. */
                 Type: components["parameters"]["Type"];
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
-    };
-    "/parties/{Type}/{ID}/{SubId}": {
         /**
-         * PartiesSubIdByTypeAndID
+         * PartiesByTypeAndID
          * @description The HTTP request GET /parties// (or GET /parties///) is used to lookup information regarding the requested Party, defined by ,  and optionally (for example, GET /parties/MSISDN/123456789, or GET /parties/BUSINESS/shoecompany/employee1).
          */
-        get: operations["PartiesSubIdByTypeAndID"];
+        get: operations["PartiesByTypeAndID"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/parties/{Type}/{ID}/{SubId}": {
         parameters: {
+            query?: never;
+            header?: never;
             path: {
+                /** @description The type of the party identifier. For example, `MSISDN`, `PERSONAL_ID`. */
                 Type: components["parameters"]["Type"];
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
+                /** @description A sub-identifier of the party identifier, or a sub-type of the party identifier's type. For example, `PASSPORT`, `DRIVING_LICENSE`. */
                 SubId: components["parameters"]["SubId"];
             };
+            cookie?: never;
         };
+        /**
+         * PartiesSubIdByTypeAndID
+         * @description The HTTP request GET /parties// (or GET /parties///) is used to lookup information regarding the requested Party, defined by ,  and optionally (for example, GET /parties/MSISDN/123456789, or GET /parties/BUSINESS/shoecompany/employee1).
+         */
+        get: operations["PartiesSubIdByTypeAndID"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/quotes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Quotes endpoint
          * @description is used to request quotes from other DFSP
          */
         post: operations["QuotesPost"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/requestToPay": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Receiver requesting funds from Sender
          * @description The HTTP request `POST /requestToPay` is used to support Pull Funds pattern where in a receiver can request for funds from the Sender.
-         * The underlying API has two stages:
+         *     The underlying API has two stages:
+         *
+         *       1. Party lookup. This facilitates a check by the sending party that the destination party is correct before proceeding with a money movement.
+         *       2. Transaction Request. This request enables a Payee to request Payer to send electronic funds to the Payee.
          *
-         *   1. Party lookup. This facilitates a check by the sending party that the destination party is correct before proceeding with a money movement.
-         *   2. Transaction Request. This request enables a Payee to request Payer to send electronic funds to the Payee.
          */
         post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
             /** @description RequestToPay request body */
             requestBody: {
                 content: {
@@ -237,19 +463,36 @@ export interface paths {
                 200: components["responses"]["requestToPaySuccess"];
             };
         };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/requestToPay/{transactionRequestId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Continues a request funds from sender that has paused at the party resolution stage in order to accept or reject party information
          * @description The HTTP request `PUT /requestToPay/{transactionRequestId}` is used to continue a transfer initiated via the `POST /requestToPay` method that has halted after party lookup stage.
-         * The request body should contain the "acceptParty" property set to `true` as required to continue the transfer.
-         * See the description of the `POST /requestToPay` HTTP method for more information on modes of transfer.
+         *     The request body should contain the "acceptParty" property set to `true` as required to continue the transfer.
+         *     See the description of the `POST /requestToPay` HTTP method for more information on modes of transfer.
+         *
          */
         put: {
             parameters: {
+                query?: never;
+                header?: never;
                 path: {
+                    /** @description Identifier of the merchant request to pay to continue as returned in the response to a `POST /requestToPay` request. */
                     transactionRequestId: components["parameters"]["transactionRequestId"];
                 };
+                cookie?: never;
             };
             requestBody?: {
                 content: {
@@ -262,31 +505,52 @@ export interface paths {
                 504: components["responses"]["transferTimeout"];
             };
         };
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/requestToPayTransfer": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Used to trigger funds from customer fsp account to merchant fsp account. This is a follow-up request to requestToPay.
          * @description The HTTP request `POST /requestToPayTransfer` is used to request the movement of funds from payer DFSP to payee DFSP.
-         * The underlying Mojaloop API has three stages for money transfer:
+         *     The underlying Mojaloop API has three stages for money transfer:
          *
-         *   1. Quotation. This facilitates the exchange of fee information and the construction of a cryptographic "contract" between payee and payer DFSPs before funds are transferred.
-         *   2. Authorization. This facilitates getting OTP from payee DFSP.
-         *   3. Transfer. The enactment of the previously agreed "contract"
+         *       1. Quotation. This facilitates the exchange of fee information and the construction of a cryptographic "contract" between payee and payer DFSPs before funds are transferred.
+         *       2. Authorization. This facilitates getting OTP from payee DFSP.
+         *       3. Transfer. The enactment of the previously agreed "contract"
          *
-         * This method has several modes of operation.
-         * - If the configuration variable `AUTO_ACCEPT_QUOTES` is set to `"false"` this method will terminate and return the quotation when it has been received from the payee DFSP.
-         *   If the payee wished to proceed with the otp, then a subsequent `PUT /transfers/{transferId}` request (accepting the quote) is required to continue the operation.
-         *   The scheme adapter will then proceed with the transfer state.
+         *     This method has several modes of operation.
+         *     - If the configuration variable `AUTO_ACCEPT_QUOTES` is set to `"false"` this method will terminate and return the quotation when it has been received from the payee DFSP.
+         *       If the payee wished to proceed with the otp, then a subsequent `PUT /transfers/{transferId}` request (accepting the quote) is required to continue the operation.
+         *       The scheme adapter will then proceed with the transfer state.
          *
-         * - If the configuration variable `AUTO_ACCEPT_OTP` is set to `"false"` this method will terminate and return the otp when it has been received from the payee DFSP.
-         *   If the payer wished to proceed with the transfer, then a subsequent `PUT /transfers/{transferId}` request (accepting the quote) is required to continue the operation.
-         *   The scheme adapter will then proceed with the transfer state.
+         *     - If the configuration variable `AUTO_ACCEPT_OTP` is set to `"false"` this method will terminate and return the otp when it has been received from the payee DFSP.
+         *       If the payer wished to proceed with the transfer, then a subsequent `PUT /transfers/{transferId}` request (accepting the quote) is required to continue the operation.
+         *       The scheme adapter will then proceed with the transfer state.
          *
-         * If the configuration variables `AUTO_ACCEPT_PARTIES` and `AUTO_ACCEPT_QUOTES` are both set to `"true"` this method will block until all three transfer stages are complete. Upon completion it will return the entire set of transfer details received during the operation.
+         *     If the configuration variables `AUTO_ACCEPT_PARTIES` and `AUTO_ACCEPT_QUOTES` are both set to `"true"` this method will block until all three transfer stages are complete. Upon completion it will return the entire set of transfer details received during the operation.
+         *
+         *     Combinations of settings for `AUTO_ACCEPT...` configuration variables allow the scheme adapter user to decide which mode of operation best suits their use cases. i.e. the scheme adapter can be configured to "break" the three stage transfer at these points in order to execute backend logic such as party verification, quoted fees assessments etc...
          *
-         * Combinations of settings for `AUTO_ACCEPT...` configuration variables allow the scheme adapter user to decide which mode of operation best suits their use cases. i.e. the scheme adapter can be configured to "break" the three stage transfer at these points in order to execute backend logic such as party verification, quoted fees assessments etc...
          */
         post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
             /** @description Request To Pay Transfer request body */
             requestBody: {
                 content: {
@@ -300,21 +564,38 @@ export interface paths {
                 504: components["responses"]["transferTimeout"];
             };
         };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/requestToPayTransfer/{transactionRequestId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Continues a transfer that has paused at the otp stage in order to accept or reject quote
          * @description This request is used to continue a requestToPayTransfer initiated via the `POST /requestToPayTransfer` method that has halted after quotation stage and/or otp stage.
          *
-         * The request body should contain either the "acceptOTP" or "acceptQuote" property set to `true` as required to continue the transfer.
+         *     The request body should contain either the "acceptOTP" or "acceptQuote" property set to `true` as required to continue the transfer.
+         *
+         *     See the description of the `POST /requestToPayTransfer` HTTP method for more information on modes of transfer.
          *
-         * See the description of the `POST /requestToPayTransfer` HTTP method for more information on modes of transfer.
          */
         put: {
             parameters: {
+                query?: never;
+                header?: never;
                 path: {
+                    /** @description Identifier of the merchant request to pay to continue as returned in the response to a `POST /requestToPay` request. */
                     transactionRequestId: components["parameters"]["transactionRequestId"];
                 };
+                cookie?: never;
             };
             requestBody?: {
                 content: {
@@ -327,38 +608,72 @@ export interface paths {
                 504: components["responses"]["transferTimeout"];
             };
         };
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/simpleTransfers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Simple Transfers endpoint
          * @description is used to request a transfer
          */
         post: operations["SimpleTransfersPost"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/transfers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Sends money from one account to another
          * @description The HTTP request `POST /transfers` is used to request the movement of funds from payer DFSP to payee DFSP.
-         * The underlying Mojaloop API has three stages for money transfer:
+         *     The underlying Mojaloop API has three stages for money transfer:
+         *
+         *       1. Party lookup. This facilitates a check by the sending party that the destination party is correct before proceeding with a money movement.
+         *       2. Quotation. This facilitates the exchange of fee information and the construction of a cryptographic "contract" between payee and payer DFSPs before funds are transferred.
+         *       3. Transfer. The enactment of the previously agreed "contract"
          *
-         *   1. Party lookup. This facilitates a check by the sending party that the destination party is correct before proceeding with a money movement.
-         *   2. Quotation. This facilitates the exchange of fee information and the construction of a cryptographic "contract" between payee and payer DFSPs before funds are transferred.
-         *   3. Transfer. The enactment of the previously agreed "contract"
+         *     This method has several modes of operation.
+         *     - If the configuration variables `AUTO_ACCEPT_PARTIES` is set to `"false"` this method will terminate when the payee party has been resolved and return the payee party details.
+         *       If the payee wishes to proceed with the transfer, then a subsequent `PUT /transfers/{transferId}` request (accepting the payee party) is required to continue the operation.
+         *       The scheme adapter will then proceed with quotation stage...
          *
-         * This method has several modes of operation.
-         * - If the configuration variables `AUTO_ACCEPT_PARTIES` is set to `"false"` this method will terminate when the payee party has been resolved and return the payee party details.
-         *   If the payee wishes to proceed with the transfer, then a subsequent `PUT /transfers/{transferId}` request (accepting the payee party) is required to continue the operation.
-         *   The scheme adapter will then proceed with quotation stage...
+         *     - If the configuration variable `AUTO_ACCEPT_QUOTES` is set to `"false"` this method will terminate and return the quotation when it has been received from the payee DFSP.
+         *       If the payee wished to proceed with the transfer, then a subsequent `PUT /transfers/{transferId}` request (accepting the quote) is required to continue the operation.
+         *       The scheme adapter will then proceed with the transfer state.
          *
-         * - If the configuration variable `AUTO_ACCEPT_QUOTES` is set to `"false"` this method will terminate and return the quotation when it has been received from the payee DFSP.
-         *   If the payee wished to proceed with the transfer, then a subsequent `PUT /transfers/{transferId}` request (accepting the quote) is required to continue the operation.
-         *   The scheme adapter will then proceed with the transfer state.
+         *     If the configuration variables `AUTO_ACCEPT_PARTIES` and `AUTO_ACCEPT_QUOTES` are both set to `"true"` this method will block until all three transfer stages are complete. Upon completion it will return the entire set of transfer details received during the operation.
          *
-         * If the configuration variables `AUTO_ACCEPT_PARTIES` and `AUTO_ACCEPT_QUOTES` are both set to `"true"` this method will block until all three transfer stages are complete. Upon completion it will return the entire set of transfer details received during the operation.
+         *     Combinations of settings for `AUTO_ACCEPT...` configuration variables allow the scheme adapter user to decide which mode of operation best suits their use cases. i.e. the scheme adapter can be configured to "break" the three stage transfer at these points in order to execute backend logic such as party verification, quoted fees assessments etc...
          *
-         * Combinations of settings for `AUTO_ACCEPT...` configuration variables allow the scheme adapter user to decide which mode of operation best suits their use cases. i.e. the scheme adapter can be configured to "break" the three stage transfer at these points in order to execute backend logic such as party verification, quoted fees assessments etc...
          */
         post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
             /** @description Transfer request body */
             requestBody: {
                 content: {
@@ -372,27 +687,49 @@ export interface paths {
                 504: components["responses"]["transferTimeout"];
             };
         };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/transfers/{transferId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         /**
          * Retrieves information for a specific transfer
          * @description The HTTP request `GET /transfers/{transferId}` is used to get information regarding a transfer created or requested earlier. The `{transferId}` in the URI should contain the `transferId` that was used for the creation of the transfer.
          */
         get: {
             parameters: {
+                query?: never;
+                header?: never;
                 path: {
+                    /** @description Identifier of the transfer to continue as returned in the response to a `POST /transfers` request. */
                     transferId: components["parameters"]["transferId"];
                 };
+                cookie?: never;
             };
+            requestBody?: never;
             responses: {
                 /** @description Transfer information successfully retrieved */
                 200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
                     content: {
                         "application/json": components["schemas"]["transferStatusResponse"];
                     };
                 };
                 /** @description An error occurred processing the transfer */
                 500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
                     content: {
                         "application/json": components["schemas"]["errorResponse"];
                     };
@@ -403,15 +740,20 @@ export interface paths {
          * Continues a transfer that has paused at the quote stage in order to accept or reject payee party and/or quote and/or conversion
          * @description The HTTP request `PUT /transfers/{transferId}` is used to continue a transfer initiated via the `POST /transfers` method that has halted after party lookup and/or quotation stage and/or currency conversion stage.
          *
-         * The request body should contain either the "acceptParty" or "acceptQuote" or "acceptConversion" property set to `true` as required to continue the transfer.
+         *     The request body should contain either the "acceptParty" or "acceptQuote" or "acceptConversion" property set to `true` as required to continue the transfer.
+         *
+         *     See the description of the `POST /transfers` HTTP method for more information on modes of transfer.
          *
-         * See the description of the `POST /transfers` HTTP method for more information on modes of transfer.
          */
         put: {
             parameters: {
+                query?: never;
+                header?: never;
                 path: {
+                    /** @description Identifier of the transfer to continue as returned in the response to a `POST /transfers` request. */
                     transferId: components["parameters"]["transferId"];
                 };
+                cookie?: never;
             };
             requestBody?: {
                 content: {
@@ -424,34 +766,92 @@ export interface paths {
                 504: components["responses"]["transferTimeout"];
             };
         };
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/services/FXP": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         /**
          * Obtain a list of the DFSPs in the scheme who provide FXP service
          * @description The HTTP request `GET /services/FXP` is used to request information about the participants in a scheme who offer currency conversion services.
          */
         get: operations["ServicesFXPGet"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/services/FXP/{SourceCurrency}/{TargetCurrency}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         /**
          * Obtain a list of the DFSPs in the scheme who provide FXP service
          * @description The HTTP request `GET /services/FXP/{SourceCurrency}/{TargetCurrency}` is used to request information about the participants in a scheme who offer currency conversion services in a particular currency corridor. The required corridor is specified by giving the ISO 4217 currency code for the SourceCurrency and the TargetCurrency.
          */
         get: operations["ServicesFXPSourceCurrencyTargetCurrencyGet"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/fxQuotes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Calculate FX quote
          * @description The HTTP request `POST /fxQuotes` is used to ask to provide a quotation for a currency conversion.
          */
         post: operations["FxQuotesPost"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/fxTransfers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Perform FX transfer
          * @description The HTTP request `POST /fxTransfers` is used to ask to confirm the execution of an agreed currency conversion.
          */
         post: operations["FxTransfersPost"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
 }
 export type webhooks = Record<string, never>;
@@ -460,14 +860,14 @@ export interface components {
         /**
          * PartyIdType
          * @description Below are the allowed values for the enumeration.
-         * - MSISDN - An MSISDN (Mobile Station International Subscriber Directory Number, that is, the phone number) is used as reference to a participant. The MSISDN identifier should be in international format according to the [ITU-T E.164 standard](https://www.itu.int/rec/T-REC-E.164/en). Optionally, the MSISDN may be prefixed by a single plus sign, indicating the international prefix.
-         * - EMAIL - An email is used as reference to a participant. The format of the email should be according to the informational [RFC 3696](https://tools.ietf.org/html/rfc3696).
-         * - PERSONAL_ID - A personal identifier is used as reference to a participant. Examples of personal identification are passport number, birth certificate number, and national registration number. The identifier number is added in the PartyIdentifier element. The personal identifier type is added in the PartySubIdOrType element.
-         * - BUSINESS - A specific Business (for example, an organization or a company) is used as reference to a participant. The BUSINESS identifier can be in any format. To make a transaction connected to a specific username or bill number in a Business, the PartySubIdOrType element should be used.
-         * - DEVICE - A specific device (for example, a POS or ATM) ID connected to a specific business or organization is used as reference to a Party. For referencing a specific device under a specific business or organization, use the PartySubIdOrType element.
-         * - ACCOUNT_ID - A bank account number or FSP account ID should be used as reference to a participant. The ACCOUNT_ID identifier can be in any format, as formats can greatly differ depending on country and FSP.
-         * - IBAN - A bank account number or FSP account ID is used as reference to a participant. The IBAN identifier can consist of up to 34 alphanumeric characters and should be entered without whitespace.
-         * - ALIAS An alias is used as reference to a participant. The alias should be created in the FSP as an alternative reference to an account owner. Another example of an alias is a username in the FSP system. The ALIAS identifier can be in any format. It is also possible to use the PartySubIdOrType element for identifying an account under an Alias defined by the PartyIdentifier.
+         *     - MSISDN - An MSISDN (Mobile Station International Subscriber Directory Number, that is, the phone number) is used as reference to a participant. The MSISDN identifier should be in international format according to the [ITU-T E.164 standard](https://www.itu.int/rec/T-REC-E.164/en). Optionally, the MSISDN may be prefixed by a single plus sign, indicating the international prefix.
+         *     - EMAIL - An email is used as reference to a participant. The format of the email should be according to the informational [RFC 3696](https://tools.ietf.org/html/rfc3696).
+         *     - PERSONAL_ID - A personal identifier is used as reference to a participant. Examples of personal identification are passport number, birth certificate number, and national registration number. The identifier number is added in the PartyIdentifier element. The personal identifier type is added in the PartySubIdOrType element.
+         *     - BUSINESS - A specific Business (for example, an organization or a company) is used as reference to a participant. The BUSINESS identifier can be in any format. To make a transaction connected to a specific username or bill number in a Business, the PartySubIdOrType element should be used.
+         *     - DEVICE - A specific device (for example, a POS or ATM) ID connected to a specific business or organization is used as reference to a Party. For referencing a specific device under a specific business or organization, use the PartySubIdOrType element.
+         *     - ACCOUNT_ID - A bank account number or FSP account ID should be used as reference to a participant. The ACCOUNT_ID identifier can be in any format, as formats can greatly differ depending on country and FSP.
+         *     - IBAN - A bank account number or FSP account ID is used as reference to a participant. The IBAN identifier can consist of up to 34 alphanumeric characters and should be entered without whitespace.
+         *     - ALIAS An alias is used as reference to a participant. The alias should be created in the FSP as an alternative reference to an account owner. Another example of an alias is a username in the FSP system. The ALIAS identifier can be in any format. It is also possible to use the PartySubIdOrType element for identifying an account under an Alias defined by the PartyIdentifier.
          * @enum {string}
          */
         PartyIdType: "MSISDN" | "EMAIL" | "PERSONAL_ID" | "BUSINESS" | "DEVICE" | "ACCOUNT_ID" | "IBAN" | "ALIAS";
@@ -501,10 +901,9 @@ export interface components {
          */
         CorrelationId: string;
         errorResponse: {
-            /**
-             * @description Backend error code from FSP. Ideally, statusCode is FSPIOP conforming. SDK will use status code to retrieve an FSPIOP error with the same code.
-             * Otherwise, a suitable generic FSPIOP will be used with the errorResponse in the FSPIOP error message.
-             */
+            /** @description Backend error code from FSP. Ideally, statusCode is FSPIOP conforming. SDK will use status code to retrieve an FSPIOP error with the same code.
+             *     Otherwise, a suitable generic FSPIOP will be used with the errorResponse in the FSPIOP error message.
+             *      */
             statusCode?: string;
             /** @description Error message text. */
             message?: string;
@@ -589,10 +988,10 @@ export interface components {
         /**
          * TransactionInitiatorType
          * @description Below are the allowed values for the enumeration.
-         * - CONSUMER - Consumer is the initiator of the transaction.
-         * - AGENT - Agent is the initiator of the transaction.
-         * - BUSINESS - Business is the initiator of the transaction.
-         * - DEVICE - Device is the initiator of the transaction.
+         *     - CONSUMER - Consumer is the initiator of the transaction.
+         *     - AGENT - Agent is the initiator of the transaction.
+         *     - BUSINESS - Business is the initiator of the transaction.
+         *     - DEVICE - Device is the initiator of the transaction.
          * @example CONSUMER
          * @enum {string}
          */
@@ -601,9 +1000,9 @@ export interface components {
          * Name
          * @description The API data type Name is a JSON String, restricted by a regular expression to avoid characters which are generally not used in a name.
          *
-         * Regular Expression - The regular expression for restricting the Name type is "^(?!\s*$)[\w .,'-]{1,128}$". The restriction does not allow a string consisting of whitespace only, all Unicode characters are allowed, as well as the period (.) (apostrophe (‘), dash (-), comma (,) and space characters ( ).
+         *     Regular Expression - The regular expression for restricting the Name type is "^(?!\s*$)[\w .,'-]{1,128}$". The restriction does not allow a string consisting of whitespace only, all Unicode characters are allowed, as well as the period (.) (apostrophe (‘), dash (-), comma (,) and space characters ( ).
          *
-         * **Note:** In some programming languages, Unicode support must be specifically enabled. For example, if Java is used, the flag UNICODE_CHARACTER_CLASS must be enabled to allow Unicode characters.
+         *     **Note:** In some programming languages, Unicode support must be specifically enabled. For example, if Java is used, the flag UNICODE_CHARACTER_CLASS must be enabled to allow Unicode characters.
          */
         Name: string;
         /**
@@ -644,32 +1043,32 @@ export interface components {
          * KYCInformation
          * @description KYC information for the party in a form mandated by an individual scheme.
          * @example {
-         *     "metadata": {
-         *         "format": "JSON",
-         *         "version": "1.0",
-         *         "description": "Data containing KYC Information"
-         *     },
-         *     "data": {
-         *         "name": "John Doe",
-         *         "dob": "1980-05-15",
-         *         "gender": "Male",
-         *         "address": "123 Main Street, Anytown, USA",
-         *         "email": "johndoe@example.com",
-         *         "phone": "+1 555-123-4567",
-         *         "nationality": "US",
-         *         "passport_number": "AB1234567",
-         *         "issue_date": "2010-02-20",
-         *         "expiry_date": "2025-02-20",
-         *         "bank_account_number": "1234567890",
-         *         "bank_name": "Example Bank",
-         *         "employer": "ABC Company",
-         *         "occupation": "Software Engineer",
-         *         "income": "$80,000 per year",
-         *         "marital_status": "Single",
-         *         "dependents": 0,
-         *         "risk_level": "Low"
+         *         "metadata": {
+         *             "format": "JSON",
+         *             "version": "1.0",
+         *             "description": "Data containing KYC Information"
+         *         },
+         *         "data": {
+         *             "name": "John Doe",
+         *             "dob": "1980-05-15",
+         *             "gender": "Male",
+         *             "address": "123 Main Street, Anytown, USA",
+         *             "email": "johndoe@example.com",
+         *             "phone": "+1 555-123-4567",
+         *             "nationality": "US",
+         *             "passport_number": "AB1234567",
+         *             "issue_date": "2010-02-20",
+         *             "expiry_date": "2025-02-20",
+         *             "bank_account_number": "1234567890",
+         *             "bank_name": "Example Bank",
+         *             "employer": "ABC Company",
+         *             "occupation": "Software Engineer",
+         *             "income": "$80,000 per year",
+         *             "marital_status": "Single",
+         *             "dependents": 0,
+         *             "risk_level": "Low"
+         *         }
          *     }
-         * }
          */
         KYCInformation: string;
         extensionListEmptiable: components["schemas"]["Extension"][];
@@ -693,8 +1092,8 @@ export interface components {
         /**
          * AmountType
          * @description Below are the allowed values for the enumeration AmountType.
-         * - SEND - Amount the Payer would like to send, that is, the amount that should be withdrawn from the Payer account including any fees.
-         * - RECEIVE - Amount the Payer would like the Payee to receive, that is, the amount that should be sent to the receiver exclusive of any fees.
+         *     - SEND - Amount the Payer would like to send, that is, the amount that should be withdrawn from the Payer account including any fees.
+         *     - RECEIVE - Amount the Payer would like the Payee to receive, that is, the amount that should be sent to the receiver exclusive of any fees.
          * @example RECEIVE
          * @enum {string}
          */
@@ -934,10 +1333,10 @@ export interface components {
         /**
          * TransferState
          * @description Below are the allowed values for the enumeration.
-         * - RECEIVED - Next ledger has received the transfer.
-         * - RESERVED - Next ledger has reserved the transfer.
-         * - COMMITTED - Next ledger has successfully performed the transfer.
-         * - ABORTED - Next ledger has aborted the transfer due to a rejection or failure to perform the transfer.
+         *     - RECEIVED - Next ledger has received the transfer.
+         *     - RESERVED - Next ledger has reserved the transfer.
+         *     - COMMITTED - Next ledger has successfully performed the transfer.
+         *     - ABORTED - Next ledger has aborted the transfer due to a rejection or failure to perform the transfer.
          * @example RESERVED
          * @enum {string}
          */
@@ -998,12 +1397,12 @@ export interface components {
             httpStatusCode?: number;
             mojaloopError?: components["schemas"]["mojaloopError"];
         };
-        bulkTransactionAcceptPartyErrorResponse: components["schemas"]["errorResponse"] & ({
+        bulkTransactionAcceptPartyErrorResponse: components["schemas"]["errorResponse"] & {
             bulkTransferState: components["schemas"]["bulkTransactionContinuationAcceptParty"] & components["schemas"]["partyError"];
-        });
-        bulkTransactionAcceptQuoteErrorResponse: components["schemas"]["errorResponse"] & ({
+        };
+        bulkTransactionAcceptQuoteErrorResponse: components["schemas"]["errorResponse"] & {
             bulkTransferState?: components["schemas"]["bulkTransactionContinuationAcceptQuote"] & components["schemas"]["quoteError"];
-        });
+        };
         /**
          * IndividualTransfer
          * @description Data model for the complex type 'individualTransfer'.
@@ -1057,11 +1456,11 @@ export interface components {
         /**
          * TransactionScenario
          * @description Below are the allowed values for the enumeration.
-         * - DEPOSIT - Used for performing a Cash-In (deposit) transaction. In a normal scenario, electronic funds are transferred from a Business account to a Consumer account, and physical cash is given from the Consumer to the Business User.
-         * - WITHDRAWAL - Used for performing a Cash-Out (withdrawal) transaction. In a normal scenario, electronic funds are transferred from a Consumer’s account to a Business account, and physical cash is given from the Business User to the Consumer.
-         * - TRANSFER - Used for performing a P2P (Peer to Peer, or Consumer to Consumer) transaction.
-         * - PAYMENT - Usually used for performing a transaction from a Consumer to a Merchant or Organization, but could also be for a B2B (Business to Business) payment. The transaction could be online for a purchase in an Internet store, in a physical store where both the Consumer and Business User are present, a bill payment, a donation, and so on.
-         * - REFUND - Used for performing a refund of transaction.
+         *     - DEPOSIT - Used for performing a Cash-In (deposit) transaction. In a normal scenario, electronic funds are transferred from a Business account to a Consumer account, and physical cash is given from the Consumer to the Business User.
+         *     - WITHDRAWAL - Used for performing a Cash-Out (withdrawal) transaction. In a normal scenario, electronic funds are transferred from a Consumer’s account to a Business account, and physical cash is given from the Business User to the Consumer.
+         *     - TRANSFER - Used for performing a P2P (Peer to Peer, or Consumer to Consumer) transaction.
+         *     - PAYMENT - Usually used for performing a transaction from a Consumer to a Merchant or Organization, but could also be for a B2B (Business to Business) payment. The transaction could be online for a purchase in an Internet store, in a physical store where both the Consumer and Business User are present, a bill payment, a donation, and so on.
+         *     - REFUND - Used for performing a refund of transaction.
          * @example DEPOSIT
          * @enum {string}
          */
@@ -1069,8 +1468,8 @@ export interface components {
         /**
          * TransactionInitiator
          * @description Below are the allowed values for the enumeration.
-         * - PAYER - Sender of funds is initiating the transaction. The account to send from is either owned by the Payer or is connected to the Payer in some way.
-         * - PAYEE - Recipient of the funds is initiating the transaction by sending a transaction request. The Payer must approve the transaction, either automatically by a pre-generated OTP or by pre-approval of the Payee, or by manually approving in his or her own Device.
+         *     - PAYER - Sender of funds is initiating the transaction. The account to send from is either owned by the Payer or is connected to the Payer in some way.
+         *     - PAYEE - Recipient of the funds is initiating the transaction by sending a transaction request. The Payer must approve the transaction, either automatically by a pre-generated OTP or by pre-approval of the Payee, or by manually approving in his or her own Device.
          * @example PAYEE
          * @enum {string}
          */
@@ -1118,8 +1517,8 @@ export interface components {
          * @description The FxRate object contains information about a currency conversion in the transfer. It can be used by parties to the transfer to exchange information with each other about the exchange rate for the transfer, to ensure that the best rate can be agreed on.
          */
         FxRate: {
-            sourceAmount: components["schemas"]["Money"];
-            targetAmount: components["schemas"]["Money"];
+            sourceAmount: components["schemas"]["Money"] & unknown;
+            targetAmount: components["schemas"]["Money"] & unknown;
         };
         /**
          * QuotesPostRequest
@@ -1135,8 +1534,8 @@ export interface components {
             amount: components["schemas"]["Money"];
             fees?: components["schemas"]["Money"];
             transactionType: components["schemas"]["TransactionType"];
-            converter?: components["schemas"]["CurrencyConverter"];
-            currencyConversion?: components["schemas"]["FxRate"];
+            converter?: components["schemas"]["CurrencyConverter"] & unknown;
+            currencyConversion?: components["schemas"]["FxRate"] & unknown;
             geoCode?: components["schemas"]["GeoCode"];
             note?: components["schemas"]["Note"];
             expiration?: components["schemas"]["DateTime"];
@@ -1177,9 +1576,9 @@ export interface components {
         /**
          * AuthenticationType
          * @description Below are the allowed values for the enumeration AuthenticationType.
-         * - OTP - One-time password generated by the Payer FSP.
-         * - QRCODE - QR code used as One Time Password.
-         * - U2F - U2F is a new addition isolated to Thirdparty stream.
+         *     - OTP - One-time password generated by the Payer FSP.
+         *     - QRCODE - QR code used as One Time Password.
+         *     - U2F - U2F is a new addition isolated to Thirdparty stream.
          * @example OTP
          * @enum {string}
          */
@@ -1209,10 +1608,10 @@ export interface components {
         /**
          * TransactionRequestState
          * @description Below are the allowed values for the enumeration.
-         * - RECEIVED - Payer FSP has received the transaction from the Payee FSP.
-         * - PENDING - Payer FSP has sent the transaction request to the Payer.
-         * - ACCEPTED - Payer has approved the transaction.
-         * - REJECTED - Payer has rejected the transaction.
+         *     - RECEIVED - Payer FSP has received the transaction from the Payee FSP.
+         *     - PENDING - Payer FSP has sent the transaction request to the Payer.
+         *     - ACCEPTED - Payer has approved the transaction.
+         *     - REJECTED - Payer has rejected the transaction.
          * @example RECEIVED
          * @enum {string}
          */
@@ -1275,25 +1674,25 @@ export interface components {
         FxCharge: {
             /** @description A description of the charge which is being levied. */
             chargeType: string;
-            sourceAmount?: components["schemas"]["Money"];
-            targetAmount?: components["schemas"]["Money"];
+            sourceAmount?: components["schemas"]["Money"] & unknown;
+            targetAmount?: components["schemas"]["Money"] & unknown;
         };
         /**
          * FxConversion
          * @description A DFSP will be able to request a currency conversion, and an FX provider will be able to describe its involvement in a proposed transfer, using a FxConversion object.
          */
         FxConversion: {
-            conversionId: components["schemas"]["CorrelationId"];
-            determiningTransferId?: components["schemas"]["CorrelationId"];
-            initiatingFsp: components["schemas"]["FspId"];
-            counterPartyFsp: components["schemas"]["FspId"];
-            amountType: components["schemas"]["AmountType"];
-            sourceAmount: components["schemas"]["FxMoney"];
-            targetAmount: components["schemas"]["FxMoney"];
-            expiration: components["schemas"]["DateTime"];
+            conversionId: components["schemas"]["CorrelationId"] & unknown;
+            determiningTransferId?: components["schemas"]["CorrelationId"] & unknown;
+            initiatingFsp: components["schemas"]["FspId"] & unknown;
+            counterPartyFsp: components["schemas"]["FspId"] & unknown;
+            amountType: components["schemas"]["AmountType"] & unknown;
+            sourceAmount: components["schemas"]["FxMoney"] & unknown;
+            targetAmount: components["schemas"]["FxMoney"] & unknown;
+            expiration: components["schemas"]["DateTime"] & unknown;
             /** @description One or more charges which the FXP intends to levy as part of the currency conversion, or which the payee DFSP intends to add to the amount transferred. */
             charges?: components["schemas"]["FxCharge"][];
-            extensionList?: components["schemas"]["ExtensionList"];
+            extensionList?: components["schemas"]["ExtensionList"] & unknown;
         };
         /**
          * FxQuotesPostOutboundResponse
@@ -1302,8 +1701,8 @@ export interface components {
         FxQuotesPostOutboundResponse: {
             /** @description Transaction ID for the FXP backend, used to reconcile transactions between the Switch and FXP backend systems. */
             homeTransactionId?: string;
-            condition?: components["schemas"]["IlpCondition"];
-            conversionTerms: components["schemas"]["FxConversion"];
+            condition?: components["schemas"]["IlpCondition"] & unknown;
+            conversionTerms: components["schemas"]["FxConversion"] & unknown;
         };
         /**
          * TransfersIDPutResponse
@@ -1337,14 +1736,16 @@ export interface components {
                 body: components["schemas"]["QuotesIDPutResponse"];
                 headers?: Record<string, never>;
             };
-            /** @description FSPID of the entity that supplied the quote response. This may not be the same as the FSPID of the entity which owns the end user account in the case of a FOREX transfer. i.e. it may be a FOREX gateway. */
+            /** @description FSPID of the entity that supplied the quote response. This may not be the same as the FSPID of the entity which owns the end user account in the case of a FOREX transfer. i.e. it may be a FOREX gateway.
+             *      */
             quoteResponseSource?: string;
             conversionRequestId?: components["schemas"]["CorrelationId"];
             fxQuotesResponse?: {
                 body: components["schemas"]["FxQuotesPostOutboundResponse"];
                 headers?: Record<string, never>;
             };
-            /** @description FXPID of the entity that supplied the fxQuotes response. */
+            /** @description FXPID of the entity that supplied the fxQuotes response.
+             *      */
             fxQuotesResponseSource?: string;
             fulfil?: {
                 body: components["schemas"]["TransfersIDPutResponse"];
@@ -1378,7 +1779,8 @@ export interface components {
          * @description Contains the authentication value. The format depends on the authentication type used in the AuthenticationInfo complex type.
          */
         AuthenticationValue: string | {
-            /** @description U2F challenge-response, where payer FSP verifies if the response provided by end-user device matches the previously registered key. */
+            /** @description U2F challenge-response, where payer FSP verifies if the response provided by end-user device matches the previously registered key.
+             *      */
             pinValue: string;
             /**
              * Integer
@@ -1397,9 +1799,9 @@ export interface components {
         /**
          * AuthorizationResponseType
          * @description Below are the allowed values for the enumeration.
-         * - ENTERED - Consumer entered the authentication value.
-         * - REJECTED - Consumer rejected the transaction.
-         * - RESEND - Consumer requested to resend the authentication value.
+         *     - ENTERED - Consumer entered the authentication value.
+         *     - REJECTED - Consumer rejected the transaction.
+         *     - RESEND - Consumer requested to resend the authentication value.
          * @example ENTERED
          * @enum {string}
          */
@@ -1430,7 +1832,8 @@ export interface components {
                 body: components["schemas"]["QuotesIDPutResponse"];
                 headers?: Record<string, never>;
             };
-            /** @description FSPID of the entity that supplied the quote response. This may not be the same as the FSPID of the entity which owns the end user account in the case of a FOREX transfer. i.e. it may be a FOREX gateway. */
+            /** @description FSPID of the entity that supplied the quote response. This may not be the same as the FSPID of the entity which owns the end user account in the case of a FOREX transfer. i.e. it may be a FOREX gateway.
+             *      */
             quoteResponseSource?: string;
             authorizationResponse?: {
                 body: components["schemas"]["AuthorizationIDPutResponse"];
@@ -1517,16 +1920,16 @@ export interface components {
         FxQuotesPostOutboundRequest: {
             /** @description Transaction ID for the backend, used to reconcile transactions between the Switch and backend systems. */
             homeTransactionId?: string;
-            conversionRequestId: components["schemas"]["CorrelationId"];
-            conversionTerms: components["schemas"]["FxConversion"];
+            conversionRequestId: components["schemas"]["CorrelationId"] & unknown;
+            conversionTerms: components["schemas"]["FxConversion"] & unknown;
         };
-        commitRequestId: components["schemas"]["CorrelationId"];
-        determiningTransferId: components["schemas"]["CorrelationId"];
-        initiatingFsp: components["schemas"]["FspId"];
-        counterPartyFsp: components["schemas"]["FspId"];
-        sourceAmount: components["schemas"]["Money"];
-        targetAmount: components["schemas"]["Money"];
-        condition: components["schemas"]["IlpCondition"];
+        commitRequestId: components["schemas"]["CorrelationId"] & unknown;
+        determiningTransferId: components["schemas"]["CorrelationId"] & unknown;
+        initiatingFsp: components["schemas"]["FspId"] & unknown;
+        counterPartyFsp: components["schemas"]["FspId"] & unknown;
+        sourceAmount: components["schemas"]["Money"] & unknown;
+        targetAmount: components["schemas"]["Money"] & unknown;
+        condition: components["schemas"]["IlpCondition"] & unknown;
         /**
          * FxTransfersPostOutboundRequest
          * @description The object sent in the POST /fxTransfers request.
@@ -1542,9 +1945,9 @@ export interface components {
             targetAmount: components["schemas"]["targetAmount"];
             condition?: components["schemas"]["condition"];
         };
-        fulfilment: components["schemas"]["IlpFulfilment"];
-        completedTimestamp: components["schemas"]["DateTime"];
-        conversionState: components["schemas"]["TransferState"];
+        fulfilment: components["schemas"]["IlpFulfilment"] & unknown;
+        completedTimestamp: components["schemas"]["DateTime"] & unknown;
+        conversionState: components["schemas"]["TransferState"] & unknown;
         /**
          * FxTransfersPostOutboundResponse
          * @description The object sent as a response for the POST /fxTransfers request.
@@ -1561,94 +1964,142 @@ export interface components {
     responses: {
         /** @description Malformed or missing required headers or parameters. */
         400: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["errorResponse"];
             };
         };
         /** @description An error occurred processing the request. */
         500: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["errorResponse"];
             };
         };
         /** @description Accounts creation completed */
         accountsCreationCompleted: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["accountsResponse"];
             };
         };
         /** @description An error occurred creating accounts */
         accountsCreationError: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["errorAccountsResponse"];
             };
         };
         /** @description Timeout occurred creating accounts */
         accountsCreationTimeout: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["errorAccountsResponse"];
             };
         };
         /** @description Bulk quote completed successfully */
         bulkQuoteSuccess: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["bulkQuoteResponse"];
             };
         };
         /** @description Malformed or missing required body, headers or parameters */
         bulkQuoteBadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["bulkQuoteErrorResponse"];
             };
         };
         /** @description An error occurred processing the bulk quote */
         bulkQuoteServerError: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["bulkQuoteErrorResponse"];
             };
         };
         /** @description Timeout occurred processing the bulk quote */
         bulkQuoteTimeout: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["bulkQuoteErrorResponse"];
             };
         };
         /** @description Bulk transfer accepted successfully */
         bulkTransactionAccepted: {
-            content: never;
+            headers: {
+                [name: string]: unknown;
+            };
+            content?: never;
         };
         /** @description Malformed or missing required body, headers or parameters */
         bulkTransferBadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["bulkTransferErrorResponse"];
             };
         };
         /** @description Internal Server Error */
         errorResponse: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["errorResponse"];
             };
         };
         /** @description Malformed or missing required body, headers or parameters */
         bulkTransactionPutBadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["bulkTransactionAcceptPartyErrorResponse"] | components["schemas"]["bulkTransactionAcceptQuoteErrorResponse"];
             };
         };
         /** @description Bulk transfer completed successfully */
         bulkTransferSuccess: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["bulkTransferResponse"];
             };
         };
         /** @description PartiesByIdSuccess */
         partiesByIdSuccess: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["partiesByIdResponse"];
             };
         };
         /** @description PartiesByIdError404 */
         partiesByIdError404: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": {
                     errorInformation?: components["schemas"]["ErrorInformation"];
@@ -1657,72 +2108,108 @@ export interface components {
         };
         /** @description sync response from POST /quotes */
         quotesPostSuccess: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["quotesPostResponse"];
             };
         };
         /** @description An error occurred processing the quotes request */
         quotesServerError: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["errorQuotesResponse"];
             };
         };
         /** @description Request to Pay completed successfully */
         requestToPaySuccess: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["requestToPayResponse"];
             };
         };
         /** @description An error occurred processing the transfer */
         transferServerError: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["errorTransferResponse"];
             };
         };
         /** @description Timeout occurred processing the transfer */
         transferTimeout: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["errorTransferResponse"];
             };
         };
         /** @description Transfer completed successfully */
         requestToPayTransferSuccess: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["requestToPayTransferResponse"];
             };
         };
         /** @description Malformed or missing required body, headers or parameters */
         requestToPayTransferBadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["errorTransferResponse"];
             };
         };
         /** @description Transfer completed successfully */
         transferSuccess: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["transferResponse"];
             };
         };
         /** @description sync response from POST /simpleTransfers */
         simpleTransfersPostSuccess: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["simpleTransfersPostResponse"];
             };
         };
         /** @description An error occurred processing the simple transfers request */
         simpleTransfersServerError: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["errorSimpleTransfersResponse"];
             };
         };
         /** @description Malformed or missing required body, headers or parameters */
         transferBadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["errorTransferResponse"];
             };
         };
         /** @description The response contains participants in a scheme who offer currency conversion services. If no participants offer these services, the return object will be blank. */
         servicesFXPSucess: {
+            headers: {
+                [name: string]: unknown;
+            };
             content: {
                 "application/json": components["schemas"]["ServicesFXPPutResponse"];
             };
@@ -1755,46 +2242,52 @@ export interface components {
     pathItems: never;
 }
 export type $defs = Record<string, never>;
-export type external = Record<string, never>;
 export interface operations {
-    /**
-     * PartiesByTypeAndID
-     * @description The HTTP request GET /parties// (or GET /parties///) is used to lookup information regarding the requested Party, defined by ,  and optionally (for example, GET /parties/MSISDN/123456789, or GET /parties/BUSINESS/shoecompany/employee1).
-     */
     PartiesByTypeAndID: {
         parameters: {
+            query?: never;
+            header?: never;
             path: {
+                /** @description The type of the party identifier. For example, `MSISDN`, `PERSONAL_ID`. */
                 Type: components["parameters"]["Type"];
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             200: components["responses"]["partiesByIdSuccess"];
             404: components["responses"]["partiesByIdError404"];
         };
     };
-    /**
-     * PartiesSubIdByTypeAndID
-     * @description The HTTP request GET /parties// (or GET /parties///) is used to lookup information regarding the requested Party, defined by ,  and optionally (for example, GET /parties/MSISDN/123456789, or GET /parties/BUSINESS/shoecompany/employee1).
-     */
     PartiesSubIdByTypeAndID: {
         parameters: {
+            query?: never;
+            header?: never;
             path: {
+                /** @description The type of the party identifier. For example, `MSISDN`, `PERSONAL_ID`. */
                 Type: components["parameters"]["Type"];
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
+                /** @description A sub-identifier of the party identifier, or a sub-type of the party identifier's type. For example, `PASSPORT`, `DRIVING_LICENSE`. */
                 SubId: components["parameters"]["SubId"];
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             200: components["responses"]["partiesByIdSuccess"];
             404: components["responses"]["partiesByIdError404"];
         };
     };
-    /**
-     * Quotes endpoint
-     * @description is used to request quotes from other DFSP
-     */
     QuotesPost: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         /** @description Quotes request payload */
         requestBody: {
             content: {
@@ -1806,11 +2299,13 @@ export interface operations {
             500: components["responses"]["quotesServerError"];
         };
     };
-    /**
-     * Simple Transfers endpoint
-     * @description is used to request a transfer
-     */
     SimpleTransfersPost: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         /** @description Simple Transfer request payload */
         requestBody: {
             content: {
@@ -1822,39 +2317,46 @@ export interface operations {
             500: components["responses"]["simpleTransfersServerError"];
         };
     };
-    /**
-     * Obtain a list of the DFSPs in the scheme who provide FXP service
-     * @description The HTTP request `GET /services/FXP` is used to request information about the participants in a scheme who offer currency conversion services.
-     */
     ServicesFXPGet: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
         responses: {
             200: components["responses"]["servicesFXPSucess"];
             400: components["responses"]["400"];
             500: components["responses"]["500"];
         };
     };
-    /**
-     * Obtain a list of the DFSPs in the scheme who provide FXP service
-     * @description The HTTP request `GET /services/FXP/{SourceCurrency}/{TargetCurrency}` is used to request information about the participants in a scheme who offer currency conversion services in a particular currency corridor. The required corridor is specified by giving the ISO 4217 currency code for the SourceCurrency and the TargetCurrency.
-     */
     ServicesFXPSourceCurrencyTargetCurrencyGet: {
         parameters: {
+            query?: never;
+            header?: never;
             path: {
+                /** @description ISO 4217 currency code for the source currency. */
                 SourceCurrency: components["parameters"]["SourceCurrency"];
+                /** @description ISO 4217 currency code for the target currency. */
                 TargetCurrency: components["parameters"]["TargetCurrency"];
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             200: components["responses"]["servicesFXPSucess"];
             400: components["responses"]["400"];
             500: components["responses"]["500"];
         };
     };
-    /**
-     * Calculate FX quote
-     * @description The HTTP request `POST /fxQuotes` is used to ask to provide a quotation for a currency conversion.
-     */
     FxQuotesPost: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         /** @description Details of the FX quote request. */
         requestBody: {
             content: {
@@ -1864,6 +2366,9 @@ export interface operations {
         responses: {
             /** @description Successful response. */
             200: {
+                headers: {
+                    [name: string]: unknown;
+                };
                 content: {
                     "application/json": components["schemas"]["FxQuotesPostOutboundResponse"];
                 };
@@ -1872,11 +2377,13 @@ export interface operations {
             500: components["responses"]["500"];
         };
     };
-    /**
-     * Perform FX transfer
-     * @description The HTTP request `POST /fxTransfers` is used to ask to confirm the execution of an agreed currency conversion.
-     */
     FxTransfersPost: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
         /** @description Details of the FX transfer request. */
         requestBody: {
             content: {
@@ -1886,6 +2393,9 @@ export interface operations {
         responses: {
             /** @description Successful response. */
             200: {
+                headers: {
+                    [name: string]: unknown;
+                };
                 content: {
                     "application/json": components["schemas"]["FxTransfersPostOutboundResponse"];
                 };