ultracart_rest_api_v2_typescript 3.10.152 → 3.10.154

package/README.md

@@ -1,4 +1,4 @@
-## ultracart_rest_api_v2_typescript@3.10.152
+## ultracart_rest_api_v2_typescript@3.10.154
 
 This generator creates TypeScript/JavaScript client that utilizes [Fetch API](https://fetch.spec.whatwg.org/). The generated Node module can be used in the following environments:
 
@@ -36,7 +36,7 @@ navigate to the folder of your consuming project and run one of the following co
 _published:_
 
 ```
-npm install ultracart_rest_api_v2_typescript@3.10.152 --save
+npm install ultracart_rest_api_v2_typescript@3.10.154 --save
 ```
 
 _unPublished (not recommended):_
@@ -54,6 +54,8 @@ Not every change is committed to every SDK.
 
 | Version | Date | Comments |
 | --: | :-: | --- |
+| 3.10.154 | 08/14/2023 | esp - add require_order_within_last to the settings object |
+| 3.10.153 | 08/14/2023 | esp - expose rate limiter values in settings object |
 | 3.10.152 | 07/27/2023 | dw bi - add settings to the report and page objects |
 | 3.10.151 | 07/19/2023 | dw bi - add data_source_uuid to filter connection obj |
 | 3.10.150 | 07/19/2023 | dw bi - add data_source_uuid to page visualization obj |

package/api.ts

@@ -18999,6 +18999,24 @@ export interface EmailSendingDomainsResponse {
  * @interface EmailSettings
  */
 export interface EmailSettings {
+    /**
+     * Emails per day allowed
+     * @type {number}
+     * @memberof EmailSettings
+     */
+    emails_per_day?: number;
+    /**
+     * Emails per hour allowed
+     * @type {number}
+     * @memberof EmailSettings
+     */
+    emails_per_hour?: number;
+    /**
+     * Emails per month allowed
+     * @type {number}
+     * @memberof EmailSettings
+     */
+    emails_per_month?: number;
     /**
      * 
      * @type {string}
@@ -19053,6 +19071,12 @@ export interface EmailSettings {
      * @memberof EmailSettings
      */
     postcard_from_state?: string;
+    /**
+     * Require order within last
+     * @type {number}
+     * @memberof EmailSettings
+     */
+    require_order_within_last?: number;
     /**
      * True if the Reviews.io integration is configured
      * @type {boolean}
@@ -33135,6 +33159,52 @@ export interface OrderUtm {
     wbraid?: string;
 }
 
+/**
+ * 
+ * @export
+ * @interface OrderValidationRequest
+ */
+export interface OrderValidationRequest {
+    /**
+     * Checks to perform
+     * @type {Array<string>}
+     * @memberof OrderValidationRequest
+     */
+    checks?: Array<string>;
+    /**
+     * 
+     * @type {Order}
+     * @memberof OrderValidationRequest
+     */
+    order?: Order;
+}
+
+/**
+ * 
+ * @export
+ * @interface OrderValidationResponse
+ */
+export interface OrderValidationResponse {
+    /**
+     * Errors to display to the merchant if they failed any of the validations checked
+     * @type {Array<string>}
+     * @memberof OrderValidationResponse
+     */
+    errors?: Array<string>;
+    /**
+     * Informational messages
+     * @type {Array<string>}
+     * @memberof OrderValidationResponse
+     */
+    messages?: Array<string>;
+    /**
+     * If true, this order was updated during the validation call.  This may happen during address standardization fixes.
+     * @type {boolean}
+     * @memberof OrderValidationResponse
+     */
+    order_was_updated?: boolean;
+}
+
 /**
  * 
  * @export
@@ -63117,6 +63187,61 @@ export const OrderApiFetchParamCreator = function (configuration?: Configuration
             const needsSerialization = (<any>"Order" !== "string") || localVarRequestOptions.headers['Content-Type'] === 'application/json';
             localVarRequestOptions.body =  needsSerialization ? JSON.stringify(order || {}) : (order || "");
 
+            return {
+                url: url.format(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions. 
+         * @summary Validate
+         * @param {OrderValidationRequest} validation_request Validation request
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        validateOrder(validation_request: OrderValidationRequest, options: any = {}): FetchArgs {
+            // verify required parameter 'validation_request' is not null or undefined
+            if (validation_request === null || validation_request === undefined) {
+                throw new RequiredError('validation_request','Required parameter validation_request was null or undefined when calling validateOrder.');
+            }
+            const localVarPath = `/order/validate`;
+            const localVarUrlObj = url.parse(localVarPath, true);
+            const localVarRequestOptions = Object.assign({ method: 'POST' }, options);
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+    if(configuration && configuration.apiVersion) {
+      localVarHeaderParameter["X-UltraCart-Api-Version"] = configuration.apiVersion;
+    }
+
+
+
+            // authentication ultraCartOauth required
+            // oauth required
+            if (configuration && configuration.accessToken) {
+				const localVarAccessTokenValue = typeof configuration.accessToken === 'function'
+					? configuration.accessToken("ultraCartOauth", ["order_read", "order_write"])
+					: configuration.accessToken;
+                localVarHeaderParameter["Authorization"] = "Bearer " + localVarAccessTokenValue;
+            }
+
+            // authentication ultraCartSimpleApiKey required
+            if (configuration && configuration.apiKey) {
+                const localVarApiKeyValue = typeof configuration.apiKey === 'function'
+					? configuration.apiKey("x-ultracart-simple-key")
+					: configuration.apiKey;
+                localVarHeaderParameter["x-ultracart-simple-key"] = localVarApiKeyValue;
+            }
+
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            localVarUrlObj.query = Object.assign({}, localVarUrlObj.query, localVarQueryParameter, options.query);
+            // fix override query string Detail: https://stackoverflow.com/a/7517673/1077943
+            delete localVarUrlObj.search;
+            localVarRequestOptions.headers = Object.assign({}, localVarHeaderParameter, options.headers);
+            const needsSerialization = (<any>"OrderValidationRequest" !== "string") || localVarRequestOptions.headers['Content-Type'] === 'application/json';
+            localVarRequestOptions.body =  needsSerialization ? JSON.stringify(validation_request || {}) : (validation_request || "");
+
             return {
                 url: url.format(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -63733,6 +63858,27 @@ export const OrderApiFp = function(configuration?: Configuration) {
                 });
             };
         },
+        /**
+         * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions. 
+         * @summary Validate
+         * @param {OrderValidationRequest} validation_request Validation request
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        validateOrder(validation_request: OrderValidationRequest, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise<OrderValidationResponse> {
+            const localVarFetchArgs = OrderApiFetchParamCreator(configuration).validateOrder(validation_request, options);
+            return (fetch: FetchAPI = portableFetch, basePath: string = BASE_PATH) => {
+                return fetch(basePath + localVarFetchArgs.url, localVarFetchArgs.options).then((response) => {
+
+                    if (response.status >= 200 && response.status < 300) {
+                      return response.json();
+                      
+                    } else {
+                        throw response;
+                    }
+                });
+            };
+        },
     }
 };
 
@@ -64058,6 +64204,16 @@ export const OrderApiFactory = function (configuration?: Configuration, fetch?:
         updateOrder(order: Order, order_id: string, _expand?: string, options?: any) {
             return OrderApiFp(configuration).updateOrder(order, order_id, _expand, options)(fetch, basePath);
         },
+        /**
+         * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions. 
+         * @summary Validate
+         * @param {OrderValidationRequest} validation_request Validation request
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        validateOrder(validation_request: OrderValidationRequest, options?: any) {
+            return OrderApiFp(configuration).validateOrder(validation_request, options)(fetch, basePath);
+        },
     };
 };
 
@@ -64383,6 +64539,16 @@ export interface OrderApiInterface {
      */
     updateOrder(order: Order, order_id: string, _expand?: string, options?: any): Promise<OrderResponse>;
 
+    /**
+     * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions. 
+     * @summary Validate
+     * @param {OrderValidationRequest} validation_request Validation request
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof OrderApiInterface
+     */
+    validateOrder(validation_request: OrderValidationRequest, options?: any): Promise<OrderValidationResponse>;
+
 }
 
 /**
@@ -64760,6 +64926,18 @@ export class OrderApi extends BaseAPI implements OrderApiInterface {
         return OrderApiFp(this.configuration).updateOrder(order, order_id, _expand, options)(this.fetch, this.basePath);
     }
 
+    /**
+     * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions. 
+     * @summary Validate
+     * @param {OrderValidationRequest} validation_request Validation request
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof OrderApi
+     */
+    public validateOrder(validation_request: OrderValidationRequest, options?: any) {
+        return OrderApiFp(this.configuration).validateOrder(validation_request, options)(this.fetch, this.basePath);
+    }
+
 }
 
 /**

package/dist/api.d.ts

@@ -18570,6 +18570,24 @@ export interface EmailSendingDomainsResponse {
  * @interface EmailSettings
  */
 export interface EmailSettings {
+    /**
+     * Emails per day allowed
+     * @type {number}
+     * @memberof EmailSettings
+     */
+    emails_per_day?: number;
+    /**
+     * Emails per hour allowed
+     * @type {number}
+     * @memberof EmailSettings
+     */
+    emails_per_hour?: number;
+    /**
+     * Emails per month allowed
+     * @type {number}
+     * @memberof EmailSettings
+     */
+    emails_per_month?: number;
     /**
      *
      * @type {string}
@@ -18624,6 +18642,12 @@ export interface EmailSettings {
      * @memberof EmailSettings
      */
     postcard_from_state?: string;
+    /**
+     * Require order within last
+     * @type {number}
+     * @memberof EmailSettings
+     */
+    require_order_within_last?: number;
     /**
      * True if the Reviews.io integration is configured
      * @type {boolean}
@@ -32444,6 +32468,50 @@ export interface OrderUtm {
      */
     wbraid?: string;
 }
+/**
+ *
+ * @export
+ * @interface OrderValidationRequest
+ */
+export interface OrderValidationRequest {
+    /**
+     * Checks to perform
+     * @type {Array<string>}
+     * @memberof OrderValidationRequest
+     */
+    checks?: Array<string>;
+    /**
+     *
+     * @type {Order}
+     * @memberof OrderValidationRequest
+     */
+    order?: Order;
+}
+/**
+ *
+ * @export
+ * @interface OrderValidationResponse
+ */
+export interface OrderValidationResponse {
+    /**
+     * Errors to display to the merchant if they failed any of the validations checked
+     * @type {Array<string>}
+     * @memberof OrderValidationResponse
+     */
+    errors?: Array<string>;
+    /**
+     * Informational messages
+     * @type {Array<string>}
+     * @memberof OrderValidationResponse
+     */
+    messages?: Array<string>;
+    /**
+     * If true, this order was updated during the validation call.  This may happen during address standardization fixes.
+     * @type {boolean}
+     * @memberof OrderValidationResponse
+     */
+    order_was_updated?: boolean;
+}
 /**
  *
  * @export
@@ -48674,6 +48742,14 @@ export declare const OrderApiFetchParamCreator: (configuration?: Configuration)
      * @throws {RequiredError}
      */
     updateOrder(order: Order, order_id: string, _expand?: string, options?: any): FetchArgs;
+    /**
+     * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions.
+     * @summary Validate
+     * @param {OrderValidationRequest} validation_request Validation request
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    validateOrder(validation_request: OrderValidationRequest, options?: any): FetchArgs;
 };
 /**
  * OrderApi - functional programming interface
@@ -48944,6 +49020,14 @@ export declare const OrderApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     updateOrder(order: Order, order_id: string, _expand?: string, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise<OrderResponse>;
+    /**
+     * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions.
+     * @summary Validate
+     * @param {OrderValidationRequest} validation_request Validation request
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    validateOrder(validation_request: OrderValidationRequest, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise<OrderValidationResponse>;
 };
 /**
  * OrderApi - factory interface
@@ -49214,6 +49298,14 @@ export declare const OrderApiFactory: (configuration?: Configuration, fetch?: Fe
      * @throws {RequiredError}
      */
     updateOrder(order: Order, order_id: string, _expand?: string, options?: any): Promise<OrderResponse>;
+    /**
+     * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions.
+     * @summary Validate
+     * @param {OrderValidationRequest} validation_request Validation request
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    validateOrder(validation_request: OrderValidationRequest, options?: any): Promise<OrderValidationResponse>;
 };
 /**
  * OrderApi - interface
@@ -49511,6 +49603,15 @@ export interface OrderApiInterface {
      * @memberof OrderApiInterface
      */
     updateOrder(order: Order, order_id: string, _expand?: string, options?: any): Promise<OrderResponse>;
+    /**
+     * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions.
+     * @summary Validate
+     * @param {OrderValidationRequest} validation_request Validation request
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof OrderApiInterface
+     */
+    validateOrder(validation_request: OrderValidationRequest, options?: any): Promise<OrderValidationResponse>;
 }
 /**
  * OrderApi - object-oriented interface
@@ -49809,6 +49910,15 @@ export declare class OrderApi extends BaseAPI implements OrderApiInterface {
      * @memberof OrderApi
      */
     updateOrder(order: Order, order_id: string, _expand?: string, options?: any): Promise<OrderResponse>;
+    /**
+     * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions.
+     * @summary Validate
+     * @param {OrderValidationRequest} validation_request Validation request
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof OrderApi
+     */
+    validateOrder(validation_request: OrderValidationRequest, options?: any): Promise<OrderValidationResponse>;
 }
 /**
  * SsoApi - fetch parameter creator

package/dist/api.js

@@ -20587,6 +20587,54 @@ var OrderApiFetchParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions.
+         * @summary Validate
+         * @param {OrderValidationRequest} validation_request Validation request
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        validateOrder: function (validation_request, options) {
+            if (options === void 0) { options = {}; }
+            // verify required parameter 'validation_request' is not null or undefined
+            if (validation_request === null || validation_request === undefined) {
+                throw new RequiredError('validation_request', 'Required parameter validation_request was null or undefined when calling validateOrder.');
+            }
+            var localVarPath = "/order/validate";
+            var localVarUrlObj = url.parse(localVarPath, true);
+            var localVarRequestOptions = Object.assign({ method: 'POST' }, options);
+            var localVarHeaderParameter = {};
+            var localVarQueryParameter = {};
+            if (configuration && configuration.apiVersion) {
+                localVarHeaderParameter["X-UltraCart-Api-Version"] = configuration.apiVersion;
+            }
+            // authentication ultraCartOauth required
+            // oauth required
+            if (configuration && configuration.accessToken) {
+                var localVarAccessTokenValue = typeof configuration.accessToken === 'function'
+                    ? configuration.accessToken("ultraCartOauth", ["order_read", "order_write"])
+                    : configuration.accessToken;
+                localVarHeaderParameter["Authorization"] = "Bearer " + localVarAccessTokenValue;
+            }
+            // authentication ultraCartSimpleApiKey required
+            if (configuration && configuration.apiKey) {
+                var localVarApiKeyValue = typeof configuration.apiKey === 'function'
+                    ? configuration.apiKey("x-ultracart-simple-key")
+                    : configuration.apiKey;
+                localVarHeaderParameter["x-ultracart-simple-key"] = localVarApiKeyValue;
+            }
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            localVarUrlObj.query = Object.assign({}, localVarUrlObj.query, localVarQueryParameter, options.query);
+            // fix override query string Detail: https://stackoverflow.com/a/7517673/1077943
+            delete localVarUrlObj.search;
+            localVarRequestOptions.headers = Object.assign({}, localVarHeaderParameter, options.headers);
+            var needsSerialization = ("OrderValidationRequest" !== "string") || localVarRequestOptions.headers['Content-Type'] === 'application/json';
+            localVarRequestOptions.body = needsSerialization ? JSON.stringify(validation_request || {}) : (validation_request || "");
+            return {
+                url: url.format(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
     };
 };
 exports.OrderApiFetchParamCreator = OrderApiFetchParamCreator;
@@ -21224,6 +21272,28 @@ var OrderApiFp = function (configuration) {
                 });
             };
         },
+        /**
+         * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions.
+         * @summary Validate
+         * @param {OrderValidationRequest} validation_request Validation request
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        validateOrder: function (validation_request, options) {
+            var localVarFetchArgs = (0, exports.OrderApiFetchParamCreator)(configuration).validateOrder(validation_request, options);
+            return function (fetch, basePath) {
+                if (fetch === void 0) { fetch = portableFetch; }
+                if (basePath === void 0) { basePath = BASE_PATH; }
+                return fetch(basePath + localVarFetchArgs.url, localVarFetchArgs.options).then(function (response) {
+                    if (response.status >= 200 && response.status < 300) {
+                        return response.json();
+                    }
+                    else {
+                        throw response;
+                    }
+                });
+            };
+        },
     };
 };
 exports.OrderApiFp = OrderApiFp;
@@ -21549,6 +21619,16 @@ var OrderApiFactory = function (configuration, fetch, basePath) {
         updateOrder: function (order, order_id, _expand, options) {
             return (0, exports.OrderApiFp)(configuration).updateOrder(order, order_id, _expand, options)(fetch, basePath);
         },
+        /**
+         * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions.
+         * @summary Validate
+         * @param {OrderValidationRequest} validation_request Validation request
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        validateOrder: function (validation_request, options) {
+            return (0, exports.OrderApiFp)(configuration).validateOrder(validation_request, options)(fetch, basePath);
+        },
     };
 };
 exports.OrderApiFactory = OrderApiFactory;
@@ -21905,6 +21985,17 @@ var OrderApi = /** @class */ (function (_super) {
     OrderApi.prototype.updateOrder = function (order, order_id, _expand, options) {
         return (0, exports.OrderApiFp)(this.configuration).updateOrder(order, order_id, _expand, options)(this.fetch, this.basePath);
     };
+    /**
+     * Validate the order for errors.  Specific checks can be passed to fine tune what is validated. Read and write permissions are required because the validate method may fix obvious address issues automatically which require update permission.This rest call makes use of the built-in translation of rest objects to UltraCart internal objects which also contains a multitude of validation checks that cannot be trapped.  Therefore any time this call is made, you should also trap api exceptions and examine their content because it may contain validation issues.  So check the response object and trap any exceptions.
+     * @summary Validate
+     * @param {OrderValidationRequest} validation_request Validation request
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof OrderApi
+     */
+    OrderApi.prototype.validateOrder = function (validation_request, options) {
+        return (0, exports.OrderApiFp)(this.configuration).validateOrder(validation_request, options)(this.fetch, this.basePath);
+    };
     return OrderApi;
 }(BaseAPI));
 exports.OrderApi = OrderApi;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultracart_rest_api_v2_typescript",
-  "version": "3.10.152",
+  "version": "3.10.154",
   "description": "UltraCart Rest TypeScript SDK",
   "author": "UltraCart",
   "keywords": [