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

package/lib/fspiop/v1_1/openapi.d.ts

@@ -4,6 +4,38 @@
  */
 export interface paths {
     "/participants/{Type}/{ID}": {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
+                "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
+                Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
+                "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
+                "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
+                "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
+                "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
+                "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
+                "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
+                "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+            };
+            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;
+        };
         /**
          * Look up participant information
          * @description The HTTP request `GET /participants/{Type}/{ID}` (or `GET /participants/{Type}/{ID}/{SubId}`) is used to find out in which FSP the requested Party, defined by `{Type}`, `{ID}` and optionally `{SubId}`, is located (for example, `GET /participants/MSISDN/123456789`, or `GET /participants/BUSINESS/shoecompany/employee1`). This HTTP request should support a query string for filtering of currency. To use filtering of currency, the HTTP request `GET /participants/{Type}/{ID}?currency=XYZ` should be used, where `XYZ` is the requested currency.
@@ -23,35 +55,69 @@ export interface paths {
          * Delete participant information
          * @description The HTTP request `DELETE /participants/{Type}/{ID}` (or `DELETE /participants/{Type}/{ID}/{SubId}`) is used to delete information in the server regarding the provided identity, defined by `{Type}` and `{ID}`) (for example, `DELETE /participants/MSISDN/123456789`), and optionally `{SubId}`. This HTTP request should support a query string to delete FSP information regarding a specific currency only. To delete a specific currency only, the HTTP request `DELETE /participants/{Type}/{ID}?currency=XYZ` should be used, where `XYZ` is the requested currency.
          *
-         * **Note:** The Account Lookup System should verify that it is the Party’s current FSP that is deleting the FSP information.
+         *     **Note:** The Account Lookup System should verify that it is the Party’s current FSP that is deleting the FSP information.
          */
         delete: operations["ParticipantsByTypeAndID2"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/participants/{Type}/{ID}/error": {
         parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Return participant information error
+         * @description If the server is unable to find, create or delete the associated FSP of the provided identity, or another processing error occurred, the error callback `PUT /participants/{Type}/{ID}/error` (or `PUT /participants/{Type}/{ID}/{SubId}/error`) is used.
+         */
+        put: operations["ParticipantsErrorByTypeAndID"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/participants/{Type}/{ID}/{SubId}": {
+        parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             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;
         };
-    };
-    "/participants/{Type}/{ID}/error": {
-        /**
-         * Return participant information error
-         * @description If the server is unable to find, create or delete the associated FSP of the provided identity, or another processing error occurred, the error callback `PUT /participants/{Type}/{ID}/error` (or `PUT /participants/{Type}/{ID}/{SubId}/error`) is used.
-         */
-        put: operations["ParticipantsErrorByTypeAndID"];
-    };
-    "/participants/{Type}/{ID}/{SubId}": {
         /**
          * Look up participant information
          * @description The HTTP request `GET /participants/{Type}/{ID}` (or `GET /participants/{Type}/{ID}/{SubId}`) is used to find out in which FSP the requested Party, defined by `{Type}`, `{ID}` and optionally `{SubId}`, is located (for example, `GET /participants/MSISDN/123456789`, or `GET /participants/BUSINESS/shoecompany/employee1`). This HTTP request should support a query string for filtering of currency. To use filtering of currency, the HTTP request `GET /participants/{Type}/{ID}?currency=XYZ` should be used, where `XYZ` is the requested currency.
@@ -71,179 +137,375 @@ export interface paths {
          * Delete participant information
          * @description The HTTP request `DELETE /participants/{Type}/{ID}` (or `DELETE /participants/{Type}/{ID}/{SubId}`) is used to delete information in the server regarding the provided identity, defined by `{Type}` and `{ID}`) (for example, `DELETE /participants/MSISDN/123456789`), and optionally `{SubId}`. This HTTP request should support a query string to delete FSP information regarding a specific currency only. To delete a specific currency only, the HTTP request `DELETE /participants/{Type}/{ID}?currency=XYZ` should be used, where `XYZ` is the requested currency.
          *
-         * **Note:** The Account Lookup System should verify that it is the Party’s current FSP that is deleting the FSP information.
+         *     **Note:** The Account Lookup System should verify that it is the Party’s current FSP that is deleting the FSP information.
          */
         delete: operations["ParticipantsSubIdByTypeAndID2"];
-        parameters: {
-            header: {
-                "Content-Type": components["parameters"]["Content-Type"];
-                Date: components["parameters"]["Date"];
-                "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
-                "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
-                "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
-                "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
-                "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
-                "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
-                "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
-            };
-            path: {
-                Type: components["parameters"]["Type"];
-                ID: components["parameters"]["ID"];
-                SubId: components["parameters"]["SubId"];
-            };
-        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/participants/{Type}/{ID}/{SubId}/error": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Return participant information error
          * @description If the server is unable to find, create or delete the associated FSP of the provided identity, or another processing error occurred, the error callback `PUT /participants/{Type}/{ID}/error` (or `PUT /participants/{Type}/{ID}/{SubId}/error`) is used.
          */
         put: operations["ParticipantsSubIdErrorByTypeAndID"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/participants": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Create bulk participant information
          * @description The HTTP request `POST /participants` is used to create information in the server regarding the provided list of identities. This request should be used for bulk creation of FSP information for more than one Party. The optional currency parameter should indicate that each provided Party supports the currency.
          */
         post: operations["Participants1"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/participants/{ID}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Return bulk participant information
          * @description The callback `PUT /participants/{ID}` is used to inform the client of the result of the creation of the provided list of identities.
          */
         put: operations["putParticipantsByID"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/participants/{ID}/error": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Return bulk participant information error
          * @description If there is an error during FSP information creation in the server, the error callback `PUT /participants/{ID}/error` is used. The `{ID}` in the URI should contain the requestId that was used for the creation of the participant information.
          */
         put: operations["ParticipantsByIDAndError"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/parties/{Type}/{ID}": {
-        /**
-         * Look up party information
-         * @description The HTTP request `GET /parties/{Type}/{ID}` (or `GET /parties/{Type}/{ID}/{SubId}`) is used to look up information regarding the requested Party, defined by `{Type}`, `{ID}` and optionally `{SubId}` (for example, `GET /parties/MSISDN/123456789`, or `GET /parties/BUSINESS/shoecompany/employee1`).
-         */
-        get: operations["PartiesByTypeAndID"];
-        /**
-         * Return party information
-         * @description The callback `PUT /parties/{Type}/{ID}` (or `PUT /parties/{Type}/{ID}/{SubId}`) is used to inform the client of a successful result of the Party information lookup.
-         */
-        put: operations["PartiesByTypeAndID2"];
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             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;
         };
+        /**
+         * Look up party information
+         * @description The HTTP request `GET /parties/{Type}/{ID}` (or `GET /parties/{Type}/{ID}/{SubId}`) is used to look up information regarding the requested Party, defined by `{Type}`, `{ID}` and optionally `{SubId}` (for example, `GET /parties/MSISDN/123456789`, or `GET /parties/BUSINESS/shoecompany/employee1`).
+         */
+        get: operations["PartiesByTypeAndID"];
+        /**
+         * Return party information
+         * @description The callback `PUT /parties/{Type}/{ID}` (or `PUT /parties/{Type}/{ID}/{SubId}`) is used to inform the client of a successful result of the Party information lookup.
+         */
+        put: operations["PartiesByTypeAndID2"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/parties/{Type}/{ID}/error": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Return party information error
          * @description If the server is unable to find Party information of the provided identity, or another processing error occurred, the error callback `PUT /parties/{Type}/{ID}/error` (or `PUT /parties/{Type}/{ID}/{SubI}/error`) is used.
          */
         put: operations["PartiesErrorByTypeAndID"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/parties/{Type}/{ID}/{SubId}": {
-        /**
-         * Look up party information
-         * @description The HTTP request `GET /parties/{Type}/{ID}` (or `GET /parties/{Type}/{ID}/{SubId}`) is used to look up information regarding the requested Party, defined by `{Type}`, `{ID}` and optionally `{SubId}` (for example, `GET /parties/MSISDN/123456789`, or `GET /parties/BUSINESS/shoecompany/employee1`).
-         */
-        get: operations["PartiesSubIdByTypeAndID"];
-        /**
-         * Return party information
-         * @description The callback `PUT /parties/{Type}/{ID}` (or `PUT /parties/{Type}/{ID}/{SubId}`) is used to inform the client of a successful result of the Party information lookup.
-         */
-        put: operations["PartiesSubIdByTypeAndIDPut"];
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             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;
         };
+        /**
+         * Look up party information
+         * @description The HTTP request `GET /parties/{Type}/{ID}` (or `GET /parties/{Type}/{ID}/{SubId}`) is used to look up information regarding the requested Party, defined by `{Type}`, `{ID}` and optionally `{SubId}` (for example, `GET /parties/MSISDN/123456789`, or `GET /parties/BUSINESS/shoecompany/employee1`).
+         */
+        get: operations["PartiesSubIdByTypeAndID"];
+        /**
+         * Return party information
+         * @description The callback `PUT /parties/{Type}/{ID}` (or `PUT /parties/{Type}/{ID}/{SubId}`) is used to inform the client of a successful result of the Party information lookup.
+         */
+        put: operations["PartiesSubIdByTypeAndIDPut"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/parties/{Type}/{ID}/{SubId}/error": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Return party information error
          * @description If the server is unable to find Party information of the provided identity, or another processing error occurred, the error callback `PUT /parties/{Type}/{ID}/error` (or `PUT /parties/{Type}/{ID}/{SubId}/error`) is used.
          */
         put: operations["PartiesSubIdErrorByTypeAndID"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/transactionRequests": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Perform transaction request
          * @description The HTTP request `POST /transactionRequests` is used to request the creation of a transaction request for the provided financial transaction in the server.
          */
         post: operations["TransactionRequests"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/transactionRequests/{ID}": {
-        /**
-         * Retrieve transaction request information
-         * @description The HTTP request `GET /transactionRequests/{ID}` is used to get information regarding a transaction request created or requested earlier. The `{ID}` in the URI should contain the `transactionRequestId` that was used for the creation of the transaction request.
-         */
-        get: operations["TransactionRequestsByID"];
-        /**
-         * Return transaction request information
-         * @description The callback `PUT /transactionRequests/{ID}` is used to inform the client of a requested or created transaction request. The `{ID}` in the URI should contain the `transactionRequestId` that was used for the creation of the transaction request, or the `{ID}` that was used in the `GET /transactionRequests/{ID}`.
-         */
-        put: operations["TransactionRequestsByIDPut"];
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        /**
+         * Retrieve transaction request information
+         * @description The HTTP request `GET /transactionRequests/{ID}` is used to get information regarding a transaction request created or requested earlier. The `{ID}` in the URI should contain the `transactionRequestId` that was used for the creation of the transaction request.
+         */
+        get: operations["TransactionRequestsByID"];
+        /**
+         * Return transaction request information
+         * @description The callback `PUT /transactionRequests/{ID}` is used to inform the client of a requested or created transaction request. The `{ID}` in the URI should contain the `transactionRequestId` that was used for the creation of the transaction request, or the `{ID}` that was used in the `GET /transactionRequests/{ID}`.
+         */
+        put: operations["TransactionRequestsByIDPut"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/transactionRequests/{ID}/error": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Return transaction request information error
          * @description If the server is unable to find or create a transaction request, or another processing error occurs, the error callback `PUT /transactionRequests/{ID}/error` is used. The `{ID}` in the URI should contain the `transactionRequestId` that was used for the creation of the transaction request, or the `{ID}` that was used in the `GET /transactionRequests/{ID}`.
          */
         put: operations["TransactionRequestsErrorByID"];
+        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;
         /**
          * Calculate quote
          * @description The HTTP request `POST /quotes` is used to request the creation of a quote for the provided financial transaction in the server.
          */
         post: operations["Quotes"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/quotes/{ID}": {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
+                "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
+                Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
+                "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
+                "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
+                "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
+                "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
+                "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
+                "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
+                "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+            };
+            path: {
+                /** @description The identifier value. */
+                ID: components["parameters"]["ID"];
+            };
+            cookie?: never;
+        };
         /**
          * Retrieve quote information
          * @description The HTTP request `GET /quotes/{ID}` is used to get information regarding a quote created or requested earlier. The `{ID}` in the URI should contain the `quoteId` that was used for the creation of the quote.
@@ -254,46 +516,79 @@ export interface paths {
          * @description The callback `PUT /quotes/{ID}` is used to inform the client of a requested or created quote. The `{ID}` in the URI should contain the `quoteId` that was used for the creation of the quote, or the `{ID}` that was used in the `GET /quotes/{ID}` request.
          */
         put: operations["QuotesByID1"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/quotes/{ID}/error": {
         parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Return quote information error
+         * @description If the server is unable to find or create a quote, or some other processing error occurs, the error callback `PUT /quotes/{ID}/error` is used. The `{ID}` in the URI should contain the `quoteId` that was used for the creation of the quote, or the `{ID}` that was used in the `GET /quotes/{ID}` request.
+         */
+        put: operations["QuotesByIDAndError"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/authorizations/{ID}": {
+        parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
-    };
-    "/quotes/{ID}/error": {
-        /**
-         * Return quote information error
-         * @description If the server is unable to find or create a quote, or some other processing error occurs, the error callback `PUT /quotes/{ID}/error` is used. The `{ID}` in the URI should contain the `quoteId` that was used for the creation of the quote, or the `{ID}` that was used in the `GET /quotes/{ID}` request.
-         */
-        put: operations["QuotesByIDAndError"];
-    };
-    "/authorizations/{ID}": {
         /**
          * Perform authorization
          * @description The HTTP request `GET /authorizations/{ID}` is used to request the Payer to enter the applicable credentials in the Payee FSP system. The `{ID}` in the URI should contain the `transactionRequestID`, received from the `POST /transactionRequests` service earlier in the process. This request requires a query string to be included in the URI, with the following key-value pairs*:*
          *
-         * - `authenticationType={Type}`, where `{Type}` value is a valid authentication type from the enumeration `AuthenticationType`.
+         *     - `authenticationType={Type}`, where `{Type}` value is a valid authentication type from the enumeration `AuthenticationType`.
          *
-         * - `retriesLeft=={NrOfRetries}`, where `{NrOfRetries}` is the number of retries left before the financial transaction is rejected. `{NrOfRetries}` must be expressed in the form of the data type `Integer`. `retriesLeft=1` means that this is the last retry before the financial transaction is rejected.
+         *     - `retriesLeft=={NrOfRetries}`, where `{NrOfRetries}` is the number of retries left before the financial transaction is rejected. `{NrOfRetries}` must be expressed in the form of the data type `Integer`. `retriesLeft=1` means that this is the last retry before the financial transaction is rejected.
          *
-         * - `amount={Amount}`, where `{Amount}` is the transaction amount that will be withdrawn from the Payer’s account. `{Amount}` must be expressed in the form of the data type `Amount`.
+         *     - `amount={Amount}`, where `{Amount}` is the transaction amount that will be withdrawn from the Payer’s account. `{Amount}` must be expressed in the form of the data type `Amount`.
          *
-         * - `currency={Currency}`, where `{Currency}` is the transaction currency for the amount that will be withdrawn from the Payer’s account. The `{Currency}` value must be expressed in the form of the enumeration `CurrencyCode`.
+         *     - `currency={Currency}`, where `{Currency}` is the transaction currency for the amount that will be withdrawn from the Payer’s account. The `{Currency}` value must be expressed in the form of the enumeration `CurrencyCode`.
          *
-         * The following is an example URI containing all the required key-value pairs in the query string*:*
+         *     The following is an example URI containing all the required key-value pairs in the query string*:*
          *
-         * `GET /authorization/3d492671-b7af-4f3f-88de-76169b1bdf88?authenticationType=OTP&retriesLeft=2&amount=102&currency=USD`
+         *     `GET /authorization/3d492671-b7af-4f3f-88de-76169b1bdf88?authenticationType=OTP&retriesLeft=2&amount=102&currency=USD`
          */
         get: operations["AuthorizationsByIDGet"];
         /**
@@ -301,195 +596,368 @@ export interface paths {
          * @description The callback `PUT /authorizations/{ID}` is used to inform the client of the result of a previously-requested authorization. The `{ID}` in the URI should contain the `{ID}` that was used in the `GET /authorizations/{ID}` request.
          */
         put: operations["AuthorizationsByIDPut"];
-        parameters: {
-            header: {
-                "Content-Type": components["parameters"]["Content-Type"];
-                Date: components["parameters"]["Date"];
-                "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
-                "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
-                "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
-                "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
-                "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
-                "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
-                "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
-            };
-            path: {
-                ID: components["parameters"]["ID"];
-            };
-        };
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/authorizations/{ID}/error": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Return authorization error
          * @description If the server is unable to find the transaction request, or another processing error occurs, the error callback `PUT /authorizations/{ID}/error` is used. The `{ID}` in the URI should contain the `{ID}` that was used in the `GET /authorizations/{ID}`.
          */
         put: operations["AuthorizationsByIDAndError"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/transfers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Perform transfer
          * @description The HTTP request `POST /transfers` is used to request the creation of a transfer for the next ledger, and a financial transaction for the Payee FSP.
          */
         post: operations["transfers"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/transfers/{ID}": {
-        /**
-         * Retrieve transfer information
-         * @description The HTTP request `GET /transfers/{ID}` is used to get information regarding a transfer created or requested earlier. The `{ID}` in the URI should contain the `transferId` that was used for the creation of the transfer.
-         */
-        get: operations["TransfersByIDGet"];
-        /**
-         * Return transfer information
-         * @description The callback `PUT /transfers/{ID}` is used to inform the client of a requested or created transfer. The `{ID}` in the URI should contain the `transferId` that was used for the creation of the transfer, or the `{ID}` that was used in the `GET /transfers/{ID}` request.
-         */
-        put: operations["TransfersByIDPut"];
-        /**
-         * Return transfer information
-         * @description The HTTP request PATCH /transfers/<ID> is used by a Switch to update the state of a previously reserved transfer, if the Payee FSP has requested a commit notification when the Switch has completed processing of the transfer. The <ID> in the URI should contain the transferId that was used for the creation of the transfer. Please note that this request does not generate a callback.
-         */
-        patch: operations["TransfersByIDPatch"];
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        /**
+         * Retrieve transfer information
+         * @description The HTTP request `GET /transfers/{ID}` is used to get information regarding a transfer created or requested earlier. The `{ID}` in the URI should contain the `transferId` that was used for the creation of the transfer.
+         */
+        get: operations["TransfersByIDGet"];
+        /**
+         * Return transfer information
+         * @description The callback `PUT /transfers/{ID}` is used to inform the client of a requested or created transfer. The `{ID}` in the URI should contain the `transferId` that was used for the creation of the transfer, or the `{ID}` that was used in the `GET /transfers/{ID}` request.
+         */
+        put: operations["TransfersByIDPut"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /**
+         * Return transfer information
+         * @description The HTTP request PATCH /transfers/<ID> is used by a Switch to update the state of a previously reserved transfer, if the Payee FSP has requested a commit notification when the Switch has completed processing of the transfer. The <ID> in the URI should contain the transferId that was used for the creation of the transfer. Please note that this request does not generate a callback.
+         */
+        patch: operations["TransfersByIDPatch"];
+        trace?: never;
     };
     "/transfers/{ID}/error": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Return transfer information error
          * @description If the server is unable to find or create a transfer, or another processing error occurs, the error callback `PUT /transfers/{ID}/error` is used. The `{ID}` in the URI should contain the `transferId` that was used for the creation of the transfer, or the `{ID}` that was used in the `GET /transfers/{ID}`.
          */
         put: operations["TransfersByIDAndError"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/transactions/{ID}": {
-        /**
-         * Retrieve transaction information
-         * @description The HTTP request `GET /transactions/{ID}` is used to get transaction information regarding a financial transaction created earlier. The `{ID}` in the URI should contain the `transactionId` that was used for the creation of the quote, as the transaction is created as part of another process (the transfer process).
-         */
-        get: operations["TransactionsByID"];
-        /**
-         * Return transaction information
-         * @description The callback `PUT /transactions/{ID}` is used to inform the client of a requested transaction. The `{ID}` in the URI should contain the `{ID}` that was used in the `GET /transactions/{ID}` request.
-         */
-        put: operations["TransactionsByID1"];
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        /**
+         * Retrieve transaction information
+         * @description The HTTP request `GET /transactions/{ID}` is used to get transaction information regarding a financial transaction created earlier. The `{ID}` in the URI should contain the `transactionId` that was used for the creation of the quote, as the transaction is created as part of another process (the transfer process).
+         */
+        get: operations["TransactionsByID"];
+        /**
+         * Return transaction information
+         * @description The callback `PUT /transactions/{ID}` is used to inform the client of a requested transaction. The `{ID}` in the URI should contain the `{ID}` that was used in the `GET /transactions/{ID}` request.
+         */
+        put: operations["TransactionsByID1"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/transactions/{ID}/error": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Return transaction information error
          * @description If the server is unable to find or create a transaction, or another processing error occurs, the error callback `PUT /transactions/{ID}/error` is used. The `{ID}` in the URI should contain the `{ID}` that was used in the `GET /transactions/{ID}` request.
          */
         put: operations["TransactionsErrorByID"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/bulkQuotes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
          * Calculate bulk quote
          * @description The HTTP request `POST /bulkQuotes` is used to request the creation of a bulk quote for the provided financial transactions in the server.
          */
         post: operations["BulkQuotes"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/bulkQuotes/{ID}": {
-        /**
-         * Retrieve bulk quote information
-         * @description The HTTP request `GET /bulkQuotes/{ID}` is used to get information regarding a bulk quote created or requested earlier. The `{ID}` in the URI should contain the `bulkQuoteId` that was used for the creation of the bulk quote.
-         */
-        get: operations["BulkQuotesByID"];
-        /**
-         * Return bulk quote information
-         * @description The callback `PUT /bulkQuotes/{ID}` is used to inform the client of a requested or created bulk quote. The `{ID}` in the URI should contain the `bulkQuoteId` that was used for the creation of the bulk quote, or the `{ID}` that was used in the `GET /bulkQuotes/{ID}` request.
-         */
-        put: operations["BulkQuotesByID1"];
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        /**
+         * Retrieve bulk quote information
+         * @description The HTTP request `GET /bulkQuotes/{ID}` is used to get information regarding a bulk quote created or requested earlier. The `{ID}` in the URI should contain the `bulkQuoteId` that was used for the creation of the bulk quote.
+         */
+        get: operations["BulkQuotesByID"];
+        /**
+         * Return bulk quote information
+         * @description The callback `PUT /bulkQuotes/{ID}` is used to inform the client of a requested or created bulk quote. The `{ID}` in the URI should contain the `bulkQuoteId` that was used for the creation of the bulk quote, or the `{ID}` that was used in the `GET /bulkQuotes/{ID}` request.
+         */
+        put: operations["BulkQuotesByID1"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/bulkQuotes/{ID}/error": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Return bulk quote information error
          * @description If the server is unable to find or create a bulk quote, or another processing error occurs, the error callback `PUT /bulkQuotes/{ID}/error` is used. The `{ID}` in the URI should contain the `bulkQuoteId` that was used for the creation of the bulk quote, or the `{ID}` that was used in the `GET /bulkQuotes/{ID}` request.
          */
         put: operations["BulkQuotesErrorByID"];
+        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;
         /**
          * Perform bulk transfer
          * @description The HTTP request `POST /bulkTransfers` is used to request the creation of a bulk transfer in the server.
          */
         post: operations["BulkTransfers"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/bulkTransfers/{ID}": {
-        /**
-         * Retrieve bulk transfer information
-         * @description The HTTP request `GET /bulkTransfers/{ID}` is used to get information regarding a bulk transfer created or requested earlier. The `{ID}` in the URI should contain the `bulkTransferId` that was used for the creation of the bulk transfer.
-         */
-        get: operations["BulkTransferByID"];
-        /**
-         * Return bulk transfer information
-         * @description The callback `PUT /bulkTransfers/{ID}` is used to inform the client of a requested or created bulk transfer. The `{ID}` in the URI should contain the `bulkTransferId` that was used for the creation of the bulk transfer (`POST /bulkTransfers`), or the `{ID}` that was used in the `GET /bulkTransfers/{ID}` request.
-         */
-        put: operations["BulkTransfersByIDPut"];
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        /**
+         * Retrieve bulk transfer information
+         * @description The HTTP request `GET /bulkTransfers/{ID}` is used to get information regarding a bulk transfer created or requested earlier. The `{ID}` in the URI should contain the `bulkTransferId` that was used for the creation of the bulk transfer.
+         */
+        get: operations["BulkTransferByID"];
+        /**
+         * Return bulk transfer information
+         * @description The callback `PUT /bulkTransfers/{ID}` is used to inform the client of a requested or created bulk transfer. The `{ID}` in the URI should contain the `bulkTransferId` that was used for the creation of the bulk transfer (`POST /bulkTransfers`), or the `{ID}` that was used in the `GET /bulkTransfers/{ID}` request.
+         */
+        put: operations["BulkTransfersByIDPut"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
     "/bulkTransfers/{ID}/error": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
         /**
          * Return bulk transfer information error
          * @description If the server is unable to find or create a bulk transfer, or another processing error occurs, the error callback `PUT /bulkTransfers/{ID}/error` is used. The `{ID}` in the URI should contain the `bulkTransferId` that was used for the creation of the bulk transfer (`POST /bulkTransfers`), or the `{ID}` that was used in the `GET /bulkTransfers/{ID}` request.
          */
         put: operations["BulkTransfersErrorByID"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
     };
 }
 export type webhooks = Record<string, never>;
@@ -504,8 +972,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}
          */
@@ -521,9 +989,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}
          */
@@ -536,9 +1004,9 @@ export interface components {
         /**
          * AuthorizationResponse
          * @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}
          */
@@ -587,12 +1055,12 @@ export interface components {
         /**
          * BulkTransactionState
          * @description Below are the allowed values for the enumeration.
-         * - RECEIVED - Payee FSP has received the bulk transfer from the Payer FSP.
-         * - PENDING - Payee FSP has validated the bulk transfer.
-         * - ACCEPTED - Payee FSP has accepted to process the bulk transfer.
-         * - PROCESSING - Payee FSP has started to transfer fund to the Payees.
-         * - COMPLETED - Payee FSP has completed transfer of funds to the Payees.
-         * - REJECTED - Payee FSP has rejected to process the bulk transfer.
+         *     - RECEIVED - Payee FSP has received the bulk transfer from the Payer FSP.
+         *     - PENDING - Payee FSP has validated the bulk transfer.
+         *     - ACCEPTED - Payee FSP has accepted to process the bulk transfer.
+         *     - PROCESSING - Payee FSP has started to transfer fund to the Payees.
+         *     - COMPLETED - Payee FSP has completed transfer of funds to the Payees.
+         *     - REJECTED - Payee FSP has rejected to process the bulk transfer.
          * @example RECEIVED
          * @enum {string}
          */
@@ -851,9 +1319,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;
         /**
@@ -942,14 +1410,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";
@@ -988,19 +1456,19 @@ export interface components {
         /**
          * PersonalIdentifierType
          * @description Below are the allowed values for the enumeration.
-         * - PASSPORT - A passport number is used as reference to a Party.
-         * - NATIONAL_REGISTRATION - A national registration number is used as reference to a Party.
-         * - DRIVING_LICENSE - A driving license is used as reference to a Party.
-         * - ALIEN_REGISTRATION - An alien registration number is used as reference to a Party.
-         * - NATIONAL_ID_CARD - A national ID card number is used as reference to a Party.
-         * - EMPLOYER_ID - A tax identification number is used as reference to a Party.
-         * - TAX_ID_NUMBER - A tax identification number is used as reference to a Party.
-         * - SENIOR_CITIZENS_CARD - A senior citizens card number is used as reference to a Party.
-         * - MARRIAGE_CERTIFICATE - A marriage certificate number is used as reference to a Party.
-         * - HEALTH_CARD - A health card number is used as reference to a Party.
-         * - VOTERS_ID - A voter’s identification number is used as reference to a Party.
-         * - UNITED_NATIONS - An UN (United Nations) number is used as reference to a Party.
-         * - OTHER_ID - Any other type of identification type number is used as reference to a Party.
+         *     - PASSPORT - A passport number is used as reference to a Party.
+         *     - NATIONAL_REGISTRATION - A national registration number is used as reference to a Party.
+         *     - DRIVING_LICENSE - A driving license is used as reference to a Party.
+         *     - ALIEN_REGISTRATION - An alien registration number is used as reference to a Party.
+         *     - NATIONAL_ID_CARD - A national ID card number is used as reference to a Party.
+         *     - EMPLOYER_ID - A tax identification number is used as reference to a Party.
+         *     - TAX_ID_NUMBER - A tax identification number is used as reference to a Party.
+         *     - SENIOR_CITIZENS_CARD - A senior citizens card number is used as reference to a Party.
+         *     - MARRIAGE_CERTIFICATE - A marriage certificate number is used as reference to a Party.
+         *     - HEALTH_CARD - A health card number is used as reference to a Party.
+         *     - VOTERS_ID - A voter’s identification number is used as reference to a Party.
+         *     - UNITED_NATIONS - An UN (United Nations) number is used as reference to a Party.
+         *     - OTHER_ID - Any other type of identification type number is used as reference to a Party.
          * @enum {string}
          */
         PersonalIdentifierType: "PASSPORT" | "NATIONAL_REGISTRATION" | "DRIVING_LICENSE" | "ALIEN_REGISTRATION" | "NATIONAL_ID_CARD" | "EMPLOYER_ID" | "TAX_ID_NUMBER" | "SENIOR_CITIZENS_CARD" | "MARRIAGE_CERTIFICATE" | "HEALTH_CARD" | "VOTERS_ID" | "UNITED_NATIONS" | "OTHER_ID";
@@ -1079,8 +1547,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}
          */
@@ -1088,10 +1556,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}
          */
@@ -1099,10 +1567,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}
          */
@@ -1135,11 +1603,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}
          */
@@ -1147,10 +1615,10 @@ export interface components {
         /**
          * TransactionState
          * @description Below are the allowed values for the enumeration.
-         * - RECEIVED - Payee FSP has received the transaction from the Payer FSP.
-         * - PENDING - Payee FSP has validated the transaction.
-         * - COMPLETED - Payee FSP has successfully performed the transaction.
-         * - REJECTED - Payee FSP has failed to perform the transaction.
+         *     - RECEIVED - Payee FSP has received the transaction from the Payer FSP.
+         *     - PENDING - Payee FSP has validated the transaction.
+         *     - COMPLETED - Payee FSP has successfully performed the transaction.
+         *     - REJECTED - Payee FSP has failed to perform the transaction.
          * @example RECEIVED
          * @enum {string}
          */
@@ -1186,10 +1654,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}
          */
@@ -1230,11 +1698,13 @@ export interface components {
         /**
          * U2FPIN
          * @description U2F challenge-response, where payer FSP verifies if the response provided by end-user device matches the previously registered key.
+         *
          */
         U2FPIN: string;
         /**
          * U2FPinValue
          * @description U2F challenge-response, where payer FSP verifies if the response provided by end-user device matches the previously registered key.
+         *
          */
         U2FPinValue: {
             /** @description U2F challenge-response. */
@@ -1251,17 +1721,24 @@ export interface components {
     responses: {
         /** @description OK */
         200: {
-            content: never;
+            headers: {
+                [name: string]: unknown;
+            };
+            content?: never;
         };
         /** @description Accepted */
         202: {
-            content: never;
+            headers: {
+                [name: string]: unknown;
+            };
+            content?: never;
         };
         /** @description Bad Request */
         400: {
             headers: {
                 "Content-Length": components["headers"]["Content-Length"];
                 "Content-Type": components["headers"]["Content-Type"];
+                [name: string]: unknown;
             };
             content: {
                 "application/json": components["schemas"]["ErrorInformationResponse"];
@@ -1272,6 +1749,7 @@ export interface components {
             headers: {
                 "Content-Length": components["headers"]["Content-Length"];
                 "Content-Type": components["headers"]["Content-Type"];
+                [name: string]: unknown;
             };
             content: {
                 "application/json": components["schemas"]["ErrorInformationResponse"];
@@ -1282,6 +1760,7 @@ export interface components {
             headers: {
                 "Content-Length": components["headers"]["Content-Length"];
                 "Content-Type": components["headers"]["Content-Type"];
+                [name: string]: unknown;
             };
             content: {
                 "application/json": components["schemas"]["ErrorInformationResponse"];
@@ -1292,6 +1771,7 @@ export interface components {
             headers: {
                 "Content-Length": components["headers"]["Content-Length"];
                 "Content-Type": components["headers"]["Content-Type"];
+                [name: string]: unknown;
             };
             content: {
                 "application/json": components["schemas"]["ErrorInformationResponse"];
@@ -1302,6 +1782,7 @@ export interface components {
             headers: {
                 "Content-Length": components["headers"]["Content-Length"];
                 "Content-Type": components["headers"]["Content-Type"];
+                [name: string]: unknown;
             };
             content: {
                 "application/json": components["schemas"]["ErrorInformationResponse"];
@@ -1312,6 +1793,7 @@ export interface components {
             headers: {
                 "Content-Length": components["headers"]["Content-Length"];
                 "Content-Type": components["headers"]["Content-Type"];
+                [name: string]: unknown;
             };
             content: {
                 "application/json": components["schemas"]["ErrorInformationResponse"];
@@ -1322,6 +1804,7 @@ export interface components {
             headers: {
                 "Content-Length": components["headers"]["Content-Length"];
                 "Content-Type": components["headers"]["Content-Type"];
+                [name: string]: unknown;
             };
             content: {
                 "application/json": components["schemas"]["ErrorInformationResponse"];
@@ -1332,6 +1815,7 @@ export interface components {
             headers: {
                 "Content-Length": components["headers"]["Content-Length"];
                 "Content-Type": components["headers"]["Content-Type"];
+                [name: string]: unknown;
             };
             content: {
                 "application/json": components["schemas"]["ErrorInformationResponse"];
@@ -1341,48 +1825,42 @@ export interface components {
     parameters: {
         /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
         Accept: string;
-        /**
-         * @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+        /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
          *
-         * **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes).
-         */
-        "Content-Length"?: number;
+         *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
+        "Content-Length": number;
         /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
         "Content-Type": string;
         /** @description The `Date` header field indicates the date when the request was sent. */
         Date: string;
         /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
-        "FSPIOP-Destination"?: string;
+        "FSPIOP-Destination": string;
         /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
-        "FSPIOP-Encryption"?: string;
+        "FSPIOP-Encryption": string;
         /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
-        "FSPIOP-HTTP-Method"?: string;
+        "FSPIOP-HTTP-Method": string;
         /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
-        "FSPIOP-Signature"?: string;
+        "FSPIOP-Signature": string;
         /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
         "FSPIOP-Source": string;
         /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
-        "FSPIOP-URI"?: string;
+        "FSPIOP-URI": string;
         /** @description The identifier value. */
         ID: string;
         /** @description A sub-identifier of the party identifier, or a sub-type of the party identifier's type. For example, `PASSPORT`, `DRIVING_LICENSE`. */
         SubId: string;
         /** @description The type of the party identifier. For example, `MSISDN`, `PERSONAL_ID`. */
         Type: string;
-        /**
-         * @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+        /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
          *
-         * **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`.
-         */
-        "X-Forwarded-For"?: string;
+         *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
+        "X-Forwarded-For": string;
     };
     requestBodies: never;
     headers: {
-        /**
-         * @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+        /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
          *
-         * **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes).
-         */
+         *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
         "Content-Length": number;
         /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
         "Content-Type": string;
@@ -1390,31 +1868,43 @@ export interface components {
     pathItems: never;
 }
 export type $defs = Record<string, never>;
-export type external = Record<string, never>;
 export interface operations {
-    /**
-     * Look up participant information
-     * @description The HTTP request `GET /participants/{Type}/{ID}` (or `GET /participants/{Type}/{ID}/{SubId}`) is used to find out in which FSP the requested Party, defined by `{Type}`, `{ID}` and optionally `{SubId}`, is located (for example, `GET /participants/MSISDN/123456789`, or `GET /participants/BUSINESS/shoecompany/employee1`). This HTTP request should support a query string for filtering of currency. To use filtering of currency, the HTTP request `GET /participants/{Type}/{ID}?currency=XYZ` should be used, where `XYZ` is the requested currency.
-     */
     ParticipantsByTypeAndID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             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: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -1427,28 +1917,42 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return participant information
-     * @description The callback `PUT /participants/{Type}/{ID}` (or `PUT /participants/{Type}/{ID}/{SubId}`) is used to inform the client of a successful result of the lookup, creation, or deletion of the FSP information related to the Party. If the FSP information is deleted, the fspId element should be empty; otherwise the element should include the FSP information for the Party.
-     */
     ParticipantsByTypeAndID3: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             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;
         };
         /** @description Participant information returned. */
         requestBody: {
@@ -1468,29 +1972,44 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Create participant information
-     * @description The HTTP request `POST /participants/{Type}/{ID}` (or `POST /participants/{Type}/{ID}/{SubId}`) is used to create information in the server regarding the provided identity, defined by `{Type}`, `{ID}`, and optionally `{SubId}` (for example, `POST /participants/MSISDN/123456789` or `POST /participants/BUSINESS/shoecompany/employee1`). An ExtensionList element has been added to this reqeust in version v1.1
-     */
     ParticipantsByIDAndType: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             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;
         };
         /** @description Participant information to be created. */
         requestBody: {
@@ -1510,31 +2029,42 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Delete participant information
-     * @description The HTTP request `DELETE /participants/{Type}/{ID}` (or `DELETE /participants/{Type}/{ID}/{SubId}`) is used to delete information in the server regarding the provided identity, defined by `{Type}` and `{ID}`) (for example, `DELETE /participants/MSISDN/123456789`), and optionally `{SubId}`. This HTTP request should support a query string to delete FSP information regarding a specific currency only. To delete a specific currency only, the HTTP request `DELETE /participants/{Type}/{ID}?currency=XYZ` should be used, where `XYZ` is the requested currency.
-     *
-     * **Note:** The Account Lookup System should verify that it is the Party’s current FSP that is deleting the FSP information.
-     */
     ParticipantsByTypeAndID2: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             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: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -1547,28 +2077,42 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return participant information error
-     * @description If the server is unable to find, create or delete the associated FSP of the provided identity, or another processing error occurred, the error callback `PUT /participants/{Type}/{ID}/error` (or `PUT /participants/{Type}/{ID}/{SubId}/error`) is used.
-     */
     ParticipantsErrorByTypeAndID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             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;
         };
         /** @description Details of the error returned. */
         requestBody: {
@@ -1588,30 +2132,44 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Look up participant information
-     * @description The HTTP request `GET /participants/{Type}/{ID}` (or `GET /participants/{Type}/{ID}/{SubId}`) is used to find out in which FSP the requested Party, defined by `{Type}`, `{ID}` and optionally `{SubId}`, is located (for example, `GET /participants/MSISDN/123456789`, or `GET /participants/BUSINESS/shoecompany/employee1`). This HTTP request should support a query string for filtering of currency. To use filtering of currency, the HTTP request `GET /participants/{Type}/{ID}?currency=XYZ` should be used, where `XYZ` is the requested currency.
-     */
     ParticipantsSubIdByTypeAndID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             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: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -1624,29 +2182,44 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return participant information
-     * @description The callback `PUT /participants/{Type}/{ID}` (or `PUT /participants/{Type}/{ID}/{SubId}`) is used to inform the client of a successful result of the lookup, creation, or deletion of the FSP information related to the Party. If the FSP information is deleted, the fspId element should be empty; otherwise the element should include the FSP information for the Party.
-     */
     ParticipantsSubIdByTypeAndID3: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             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;
         };
         /** @description Participant information returned. */
         requestBody: {
@@ -1666,30 +2239,46 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Create participant information
-     * @description The HTTP request `POST /participants/{Type}/{ID}` (or `POST /participants/{Type}/{ID}/{SubId}`) is used to create information in the server regarding the provided identity, defined by `{Type}`, `{ID}`, and optionally `{SubId}` (for example, `POST /participants/MSISDN/123456789` or `POST /participants/BUSINESS/shoecompany/employee1`). An ExtensionList element has been added to this reqeust in version v1.1
-     */
     ParticipantsSubIdByTypeAndIDPost: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             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;
         };
         /** @description Participant information to be created. */
         requestBody: {
@@ -1709,32 +2298,44 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Delete participant information
-     * @description The HTTP request `DELETE /participants/{Type}/{ID}` (or `DELETE /participants/{Type}/{ID}/{SubId}`) is used to delete information in the server regarding the provided identity, defined by `{Type}` and `{ID}`) (for example, `DELETE /participants/MSISDN/123456789`), and optionally `{SubId}`. This HTTP request should support a query string to delete FSP information regarding a specific currency only. To delete a specific currency only, the HTTP request `DELETE /participants/{Type}/{ID}?currency=XYZ` should be used, where `XYZ` is the requested currency.
-     *
-     * **Note:** The Account Lookup System should verify that it is the Party’s current FSP that is deleting the FSP information.
-     */
     ParticipantsSubIdByTypeAndID2: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             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: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -1747,29 +2348,44 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return participant information error
-     * @description If the server is unable to find, create or delete the associated FSP of the provided identity, or another processing error occurred, the error callback `PUT /participants/{Type}/{ID}/error` (or `PUT /participants/{Type}/{ID}/{SubId}/error`) is used.
-     */
     ParticipantsSubIdErrorByTypeAndID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             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;
         };
         /** @description Details of the error returned. */
         requestBody: {
@@ -1789,25 +2405,39 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Create bulk participant information
-     * @description The HTTP request `POST /participants` is used to create information in the server regarding the provided list of identities. This request should be used for bulk creation of FSP information for more than one Party. The optional currency parameter should indicate that each provided Party supports the currency.
-     */
     Participants1: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
+            path?: never;
+            cookie?: never;
         };
         /** @description Participant information to be created. */
         requestBody: {
@@ -1827,27 +2457,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return bulk participant information
-     * @description The callback `PUT /participants/{ID}` is used to inform the client of the result of the creation of the provided list of identities.
-     */
     putParticipantsByID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Participant information returned. */
         requestBody: {
@@ -1867,27 +2510,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return bulk participant information error
-     * @description If there is an error during FSP information creation in the server, the error callback `PUT /participants/{ID}/error` is used. The `{ID}` in the URI should contain the requestId that was used for the creation of the participant information.
-     */
     ParticipantsByIDAndError: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Details of the error returned. */
         requestBody: {
@@ -1907,29 +2563,42 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Look up party information
-     * @description The HTTP request `GET /parties/{Type}/{ID}` (or `GET /parties/{Type}/{ID}/{SubId}`) is used to look up information regarding the requested Party, defined by `{Type}`, `{ID}` and optionally `{SubId}` (for example, `GET /parties/MSISDN/123456789`, or `GET /parties/BUSINESS/shoecompany/employee1`).
-     */
     PartiesByTypeAndID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             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: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -1942,28 +2611,42 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return party information
-     * @description The callback `PUT /parties/{Type}/{ID}` (or `PUT /parties/{Type}/{ID}/{SubId}`) is used to inform the client of a successful result of the Party information lookup.
-     */
     PartiesByTypeAndID2: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             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;
         };
         /** @description Party information returned. */
         requestBody: {
@@ -1983,28 +2666,42 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return party information error
-     * @description If the server is unable to find Party information of the provided identity, or another processing error occurred, the error callback `PUT /parties/{Type}/{ID}/error` (or `PUT /parties/{Type}/{ID}/{SubI}/error`) is used.
-     */
     PartiesErrorByTypeAndID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             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;
         };
         /** @description Details of the error returned. */
         requestBody: {
@@ -2024,30 +2721,44 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Look up party information
-     * @description The HTTP request `GET /parties/{Type}/{ID}` (or `GET /parties/{Type}/{ID}/{SubId}`) is used to look up information regarding the requested Party, defined by `{Type}`, `{ID}` and optionally `{SubId}` (for example, `GET /parties/MSISDN/123456789`, or `GET /parties/BUSINESS/shoecompany/employee1`).
-     */
     PartiesSubIdByTypeAndID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             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: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -2060,29 +2771,44 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return party information
-     * @description The callback `PUT /parties/{Type}/{ID}` (or `PUT /parties/{Type}/{ID}/{SubId}`) is used to inform the client of a successful result of the Party information lookup.
-     */
     PartiesSubIdByTypeAndIDPut: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             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;
         };
         /** @description Party information returned. */
         requestBody: {
@@ -2102,29 +2828,44 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return party information error
-     * @description If the server is unable to find Party information of the provided identity, or another processing error occurred, the error callback `PUT /parties/{Type}/{ID}/error` (or `PUT /parties/{Type}/{ID}/{SubId}/error`) is used.
-     */
     PartiesSubIdErrorByTypeAndID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             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;
         };
         /** @description Details of the error returned. */
         requestBody: {
@@ -2144,25 +2885,39 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Perform transaction request
-     * @description The HTTP request `POST /transactionRequests` is used to request the creation of a transaction request for the provided financial transaction in the server.
-     */
     TransactionRequests: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
+            path?: never;
+            cookie?: never;
         };
         /** @description Transaction request to be created. */
         requestBody: {
@@ -2182,28 +2937,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Retrieve transaction request information
-     * @description The HTTP request `GET /transactionRequests/{ID}` is used to get information regarding a transaction request created or requested earlier. The `{ID}` in the URI should contain the `transactionRequestId` that was used for the creation of the transaction request.
-     */
     TransactionRequestsByID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -2216,27 +2983,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return transaction request information
-     * @description The callback `PUT /transactionRequests/{ID}` is used to inform the client of a requested or created transaction request. The `{ID}` in the URI should contain the `transactionRequestId` that was used for the creation of the transaction request, or the `{ID}` that was used in the `GET /transactionRequests/{ID}`.
-     */
     TransactionRequestsByIDPut: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Transaction request information returned. */
         requestBody: {
@@ -2256,27 +3036,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return transaction request information error
-     * @description If the server is unable to find or create a transaction request, or another processing error occurs, the error callback `PUT /transactionRequests/{ID}/error` is used. The `{ID}` in the URI should contain the `transactionRequestId` that was used for the creation of the transaction request, or the `{ID}` that was used in the `GET /transactionRequests/{ID}`.
-     */
     TransactionRequestsErrorByID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Details of the error returned. */
         requestBody: {
@@ -2296,25 +3089,39 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Calculate quote
-     * @description The HTTP request `POST /quotes` is used to request the creation of a quote for the provided financial transaction in the server.
-     */
     Quotes: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
+            path?: never;
+            cookie?: never;
         };
         /** @description Details of the quote to be created. */
         requestBody: {
@@ -2334,28 +3141,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Retrieve quote information
-     * @description The HTTP request `GET /quotes/{ID}` is used to get information regarding a quote created or requested earlier. The `{ID}` in the URI should contain the `quoteId` that was used for the creation of the quote.
-     */
     QuotesByID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -2368,27 +3187,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return quote information
-     * @description The callback `PUT /quotes/{ID}` is used to inform the client of a requested or created quote. The `{ID}` in the URI should contain the `quoteId` that was used for the creation of the quote, or the `{ID}` that was used in the `GET /quotes/{ID}` request.
-     */
     QuotesByID1: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Quote information returned. */
         requestBody: {
@@ -2408,27 +3240,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return quote information error
-     * @description If the server is unable to find or create a quote, or some other processing error occurs, the error callback `PUT /quotes/{ID}/error` is used. The `{ID}` in the URI should contain the `quoteId` that was used for the creation of the quote, or the `{ID}` that was used in the `GET /quotes/{ID}` request.
-     */
     QuotesByIDAndError: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Details of the error returned. */
         requestBody: {
@@ -2448,40 +3293,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Perform authorization
-     * @description The HTTP request `GET /authorizations/{ID}` is used to request the Payer to enter the applicable credentials in the Payee FSP system. The `{ID}` in the URI should contain the `transactionRequestID`, received from the `POST /transactionRequests` service earlier in the process. This request requires a query string to be included in the URI, with the following key-value pairs*:*
-     *
-     * - `authenticationType={Type}`, where `{Type}` value is a valid authentication type from the enumeration `AuthenticationType`.
-     *
-     * - `retriesLeft=={NrOfRetries}`, where `{NrOfRetries}` is the number of retries left before the financial transaction is rejected. `{NrOfRetries}` must be expressed in the form of the data type `Integer`. `retriesLeft=1` means that this is the last retry before the financial transaction is rejected.
-     *
-     * - `amount={Amount}`, where `{Amount}` is the transaction amount that will be withdrawn from the Payer’s account. `{Amount}` must be expressed in the form of the data type `Amount`.
-     *
-     * - `currency={Currency}`, where `{Currency}` is the transaction currency for the amount that will be withdrawn from the Payer’s account. The `{Currency}` value must be expressed in the form of the enumeration `CurrencyCode`.
-     *
-     * The following is an example URI containing all the required key-value pairs in the query string*:*
-     *
-     * `GET /authorization/3d492671-b7af-4f3f-88de-76169b1bdf88?authenticationType=OTP&retriesLeft=2&amount=102&currency=USD`
-     */
     AuthorizationsByIDGet: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -2494,27 +3339,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return authorization result
-     * @description The callback `PUT /authorizations/{ID}` is used to inform the client of the result of a previously-requested authorization. The `{ID}` in the URI should contain the `{ID}` that was used in the `GET /authorizations/{ID}` request.
-     */
     AuthorizationsByIDPut: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Authorization result returned. */
         requestBody: {
@@ -2534,27 +3392,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return authorization error
-     * @description If the server is unable to find the transaction request, or another processing error occurs, the error callback `PUT /authorizations/{ID}/error` is used. The `{ID}` in the URI should contain the `{ID}` that was used in the `GET /authorizations/{ID}`.
-     */
     AuthorizationsByIDAndError: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Details of the error returned. */
         requestBody: {
@@ -2574,25 +3445,39 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Perform transfer
-     * @description The HTTP request `POST /transfers` is used to request the creation of a transfer for the next ledger, and a financial transaction for the Payee FSP.
-     */
     transfers: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
+            path?: never;
+            cookie?: never;
         };
         /** @description Details of the transfer to be created. */
         requestBody: {
@@ -2612,28 +3497,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Retrieve transfer information
-     * @description The HTTP request `GET /transfers/{ID}` is used to get information regarding a transfer created or requested earlier. The `{ID}` in the URI should contain the `transferId` that was used for the creation of the transfer.
-     */
     TransfersByIDGet: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -2646,27 +3543,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return transfer information
-     * @description The callback `PUT /transfers/{ID}` is used to inform the client of a requested or created transfer. The `{ID}` in the URI should contain the `transferId` that was used for the creation of the transfer, or the `{ID}` that was used in the `GET /transfers/{ID}` request.
-     */
     TransfersByIDPut: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Transfer information returned. */
         requestBody: {
@@ -2686,27 +3596,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return transfer information
-     * @description The HTTP request PATCH /transfers/<ID> is used by a Switch to update the state of a previously reserved transfer, if the Payee FSP has requested a commit notification when the Switch has completed processing of the transfer. The <ID> in the URI should contain the transferId that was used for the creation of the transfer. Please note that this request does not generate a callback.
-     */
     TransfersByIDPatch: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Transfer notification upon completion. */
         requestBody: {
@@ -2726,27 +3649,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return transfer information error
-     * @description If the server is unable to find or create a transfer, or another processing error occurs, the error callback `PUT /transfers/{ID}/error` is used. The `{ID}` in the URI should contain the `transferId` that was used for the creation of the transfer, or the `{ID}` that was used in the `GET /transfers/{ID}`.
-     */
     TransfersByIDAndError: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Details of the error returned. */
         requestBody: {
@@ -2766,28 +3702,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Retrieve transaction information
-     * @description The HTTP request `GET /transactions/{ID}` is used to get transaction information regarding a financial transaction created earlier. The `{ID}` in the URI should contain the `transactionId` that was used for the creation of the quote, as the transaction is created as part of another process (the transfer process).
-     */
     TransactionsByID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -2800,27 +3748,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return transaction information
-     * @description The callback `PUT /transactions/{ID}` is used to inform the client of a requested transaction. The `{ID}` in the URI should contain the `{ID}` that was used in the `GET /transactions/{ID}` request.
-     */
     TransactionsByID1: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Transaction information returned. */
         requestBody: {
@@ -2840,27 +3801,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return transaction information error
-     * @description If the server is unable to find or create a transaction, or another processing error occurs, the error callback `PUT /transactions/{ID}/error` is used. The `{ID}` in the URI should contain the `{ID}` that was used in the `GET /transactions/{ID}` request.
-     */
     TransactionsErrorByID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Details of the error returned. */
         requestBody: {
@@ -2880,25 +3854,39 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Calculate bulk quote
-     * @description The HTTP request `POST /bulkQuotes` is used to request the creation of a bulk quote for the provided financial transactions in the server.
-     */
     BulkQuotes: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
+            path?: never;
+            cookie?: never;
         };
         /** @description Details of the bulk quote to be created. */
         requestBody: {
@@ -2918,28 +3906,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Retrieve bulk quote information
-     * @description The HTTP request `GET /bulkQuotes/{ID}` is used to get information regarding a bulk quote created or requested earlier. The `{ID}` in the URI should contain the `bulkQuoteId` that was used for the creation of the bulk quote.
-     */
     BulkQuotesByID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -2952,27 +3952,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return bulk quote information
-     * @description The callback `PUT /bulkQuotes/{ID}` is used to inform the client of a requested or created bulk quote. The `{ID}` in the URI should contain the `bulkQuoteId` that was used for the creation of the bulk quote, or the `{ID}` that was used in the `GET /bulkQuotes/{ID}` request.
-     */
     BulkQuotesByID1: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Bulk quote information returned. */
         requestBody: {
@@ -2992,27 +4005,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return bulk quote information error
-     * @description If the server is unable to find or create a bulk quote, or another processing error occurs, the error callback `PUT /bulkQuotes/{ID}/error` is used. The `{ID}` in the URI should contain the `bulkQuoteId` that was used for the creation of the bulk quote, or the `{ID}` that was used in the `GET /bulkQuotes/{ID}` request.
-     */
     BulkQuotesErrorByID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Details of the error returned. */
         requestBody: {
@@ -3032,25 +4058,39 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Perform bulk transfer
-     * @description The HTTP request `POST /bulkTransfers` is used to request the creation of a bulk transfer in the server.
-     */
     BulkTransfers: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
+            path?: never;
+            cookie?: never;
         };
         /** @description Details of the bulk transfer to be created. */
         requestBody: {
@@ -3070,28 +4110,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Retrieve bulk transfer information
-     * @description The HTTP request `GET /bulkTransfers/{ID}` is used to get information regarding a bulk transfer created or requested earlier. The `{ID}` in the URI should contain the `bulkTransferId` that was used for the creation of the bulk transfer.
-     */
     BulkTransferByID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Accept` header field indicates the version of the API the client would like the server to use. */
                 Accept: components["parameters"]["Accept"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             202: components["responses"]["202"];
             400: components["responses"]["400"];
@@ -3104,27 +4156,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return bulk transfer information
-     * @description The callback `PUT /bulkTransfers/{ID}` is used to inform the client of a requested or created bulk transfer. The `{ID}` in the URI should contain the `bulkTransferId` that was used for the creation of the bulk transfer (`POST /bulkTransfers`), or the `{ID}` that was used in the `GET /bulkTransfers/{ID}` request.
-     */
     BulkTransfersByIDPut: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Bulk transfer information returned. */
         requestBody: {
@@ -3144,27 +4209,40 @@ export interface operations {
             503: components["responses"]["503"];
         };
     };
-    /**
-     * Return bulk transfer information error
-     * @description If the server is unable to find or create a bulk transfer, or another processing error occurs, the error callback `PUT /bulkTransfers/{ID}/error` is used. The `{ID}` in the URI should contain the `bulkTransferId` that was used for the creation of the bulk transfer (`POST /bulkTransfers`), or the `{ID}` that was used in the `GET /bulkTransfers/{ID}` request.
-     */
     BulkTransfersErrorByID: {
         parameters: {
+            query?: never;
             header: {
+                /** @description The `Content-Length` header field indicates the anticipated size of the payload body. Only sent if there is a body.
+                 *
+                 *     **Note:** The API supports a maximum size of 5242880 bytes (5 Megabytes). */
                 "Content-Length"?: components["parameters"]["Content-Length"];
+                /** @description The `Content-Type` header indicates the specific version of the API used to send the payload body. */
                 "Content-Type": components["parameters"]["Content-Type"];
+                /** @description The `Date` header field indicates the date when the request was sent. */
                 Date: components["parameters"]["Date"];
+                /** @description The `X-Forwarded-For` header field is an unofficially accepted standard used for informational purposes of the originating client IP address, as a request might pass multiple proxies, firewalls, and so on. Multiple `X-Forwarded-For` values should be expected and supported by implementers of the API.
+                 *
+                 *     **Note:** An alternative to `X-Forwarded-For` is defined in [RFC 7239](https://tools.ietf.org/html/rfc7239). However, to this point RFC 7239 is less-used and supported than `X-Forwarded-For`. */
                 "X-Forwarded-For"?: components["parameters"]["X-Forwarded-For"];
+                /** @description The `FSPIOP-Source` header field is a non-HTTP standard field used by the API for identifying the sender of the HTTP request. The field should be set by the original sender of the request. Required for routing and signature verification (see header field `FSPIOP-Signature`). */
                 "FSPIOP-Source": components["parameters"]["FSPIOP-Source"];
+                /** @description The `FSPIOP-Destination` header field is a non-HTTP standard field used by the API for HTTP header based routing of requests and responses to the destination. The field must be set by the original sender of the request if the destination is known (valid for all services except GET /parties) so that any entities between the client and the server do not need to parse the payload for routing purposes. If the destination is not known (valid for service GET /parties), the field should be left empty. */
                 "FSPIOP-Destination"?: components["parameters"]["FSPIOP-Destination"];
+                /** @description The `FSPIOP-Encryption` header field is a non-HTTP standard field used by the API for applying end-to-end encryption of the request. */
                 "FSPIOP-Encryption"?: components["parameters"]["FSPIOP-Encryption"];
+                /** @description The `FSPIOP-Signature` header field is a non-HTTP standard field used by the API for applying an end-to-end request signature. */
                 "FSPIOP-Signature"?: components["parameters"]["FSPIOP-Signature"];
+                /** @description The `FSPIOP-URI` header field is a non-HTTP standard field used by the API for signature verification, should contain the service URI. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-URI"?: components["parameters"]["FSPIOP-URI"];
+                /** @description The `FSPIOP-HTTP-Method` header field is a non-HTTP standard field used by the API for signature verification, should contain the service HTTP method. Required if signature verification is used, for more information, see [the API Signature document](https://github.com/mojaloop/docs/tree/main/Specification%20Document%20Set). */
                 "FSPIOP-HTTP-Method"?: components["parameters"]["FSPIOP-HTTP-Method"];
             };
             path: {
+                /** @description The identifier value. */
                 ID: components["parameters"]["ID"];
             };
+            cookie?: never;
         };
         /** @description Details of the error returned. */
         requestBody: {