@vality/swag-payments 0.1.0

package/esm2020/lib/configuration.mjs

@@ -0,0 +1,102 @@
+export class Configuration {
+    constructor(configurationParameters = {}) {
+        this.apiKeys = configurationParameters.apiKeys;
+        this.username = configurationParameters.username;
+        this.password = configurationParameters.password;
+        this.accessToken = configurationParameters.accessToken;
+        this.basePath = configurationParameters.basePath;
+        this.withCredentials = configurationParameters.withCredentials;
+        this.encoder = configurationParameters.encoder;
+        if (configurationParameters.encodeParam) {
+            this.encodeParam = configurationParameters.encodeParam;
+        }
+        else {
+            this.encodeParam = param => this.defaultEncodeParam(param);
+        }
+        if (configurationParameters.credentials) {
+            this.credentials = configurationParameters.credentials;
+        }
+        else {
+            this.credentials = {};
+        }
+        // init default bearer credential
+        if (!this.credentials['bearer']) {
+            this.credentials['bearer'] = () => {
+                if (this.apiKeys === null || this.apiKeys === undefined) {
+                    return undefined;
+                }
+                else {
+                    return this.apiKeys['bearer'] || this.apiKeys['Authorization'];
+                }
+            };
+        }
+    }
+    /**
+     * Select the correct content-type to use for a request.
+     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param contentTypes - the array of content types that are available for selection
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    selectHeaderContentType(contentTypes) {
+        if (contentTypes.length === 0) {
+            return undefined;
+        }
+        const type = contentTypes.find((x) => this.isJsonMime(x));
+        if (type === undefined) {
+            return contentTypes[0];
+        }
+        return type;
+    }
+    /**
+     * Select the correct accept content-type to use for a request.
+     * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param accepts - the array of content types that are available for selection.
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    selectHeaderAccept(accepts) {
+        if (accepts.length === 0) {
+            return undefined;
+        }
+        const type = accepts.find((x) => this.isJsonMime(x));
+        if (type === undefined) {
+            return accepts[0];
+        }
+        return type;
+    }
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    isJsonMime(mime) {
+        const jsonMime = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
+        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
+    }
+    lookupCredential(key) {
+        const value = this.credentials[key];
+        return typeof value === 'function'
+            ? value()
+            : value;
+    }
+    defaultEncodeParam(param) {
+        // This implementation exists as fallback for missing configuration
+        // and for backwards compatibility to older typescript-angular generator versions.
+        // It only works for the 'simple' parameter style.
+        // Date-handling only works for the 'date-time' format.
+        // All other styles and Date-formats are probably handled incorrectly.
+        //
+        // But: if that's all you need (i.e.: the most common use-case): no need for customization!
+        const value = param.dataFormat === 'date-time' && param.value instanceof Date
+            ? param.value.toISOString()
+            : param.value;
+        return encodeURIComponent(String(value));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../../../../../projects/vality/swag-payments/src/lib/configuration.ts"],"names":[],"mappings":"AAoCA,MAAM,OAAO,aAAa;IAgCtB,YAAY,0BAAmD,EAAE;QAC7D,IAAI,CAAC,OAAO,GAAG,uBAAuB,CAAC,OAAO,CAAC;QAC/C,IAAI,CAAC,QAAQ,GAAG,uBAAuB,CAAC,QAAQ,CAAC;QACjD,IAAI,CAAC,QAAQ,GAAG,uBAAuB,CAAC,QAAQ,CAAC;QACjD,IAAI,CAAC,WAAW,GAAG,uBAAuB,CAAC,WAAW,CAAC;QACvD,IAAI,CAAC,QAAQ,GAAG,uBAAuB,CAAC,QAAQ,CAAC;QACjD,IAAI,CAAC,eAAe,GAAG,uBAAuB,CAAC,eAAe,CAAC;QAC/D,IAAI,CAAC,OAAO,GAAG,uBAAuB,CAAC,OAAO,CAAC;QAC/C,IAAI,uBAAuB,CAAC,WAAW,EAAE;YACrC,IAAI,CAAC,WAAW,GAAG,uBAAuB,CAAC,WAAW,CAAC;SAC1D;aACI;YACD,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;SAC9D;QACD,IAAI,uBAAuB,CAAC,WAAW,EAAE;YACrC,IAAI,CAAC,WAAW,GAAG,uBAAuB,CAAC,WAAW,CAAC;SAC1D;aACI;YACD,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;SACzB;QAED,iCAAiC;QACjC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE;YAC7B,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,GAAG,EAAE;gBAC9B,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE;oBACrD,OAAO,SAAS,CAAC;iBACpB;qBAAM;oBACH,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;iBAClE;YACL,CAAC,CAAC;SACL;IACL,CAAC;IAED;;;;;;OAMG;IACI,uBAAuB,CAAE,YAAsB;QAClD,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,OAAO,SAAS,CAAC;SACpB;QAED,MAAM,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;QAClE,IAAI,IAAI,KAAK,SAAS,EAAE;YACpB,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC;SAC1B;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACI,kBAAkB,CAAC,OAAiB;QACvC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;YACtB,OAAO,SAAS,CAAC;SACpB;QAED,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7D,IAAI,IAAI,KAAK,SAAS,EAAE;YACpB,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;SACrB;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;;OASG;IACI,UAAU,CAAC,IAAY;QAC1B,MAAM,QAAQ,GAAW,IAAI,MAAM,CAAC,+DAA+D,EAAE,GAAG,CAAC,CAAC;QAC1G,OAAO,IAAI,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,WAAW,EAAE,KAAK,6BAA6B,CAAC,CAAC;IAC1G,CAAC;IAEM,gBAAgB,CAAC,GAAW;QAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACpC,OAAO,OAAO,KAAK,KAAK,UAAU;YAC9B,CAAC,CAAC,KAAK,EAAE;YACT,CAAC,CAAC,KAAK,CAAC;IAChB,CAAC;IAEO,kBAAkB,CAAC,KAAY;QACnC,mEAAmE;QACnE,kFAAkF;QAClF,kDAAkD;QAClD,uDAAuD;QACvD,sEAAsE;QACtE,EAAE;QACF,2FAA2F;QAE3F,MAAM,KAAK,GAAG,KAAK,CAAC,UAAU,KAAK,WAAW,IAAI,KAAK,CAAC,KAAK,YAAY,IAAI;YACzE,CAAC,CAAE,KAAK,CAAC,KAAc,CAAC,WAAW,EAAE;YACrC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC;QAElB,OAAO,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7C,CAAC;CACJ","sourcesContent":["import { HttpParameterCodec } from '@angular/common/http';\nimport { Param } from './param';\n\nexport interface ConfigurationParameters {\n    /**\n     *  @deprecated Since 5.0. Use credentials instead\n     */\n    apiKeys?: {[ key: string ]: string};\n    username?: string;\n    password?: string;\n    /**\n     *  @deprecated Since 5.0. Use credentials instead\n     */\n    accessToken?: string | (() => string);\n    basePath?: string;\n    withCredentials?: boolean;\n    /**\n     * Takes care of encoding query- and form-parameters.\n     */\n    encoder?: HttpParameterCodec;\n    /**\n     * Override the default method for encoding path parameters in various\n     * <a href=\"https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values\">styles</a>.\n     * <p>\n     * See {@link README.md} for more details\n     * </p>\n     */\n    encodeParam?: (param: Param) => string;\n    /**\n     * The keys are the names in the securitySchemes section of the OpenAPI\n     * document. They should map to the value used for authentication\n     * minus any standard prefixes such as 'Basic' or 'Bearer'.\n     */\n    credentials?: {[ key: string ]: string | (() => string | undefined)};\n}\n\nexport class Configuration {\n    /**\n     *  @deprecated Since 5.0. Use credentials instead\n     */\n    apiKeys?: {[ key: string ]: string};\n    username?: string;\n    password?: string;\n    /**\n     *  @deprecated Since 5.0. Use credentials instead\n     */\n    accessToken?: string | (() => string);\n    basePath?: string;\n    withCredentials?: boolean;\n    /**\n     * Takes care of encoding query- and form-parameters.\n     */\n    encoder?: HttpParameterCodec;\n    /**\n     * Encoding of various path parameter\n     * <a href=\"https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values\">styles</a>.\n     * <p>\n     * See {@link README.md} for more details\n     * </p>\n     */\n    encodeParam: (param: Param) => string;\n    /**\n     * The keys are the names in the securitySchemes section of the OpenAPI\n     * document. They should map to the value used for authentication\n     * minus any standard prefixes such as 'Basic' or 'Bearer'.\n     */\n    credentials: {[ key: string ]: string | (() => string | undefined)};\n\n    constructor(configurationParameters: ConfigurationParameters = {}) {\n        this.apiKeys = configurationParameters.apiKeys;\n        this.username = configurationParameters.username;\n        this.password = configurationParameters.password;\n        this.accessToken = configurationParameters.accessToken;\n        this.basePath = configurationParameters.basePath;\n        this.withCredentials = configurationParameters.withCredentials;\n        this.encoder = configurationParameters.encoder;\n        if (configurationParameters.encodeParam) {\n            this.encodeParam = configurationParameters.encodeParam;\n        }\n        else {\n            this.encodeParam = param => this.defaultEncodeParam(param);\n        }\n        if (configurationParameters.credentials) {\n            this.credentials = configurationParameters.credentials;\n        }\n        else {\n            this.credentials = {};\n        }\n\n        // init default bearer credential\n        if (!this.credentials['bearer']) {\n            this.credentials['bearer'] = () => {\n                if (this.apiKeys === null || this.apiKeys === undefined) {\n                    return undefined;\n                } else {\n                    return this.apiKeys['bearer'] || this.apiKeys['Authorization'];\n                }\n            };\n        }\n    }\n\n    /**\n     * Select the correct content-type to use for a request.\n     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.\n     * If no content type is found return the first found type if the contentTypes is not empty\n     * @param contentTypes - the array of content types that are available for selection\n     * @returns the selected content-type or <code>undefined</code> if no selection could be made.\n     */\n    public selectHeaderContentType (contentTypes: string[]): string | undefined {\n        if (contentTypes.length === 0) {\n            return undefined;\n        }\n\n        const type = contentTypes.find((x: string) => this.isJsonMime(x));\n        if (type === undefined) {\n            return contentTypes[0];\n        }\n        return type;\n    }\n\n    /**\n     * Select the correct accept content-type to use for a request.\n     * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.\n     * If no content type is found return the first found type if the contentTypes is not empty\n     * @param accepts - the array of content types that are available for selection.\n     * @returns the selected content-type or <code>undefined</code> if no selection could be made.\n     */\n    public selectHeaderAccept(accepts: string[]): string | undefined {\n        if (accepts.length === 0) {\n            return undefined;\n        }\n\n        const type = accepts.find((x: string) => this.isJsonMime(x));\n        if (type === undefined) {\n            return accepts[0];\n        }\n        return type;\n    }\n\n    /**\n     * Check if the given MIME is a JSON MIME.\n     * JSON MIME examples:\n     *   application/json\n     *   application/json; charset=UTF8\n     *   APPLICATION/JSON\n     *   application/vnd.company+json\n     * @param mime - MIME (Multipurpose Internet Mail Extensions)\n     * @return True if the given MIME is JSON, false otherwise.\n     */\n    public isJsonMime(mime: string): boolean {\n        const jsonMime: RegExp = new RegExp('^(application\\/json|[^;/ \\t]+\\/[^;/ \\t]+[+]json)[ \\t]*(;.*)?$', 'i');\n        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');\n    }\n\n    public lookupCredential(key: string): string | undefined {\n        const value = this.credentials[key];\n        return typeof value === 'function'\n            ? value()\n            : value;\n    }\n\n    private defaultEncodeParam(param: Param): string {\n        // This implementation exists as fallback for missing configuration\n        // and for backwards compatibility to older typescript-angular generator versions.\n        // It only works for the 'simple' parameter style.\n        // Date-handling only works for the 'date-time' format.\n        // All other styles and Date-formats are probably handled incorrectly.\n        //\n        // But: if that's all you need (i.e.: the most common use-case): no need for customization!\n\n        const value = param.dataFormat === 'date-time' && param.value instanceof Date\n            ? (param.value as Date).toISOString()\n            : param.value;\n\n        return encodeURIComponent(String(value));\n    }\n}\n"]}

package/esm2020/lib/encoder.mjs

@@ -0,0 +1,19 @@
+/**
+ * Custom HttpParameterCodec
+ * Workaround for https://github.com/angular/angular/issues/18261
+ */
+export class CustomHttpParameterCodec {
+    encodeKey(k) {
+        return encodeURIComponent(k);
+    }
+    encodeValue(v) {
+        return encodeURIComponent(v);
+    }
+    decodeKey(k) {
+        return decodeURIComponent(k);
+    }
+    decodeValue(v) {
+        return decodeURIComponent(v);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5jb2Rlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbGl0eS9zd2FnLXBheW1lbnRzL3NyYy9saWIvZW5jb2Rlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sd0JBQXdCO0lBQ2pDLFNBQVMsQ0FBQyxDQUFTO1FBQ2YsT0FBTyxrQkFBa0IsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBQ0QsV0FBVyxDQUFDLENBQVM7UUFDakIsT0FBTyxrQkFBa0IsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBQ0QsU0FBUyxDQUFDLENBQVM7UUFDZixPQUFPLGtCQUFrQixDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2pDLENBQUM7SUFDRCxXQUFXLENBQUMsQ0FBUztRQUNqQixPQUFPLGtCQUFrQixDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2pDLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEh0dHBQYXJhbWV0ZXJDb2RlYyB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcblxuLyoqXG4gKiBDdXN0b20gSHR0cFBhcmFtZXRlckNvZGVjXG4gKiBXb3JrYXJvdW5kIGZvciBodHRwczovL2dpdGh1Yi5jb20vYW5ndWxhci9hbmd1bGFyL2lzc3Vlcy8xODI2MVxuICovXG5leHBvcnQgY2xhc3MgQ3VzdG9tSHR0cFBhcmFtZXRlckNvZGVjIGltcGxlbWVudHMgSHR0cFBhcmFtZXRlckNvZGVjIHtcbiAgICBlbmNvZGVLZXkoazogc3RyaW5nKTogc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIGVuY29kZVVSSUNvbXBvbmVudChrKTtcbiAgICB9XG4gICAgZW5jb2RlVmFsdWUodjogc3RyaW5nKTogc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIGVuY29kZVVSSUNvbXBvbmVudCh2KTtcbiAgICB9XG4gICAgZGVjb2RlS2V5KGs6IHN0cmluZyk6IHN0cmluZyB7XG4gICAgICAgIHJldHVybiBkZWNvZGVVUklDb21wb25lbnQoayk7XG4gICAgfVxuICAgIGRlY29kZVZhbHVlKHY6IHN0cmluZyk6IHN0cmluZyB7XG4gICAgICAgIHJldHVybiBkZWNvZGVVUklDb21wb25lbnQodik7XG4gICAgfVxufVxuIl19

package/esm2020/lib/index.mjs

@@ -0,0 +1,7 @@
+export * from './api/api';
+export * from './model/models';
+export * from './variables';
+export * from './configuration';
+export * from './api.module';
+export * from './param';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWxpdHkvc3dhZy1wYXltZW50cy9zcmMvbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXBpL2FwaSc7XG5leHBvcnQgKiBmcm9tICcuL21vZGVsL21vZGVscyc7XG5leHBvcnQgKiBmcm9tICcuL3ZhcmlhYmxlcyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbmZpZ3VyYXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9hcGkubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vcGFyYW0nO1xuIl19

package/esm2020/lib/model/access-token.mjs

@@ -0,0 +1,13 @@
+/**
+ * Vality Payments API
+ * ## Description API is designed for the merchants who accept payments via user interface such as a website or a mobile app and it is the only interaction point with the system for goods and services payment transactions. ## Interaction details Whenever an API is accessed, its unique ID must be passed in the header X-Request-ID of the corresponding request: ```  X-Request-ID: 37d735d4-0f42-4f05-89fa-eaa478fb5aa9 ``` ### Content type and coding The system accepts and returns data in JSON format and UTF-8 coding: ```   Content-Type: application/json; charset=utf-8 ``` ### Date formats The system accepts and returns timestamp values in the format date-time, described in [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339): ```   2017-01-01T00:00:00Z   2017-01-01T00:00:01+00:00 ``` ### Maximum request processing time Whenever an API is accessed, the time cutoff parameters, that define maximum request processing time of the transaction completion, can be passed in the header `X-Request-Deadline` of the corresponding request: ```  X-Request-Deadline: 10s ``` The system stops processing the request upon the specified time. It is recommended to specify a value that is not more than one minute and not less than three seconds. `X-Request-Deadline` can be:  * specified in the format `date-time` according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative values: in milliseconds (`150000ms`), in seconds (`540s`) or in minutes (`3.5m`).
+ *
+ * The version of the OpenAPI document: 2.0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-body-amount-all-of.mjs

@@ -0,0 +1,13 @@
+/**
+ * Vality Payments API
+ * ## Description API is designed for the merchants who accept payments via user interface such as a website or a mobile app and it is the only interaction point with the system for goods and services payment transactions. ## Interaction details Whenever an API is accessed, its unique ID must be passed in the header X-Request-ID of the corresponding request: ```  X-Request-ID: 37d735d4-0f42-4f05-89fa-eaa478fb5aa9 ``` ### Content type and coding The system accepts and returns data in JSON format and UTF-8 coding: ```   Content-Type: application/json; charset=utf-8 ``` ### Date formats The system accepts and returns timestamp values in the format date-time, described in [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339): ```   2017-01-01T00:00:00Z   2017-01-01T00:00:01+00:00 ``` ### Maximum request processing time Whenever an API is accessed, the time cutoff parameters, that define maximum request processing time of the transaction completion, can be passed in the header `X-Request-Deadline` of the corresponding request: ```  X-Request-Deadline: 10s ``` The system stops processing the request upon the specified time. It is recommended to specify a value that is not more than one minute and not less than three seconds. `X-Request-Deadline` can be:  * specified in the format `date-time` according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative values: in milliseconds (`150000ms`), in seconds (`540s`) or in minutes (`3.5m`).
+ *
+ * The version of the OpenAPI document: 2.0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-body-amount.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-body-total-all-of.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-body-total.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-fee-fixed-all-of.mjs

@@ -0,0 +1,13 @@
+/**
+ * Vality Payments API
+ * ## Description API is designed for the merchants who accept payments via user interface such as a website or a mobile app and it is the only interaction point with the system for goods and services payment transactions. ## Interaction details Whenever an API is accessed, its unique ID must be passed in the header X-Request-ID of the corresponding request: ```  X-Request-ID: 37d735d4-0f42-4f05-89fa-eaa478fb5aa9 ``` ### Content type and coding The system accepts and returns data in JSON format and UTF-8 coding: ```   Content-Type: application/json; charset=utf-8 ``` ### Date formats The system accepts and returns timestamp values in the format date-time, described in [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339): ```   2017-01-01T00:00:00Z   2017-01-01T00:00:01+00:00 ``` ### Maximum request processing time Whenever an API is accessed, the time cutoff parameters, that define maximum request processing time of the transaction completion, can be passed in the header `X-Request-Deadline` of the corresponding request: ```  X-Request-Deadline: 10s ``` The system stops processing the request upon the specified time. It is recommended to specify a value that is not more than one minute and not less than three seconds. `X-Request-Deadline` can be:  * specified in the format `date-time` according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative values: in milliseconds (`150000ms`), in seconds (`540s`) or in minutes (`3.5m`).
+ *
+ * The version of the OpenAPI document: 2.0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-fee-fixed.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsb2NhdGlvbi1mZWUtZml4ZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWxpdHkvc3dhZy1wYXltZW50cy9zcmMvbGliL21vZGVsL2FsbG9jYXRpb24tZmVlLWZpeGVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFZhbGl0eSBQYXltZW50cyBBUElcbiAqICMjIERlc2NyaXB0aW9uIEFQSSBpcyBkZXNpZ25lZCBmb3IgdGhlIG1lcmNoYW50cyB3aG8gYWNjZXB0IHBheW1lbnRzIHZpYSB1c2VyIGludGVyZmFjZSBzdWNoIGFzIGEgd2Vic2l0ZSBvciBhIG1vYmlsZSBhcHAgYW5kIGl0IGlzIHRoZSBvbmx5IGludGVyYWN0aW9uIHBvaW50IHdpdGggdGhlIHN5c3RlbSBmb3IgZ29vZHMgYW5kIHNlcnZpY2VzIHBheW1lbnQgdHJhbnNhY3Rpb25zLiAjIyBJbnRlcmFjdGlvbiBkZXRhaWxzIFdoZW5ldmVyIGFuIEFQSSBpcyBhY2Nlc3NlZCwgaXRzIHVuaXF1ZSBJRCBtdXN0IGJlIHBhc3NlZCBpbiB0aGUgaGVhZGVyIFgtUmVxdWVzdC1JRCBvZiB0aGUgY29ycmVzcG9uZGluZyByZXF1ZXN0OiBgYGAgIFgtUmVxdWVzdC1JRDogMzdkNzM1ZDQtMGY0Mi00ZjA1LTg5ZmEtZWFhNDc4ZmI1YWE5IGBgYCAjIyMgQ29udGVudCB0eXBlIGFuZCBjb2RpbmcgVGhlIHN5c3RlbSBhY2NlcHRzIGFuZCByZXR1cm5zIGRhdGEgaW4gSlNPTiBmb3JtYXQgYW5kIFVURi04IGNvZGluZzogYGBgICAgQ29udGVudC1UeXBlOiBhcHBsaWNhdGlvbi9qc29uOyBjaGFyc2V0PXV0Zi04IGBgYCAjIyMgRGF0ZSBmb3JtYXRzIFRoZSBzeXN0ZW0gYWNjZXB0cyBhbmQgcmV0dXJucyB0aW1lc3RhbXAgdmFsdWVzIGluIHRoZSBmb3JtYXQgZGF0ZS10aW1lLCBkZXNjcmliZWQgaW4gW1JGQyAzMzM5XShodHRwczovL2RhdGF0cmFja2VyLmlldGYub3JnL2RvYy9odG1sL3JmYzMzMzkpOiBgYGAgICAyMDE3LTAxLTAxVDAwOjAwOjAwWiAgIDIwMTctMDEtMDFUMDA6MDA6MDErMDA6MDAgYGBgICMjIyBNYXhpbXVtIHJlcXVlc3QgcHJvY2Vzc2luZyB0aW1lIFdoZW5ldmVyIGFuIEFQSSBpcyBhY2Nlc3NlZCwgdGhlIHRpbWUgY3V0b2ZmIHBhcmFtZXRlcnMsIHRoYXQgZGVmaW5lIG1heGltdW0gcmVxdWVzdCBwcm9jZXNzaW5nIHRpbWUgb2YgdGhlIHRyYW5zYWN0aW9uIGNvbXBsZXRpb24sIGNhbiBiZSBwYXNzZWQgaW4gdGhlIGhlYWRlciBgWC1SZXF1ZXN0LURlYWRsaW5lYCBvZiB0aGUgY29ycmVzcG9uZGluZyByZXF1ZXN0OiBgYGAgIFgtUmVxdWVzdC1EZWFkbGluZTogMTBzIGBgYCBUaGUgc3lzdGVtIHN0b3BzIHByb2Nlc3NpbmcgdGhlIHJlcXVlc3QgdXBvbiB0aGUgc3BlY2lmaWVkIHRpbWUuIEl0IGlzIHJlY29tbWVuZGVkIHRvIHNwZWNpZnkgYSB2YWx1ZSB0aGF0IGlzIG5vdCBtb3JlIHRoYW4gb25lIG1pbnV0ZSBhbmQgbm90IGxlc3MgdGhhbiB0aHJlZSBzZWNvbmRzLiBgWC1SZXF1ZXN0LURlYWRsaW5lYCBjYW4gYmU6ICAqIHNwZWNpZmllZCBpbiB0aGUgZm9ybWF0IGBkYXRlLXRpbWVgIGFjY29yZGluZyB0byBbUkZDIDMzMzldKGh0dHBzOi8vZGF0YXRyYWNrZXIuaWV0Zi5vcmcvZG9jL2h0bWwvcmZjMzMzOSk7ICogc3BlY2lmaWVkIGluIHJlbGF0aXZlIHZhbHVlczogaW4gbWlsbGlzZWNvbmRzIChgMTUwMDAwbXNgKSwgaW4gc2Vjb25kcyAoYDU0MHNgKSBvciBpbiBtaW51dGVzIChgMy41bWApLiBcbiAqXG4gKiBUaGUgdmVyc2lvbiBvZiB0aGUgT3BlbkFQSSBkb2N1bWVudDogMi4wLjFcbiAqIFxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgT3BlbkFQSSBHZW5lcmF0b3IgKGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaCkuXG4gKiBodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2hcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuaW1wb3J0IHsgQWxsb2NhdGlvbkZlZVRhcmdldCB9IGZyb20gJy4vYWxsb2NhdGlvbi1mZWUtdGFyZ2V0JztcbmltcG9ydCB7IEFsbG9jYXRpb25GZWUgfSBmcm9tICcuL2FsbG9jYXRpb24tZmVlJztcblxuXG4vKipcbiAqIFRyYW5zYWN0aW9uIGZlZSBpbiBhYnNvbHV0ZSB2YWx1ZXNcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBBbGxvY2F0aW9uRmVlRml4ZWQgZXh0ZW5kcyBBbGxvY2F0aW9uRmVlIHsgXG4gICAgLyoqXG4gICAgICogVGhlIHZhbHVlIG9mIHRoZSBmZWUgaW4gbWlub3IgbW9uZXRhcnkgdW5pdHMsIGUuZy4gY2VudHMgaWYgVVMgZG9sbGFycyBhcmUgc3BlY2lmaWVkIGFzIHRoZSB0cmFuc2FjdGlvbiBjdXJyZW5jeS4gXG4gICAgICovXG4gICAgYW1vdW50OiBudW1iZXI7XG59XG5leHBvcnQgbmFtZXNwYWNlIEFsbG9jYXRpb25GZWVGaXhlZCB7XG59XG5cblxuIl19

package/esm2020/lib/model/allocation-fee-share-all-of.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-fee-share.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-fee-target.mjs

@@ -0,0 +1,18 @@
+/**
+ * Vality Payments API
+ * ## Description API is designed for the merchants who accept payments via user interface such as a website or a mobile app and it is the only interaction point with the system for goods and services payment transactions. ## Interaction details Whenever an API is accessed, its unique ID must be passed in the header X-Request-ID of the corresponding request: ```  X-Request-ID: 37d735d4-0f42-4f05-89fa-eaa478fb5aa9 ``` ### Content type and coding The system accepts and returns data in JSON format and UTF-8 coding: ```   Content-Type: application/json; charset=utf-8 ``` ### Date formats The system accepts and returns timestamp values in the format date-time, described in [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339): ```   2017-01-01T00:00:00Z   2017-01-01T00:00:01+00:00 ``` ### Maximum request processing time Whenever an API is accessed, the time cutoff parameters, that define maximum request processing time of the transaction completion, can be passed in the header `X-Request-Deadline` of the corresponding request: ```  X-Request-Deadline: 10s ``` The system stops processing the request upon the specified time. It is recommended to specify a value that is not more than one minute and not less than three seconds. `X-Request-Deadline` can be:  * specified in the format `date-time` according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative values: in milliseconds (`150000ms`), in seconds (`540s`) or in minutes (`3.5m`).
+ *
+ * The version of the OpenAPI document: 2.0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export var AllocationFeeTarget;
+(function (AllocationFeeTarget) {
+    AllocationFeeTarget.AllocationTargetTypeEnum = {
+        AllocationTargetShop: 'AllocationTargetShop'
+    };
+})(AllocationFeeTarget || (AllocationFeeTarget = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-fee.mjs

@@ -0,0 +1,8 @@
+export var AllocationFee;
+(function (AllocationFee) {
+    AllocationFee.AllocationFeeTypeEnum = {
+        AllocationFeeFixed: 'AllocationFeeFixed',
+        AllocationFeeShare: 'AllocationFeeShare'
+    };
+})(AllocationFee || (AllocationFee = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-target-shop-all-of.mjs

@@ -0,0 +1,13 @@
+/**
+ * Vality Payments API
+ * ## Description API is designed for the merchants who accept payments via user interface such as a website or a mobile app and it is the only interaction point with the system for goods and services payment transactions. ## Interaction details Whenever an API is accessed, its unique ID must be passed in the header X-Request-ID of the corresponding request: ```  X-Request-ID: 37d735d4-0f42-4f05-89fa-eaa478fb5aa9 ``` ### Content type and coding The system accepts and returns data in JSON format and UTF-8 coding: ```   Content-Type: application/json; charset=utf-8 ``` ### Date formats The system accepts and returns timestamp values in the format date-time, described in [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339): ```   2017-01-01T00:00:00Z   2017-01-01T00:00:01+00:00 ``` ### Maximum request processing time Whenever an API is accessed, the time cutoff parameters, that define maximum request processing time of the transaction completion, can be passed in the header `X-Request-Deadline` of the corresponding request: ```  X-Request-Deadline: 10s ``` The system stops processing the request upon the specified time. It is recommended to specify a value that is not more than one minute and not less than three seconds. `X-Request-Deadline` can be:  * specified in the format `date-time` according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative values: in milliseconds (`150000ms`), in seconds (`540s`) or in minutes (`3.5m`).
+ *
+ * The version of the OpenAPI document: 2.0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-target-shop.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-target.mjs

@@ -0,0 +1,18 @@
+/**
+ * Vality Payments API
+ * ## Description API is designed for the merchants who accept payments via user interface such as a website or a mobile app and it is the only interaction point with the system for goods and services payment transactions. ## Interaction details Whenever an API is accessed, its unique ID must be passed in the header X-Request-ID of the corresponding request: ```  X-Request-ID: 37d735d4-0f42-4f05-89fa-eaa478fb5aa9 ``` ### Content type and coding The system accepts and returns data in JSON format and UTF-8 coding: ```   Content-Type: application/json; charset=utf-8 ``` ### Date formats The system accepts and returns timestamp values in the format date-time, described in [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339): ```   2017-01-01T00:00:00Z   2017-01-01T00:00:01+00:00 ``` ### Maximum request processing time Whenever an API is accessed, the time cutoff parameters, that define maximum request processing time of the transaction completion, can be passed in the header `X-Request-Deadline` of the corresponding request: ```  X-Request-Deadline: 10s ``` The system stops processing the request upon the specified time. It is recommended to specify a value that is not more than one minute and not less than three seconds. `X-Request-Deadline` can be:  * specified in the format `date-time` according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative values: in milliseconds (`150000ms`), in seconds (`540s`) or in minutes (`3.5m`).
+ *
+ * The version of the OpenAPI document: 2.0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export var AllocationTarget;
+(function (AllocationTarget) {
+    AllocationTarget.AllocationTargetTypeEnum = {
+        AllocationTargetShop: 'AllocationTargetShop'
+    };
+})(AllocationTarget || (AllocationTarget = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/allocation-transaction.mjs

@@ -0,0 +1,8 @@
+export var AllocationTransaction;
+(function (AllocationTransaction) {
+    AllocationTransaction.AllocationBodyTypeEnum = {
+        AllocationBodyAmount: 'AllocationBodyAmount',
+        AllocationBodyTotal: 'AllocationBodyTotal'
+    };
+})(AllocationTransaction || (AllocationTransaction = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/apple-pay-all-of.mjs

@@ -0,0 +1,13 @@
+/**
+ * Vality Payments API
+ * ## Description API is designed for the merchants who accept payments via user interface such as a website or a mobile app and it is the only interaction point with the system for goods and services payment transactions. ## Interaction details Whenever an API is accessed, its unique ID must be passed in the header X-Request-ID of the corresponding request: ```  X-Request-ID: 37d735d4-0f42-4f05-89fa-eaa478fb5aa9 ``` ### Content type and coding The system accepts and returns data in JSON format and UTF-8 coding: ```   Content-Type: application/json; charset=utf-8 ``` ### Date formats The system accepts and returns timestamp values in the format date-time, described in [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339): ```   2017-01-01T00:00:00Z   2017-01-01T00:00:01+00:00 ``` ### Maximum request processing time Whenever an API is accessed, the time cutoff parameters, that define maximum request processing time of the transaction completion, can be passed in the header `X-Request-Deadline` of the corresponding request: ```  X-Request-Deadline: 10s ``` The system stops processing the request upon the specified time. It is recommended to specify a value that is not more than one minute and not less than three seconds. `X-Request-Deadline` can be:  * specified in the format `date-time` according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative values: in milliseconds (`150000ms`), in seconds (`540s`) or in minutes (`3.5m`).
+ *
+ * The version of the OpenAPI document: 2.0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/apple-pay.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/articles-of-association.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/bank-account.mjs

@@ -0,0 +1,13 @@
+/**
+ * Vality Payments API
+ * ## Description API is designed for the merchants who accept payments via user interface such as a website or a mobile app and it is the only interaction point with the system for goods and services payment transactions. ## Interaction details Whenever an API is accessed, its unique ID must be passed in the header X-Request-ID of the corresponding request: ```  X-Request-ID: 37d735d4-0f42-4f05-89fa-eaa478fb5aa9 ``` ### Content type and coding The system accepts and returns data in JSON format and UTF-8 coding: ```   Content-Type: application/json; charset=utf-8 ``` ### Date formats The system accepts and returns timestamp values in the format date-time, described in [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339): ```   2017-01-01T00:00:00Z   2017-01-01T00:00:01+00:00 ``` ### Maximum request processing time Whenever an API is accessed, the time cutoff parameters, that define maximum request processing time of the transaction completion, can be passed in the header `X-Request-Deadline` of the corresponding request: ```  X-Request-Deadline: 10s ``` The system stops processing the request upon the specified time. It is recommended to specify a value that is not more than one minute and not less than three seconds. `X-Request-Deadline` can be:  * specified in the format `date-time` according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative values: in milliseconds (`150000ms`), in seconds (`540s`) or in minutes (`3.5m`).
+ *
+ * The version of the OpenAPI document: 2.0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFuay1hY2NvdW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdmFsaXR5L3N3YWctcGF5bWVudHMvc3JjL2xpYi9tb2RlbC9iYW5rLWFjY291bnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7R0FVRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVmFsaXR5IFBheW1lbnRzIEFQSVxuICogIyMgRGVzY3JpcHRpb24gQVBJIGlzIGRlc2lnbmVkIGZvciB0aGUgbWVyY2hhbnRzIHdobyBhY2NlcHQgcGF5bWVudHMgdmlhIHVzZXIgaW50ZXJmYWNlIHN1Y2ggYXMgYSB3ZWJzaXRlIG9yIGEgbW9iaWxlIGFwcCBhbmQgaXQgaXMgdGhlIG9ubHkgaW50ZXJhY3Rpb24gcG9pbnQgd2l0aCB0aGUgc3lzdGVtIGZvciBnb29kcyBhbmQgc2VydmljZXMgcGF5bWVudCB0cmFuc2FjdGlvbnMuICMjIEludGVyYWN0aW9uIGRldGFpbHMgV2hlbmV2ZXIgYW4gQVBJIGlzIGFjY2Vzc2VkLCBpdHMgdW5pcXVlIElEIG11c3QgYmUgcGFzc2VkIGluIHRoZSBoZWFkZXIgWC1SZXF1ZXN0LUlEIG9mIHRoZSBjb3JyZXNwb25kaW5nIHJlcXVlc3Q6IGBgYCAgWC1SZXF1ZXN0LUlEOiAzN2Q3MzVkNC0wZjQyLTRmMDUtODlmYS1lYWE0NzhmYjVhYTkgYGBgICMjIyBDb250ZW50IHR5cGUgYW5kIGNvZGluZyBUaGUgc3lzdGVtIGFjY2VwdHMgYW5kIHJldHVybnMgZGF0YSBpbiBKU09OIGZvcm1hdCBhbmQgVVRGLTggY29kaW5nOiBgYGAgICBDb250ZW50LVR5cGU6IGFwcGxpY2F0aW9uL2pzb247IGNoYXJzZXQ9dXRmLTggYGBgICMjIyBEYXRlIGZvcm1hdHMgVGhlIHN5c3RlbSBhY2NlcHRzIGFuZCByZXR1cm5zIHRpbWVzdGFtcCB2YWx1ZXMgaW4gdGhlIGZvcm1hdCBkYXRlLXRpbWUsIGRlc2NyaWJlZCBpbiBbUkZDIDMzMzldKGh0dHBzOi8vZGF0YXRyYWNrZXIuaWV0Zi5vcmcvZG9jL2h0bWwvcmZjMzMzOSk6IGBgYCAgIDIwMTctMDEtMDFUMDA6MDA6MDBaICAgMjAxNy0wMS0wMVQwMDowMDowMSswMDowMCBgYGAgIyMjIE1heGltdW0gcmVxdWVzdCBwcm9jZXNzaW5nIHRpbWUgV2hlbmV2ZXIgYW4gQVBJIGlzIGFjY2Vzc2VkLCB0aGUgdGltZSBjdXRvZmYgcGFyYW1ldGVycywgdGhhdCBkZWZpbmUgbWF4aW11bSByZXF1ZXN0IHByb2Nlc3NpbmcgdGltZSBvZiB0aGUgdHJhbnNhY3Rpb24gY29tcGxldGlvbiwgY2FuIGJlIHBhc3NlZCBpbiB0aGUgaGVhZGVyIGBYLVJlcXVlc3QtRGVhZGxpbmVgIG9mIHRoZSBjb3JyZXNwb25kaW5nIHJlcXVlc3Q6IGBgYCAgWC1SZXF1ZXN0LURlYWRsaW5lOiAxMHMgYGBgIFRoZSBzeXN0ZW0gc3RvcHMgcHJvY2Vzc2luZyB0aGUgcmVxdWVzdCB1cG9uIHRoZSBzcGVjaWZpZWQgdGltZS4gSXQgaXMgcmVjb21tZW5kZWQgdG8gc3BlY2lmeSBhIHZhbHVlIHRoYXQgaXMgbm90IG1vcmUgdGhhbiBvbmUgbWludXRlIGFuZCBub3QgbGVzcyB0aGFuIHRocmVlIHNlY29uZHMuIGBYLVJlcXVlc3QtRGVhZGxpbmVgIGNhbiBiZTogICogc3BlY2lmaWVkIGluIHRoZSBmb3JtYXQgYGRhdGUtdGltZWAgYWNjb3JkaW5nIHRvIFtSRkMgMzMzOV0oaHR0cHM6Ly9kYXRhdHJhY2tlci5pZXRmLm9yZy9kb2MvaHRtbC9yZmMzMzM5KTsgKiBzcGVjaWZpZWQgaW4gcmVsYXRpdmUgdmFsdWVzOiBpbiBtaWxsaXNlY29uZHMgKGAxNTAwMDBtc2ApLCBpbiBzZWNvbmRzIChgNTQwc2ApIG9yIGluIG1pbnV0ZXMgKGAzLjVtYCkuIFxuICpcbiAqIFRoZSB2ZXJzaW9uIG9mIHRoZSBPcGVuQVBJIGRvY3VtZW50OiAyLjAuMVxuICogXG4gKlxuICogTk9URTogVGhpcyBjbGFzcyBpcyBhdXRvIGdlbmVyYXRlZCBieSBPcGVuQVBJIEdlbmVyYXRvciAoaHR0cHM6Ly9vcGVuYXBpLWdlbmVyYXRvci50ZWNoKS5cbiAqIGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaFxuICogRG8gbm90IGVkaXQgdGhlIGNsYXNzIG1hbnVhbGx5LlxuICovXG5cblxuLyoqXG4gKiBEYXRhIG9mIGEgc2V0dGxlbWVudCBhY2NvdW50IGluIGEgYmFua2luZyBvcmdhbml6YXRpb24gb3BlcmF0aW5nIHVuZGVyIHRoZSBqdXJpc2RpY3Rpb24gb2YgdGhlIFJ1c3NpYW4gRmVkZXJhdGlvbi4gXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQmFua0FjY291bnQgeyBcbiAgICAvKipcbiAgICAgKiBBY2NvdW50IG51bWJlclxuICAgICAqL1xuICAgIGFjY291bnQ6IHN0cmluZztcbiAgICAvKipcbiAgICAgKiBOYW1lIG9mIHRoZSBsZWdhbCBlbnRpdHkgb2YgdGhlIGJhbmtpbmcgb3JnYW5pemF0aW9uXG4gICAgICovXG4gICAgYmFua05hbWU6IHN0cmluZztcbiAgICBiYW5rUG9zdEFjY291bnQ6IHN0cmluZztcbiAgICAvKipcbiAgICAgKiBCSUsgb2YgdGhlIGJhbmtpbmcgb3JnYW5pemF0aW9uXG4gICAgICovXG4gICAgYmFua0Jpazogc3RyaW5nO1xufVxuXG4iXX0=

package/esm2020/lib/model/bank-card-all-of-token-provider-data.mjs

@@ -0,0 +1,19 @@
+/**
+ * Vality Payments API
+ * ## Description API is designed for the merchants who accept payments via user interface such as a website or a mobile app and it is the only interaction point with the system for goods and services payment transactions. ## Interaction details Whenever an API is accessed, its unique ID must be passed in the header X-Request-ID of the corresponding request: ```  X-Request-ID: 37d735d4-0f42-4f05-89fa-eaa478fb5aa9 ``` ### Content type and coding The system accepts and returns data in JSON format and UTF-8 coding: ```   Content-Type: application/json; charset=utf-8 ``` ### Date formats The system accepts and returns timestamp values in the format date-time, described in [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339): ```   2017-01-01T00:00:00Z   2017-01-01T00:00:01+00:00 ``` ### Maximum request processing time Whenever an API is accessed, the time cutoff parameters, that define maximum request processing time of the transaction completion, can be passed in the header `X-Request-Deadline` of the corresponding request: ```  X-Request-Deadline: 10s ``` The system stops processing the request upon the specified time. It is recommended to specify a value that is not more than one minute and not less than three seconds. `X-Request-Deadline` can be:  * specified in the format `date-time` according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative values: in milliseconds (`150000ms`), in seconds (`540s`) or in minutes (`3.5m`).
+ *
+ * The version of the OpenAPI document: 2.0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export var BankCardAllOfTokenProviderData;
+(function (BankCardAllOfTokenProviderData) {
+    BankCardAllOfTokenProviderData.RealmEnum = {
+        Test: 'test',
+        Live: 'live'
+    };
+})(BankCardAllOfTokenProviderData || (BankCardAllOfTokenProviderData = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/bank-card-all-of.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/bank-card-details.mjs

@@ -0,0 +1,19 @@
+/**
+ * Vality Payments API
+ * ## Description API is designed for the merchants who accept payments via user interface such as a website or a mobile app and it is the only interaction point with the system for goods and services payment transactions. ## Interaction details Whenever an API is accessed, its unique ID must be passed in the header X-Request-ID of the corresponding request: ```  X-Request-ID: 37d735d4-0f42-4f05-89fa-eaa478fb5aa9 ``` ### Content type and coding The system accepts and returns data in JSON format and UTF-8 coding: ```   Content-Type: application/json; charset=utf-8 ``` ### Date formats The system accepts and returns timestamp values in the format date-time, described in [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339): ```   2017-01-01T00:00:00Z   2017-01-01T00:00:01+00:00 ``` ### Maximum request processing time Whenever an API is accessed, the time cutoff parameters, that define maximum request processing time of the transaction completion, can be passed in the header `X-Request-Deadline` of the corresponding request: ```  X-Request-Deadline: 10s ``` The system stops processing the request upon the specified time. It is recommended to specify a value that is not more than one minute and not less than three seconds. `X-Request-Deadline` can be:  * specified in the format `date-time` according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative values: in milliseconds (`150000ms`), in seconds (`540s`) or in minutes (`3.5m`).
+ *
+ * The version of the OpenAPI document: 2.0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export var BankCardDetails;
+(function (BankCardDetails) {
+    BankCardDetails.TokenizationMethodEnum = {
+        Dpan: 'dpan',
+        None: 'none'
+    };
+})(BankCardDetails || (BankCardDetails = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/bank-card-token-provider-data.mjs

@@ -0,0 +1,19 @@
+/**
+ * Vality Payments API
+ * ## Description API is designed for the merchants who accept payments via user interface such as a website or a mobile app and it is the only interaction point with the system for goods and services payment transactions. ## Interaction details Whenever an API is accessed, its unique ID must be passed in the header X-Request-ID of the corresponding request: ```  X-Request-ID: 37d735d4-0f42-4f05-89fa-eaa478fb5aa9 ``` ### Content type and coding The system accepts and returns data in JSON format and UTF-8 coding: ```   Content-Type: application/json; charset=utf-8 ``` ### Date formats The system accepts and returns timestamp values in the format date-time, described in [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339): ```   2017-01-01T00:00:00Z   2017-01-01T00:00:01+00:00 ``` ### Maximum request processing time Whenever an API is accessed, the time cutoff parameters, that define maximum request processing time of the transaction completion, can be passed in the header `X-Request-Deadline` of the corresponding request: ```  X-Request-Deadline: 10s ``` The system stops processing the request upon the specified time. It is recommended to specify a value that is not more than one minute and not less than three seconds. `X-Request-Deadline` can be:  * specified in the format `date-time` according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative values: in milliseconds (`150000ms`), in seconds (`540s`) or in minutes (`3.5m`).
+ *
+ * The version of the OpenAPI document: 2.0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export var BankCardTokenProviderData;
+(function (BankCardTokenProviderData) {
+    BankCardTokenProviderData.RealmEnum = {
+        Test: 'test',
+        Live: 'live'
+    };
+})(BankCardTokenProviderData || (BankCardTokenProviderData = {}));
+//# sourceMappingURL=data:application/json;base64,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