@huaweicloud/huaweicloud-sdk-cdn 3.1.23

package/v1/model/ListDomainsRequest.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListDomainsRequestServiceAreaEnum = exports.ListDomainsRequestDomainStatusEnum = exports.ListDomainsRequestBusinessTypeEnum = exports.ListDomainsRequest = void 0;
+var ListDomainsRequest = /** @class */ (function () {
+    function ListDomainsRequest() {
+    }
+    ListDomainsRequest.prototype.withDomainName = function (domainName) {
+        this['domain_name'] = domainName;
+        return this;
+    };
+    Object.defineProperty(ListDomainsRequest.prototype, "domainName", {
+        get: function () {
+            return this['domain_name'];
+        },
+        set: function (domainName) {
+            this['domain_name'] = domainName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ListDomainsRequest.prototype.withBusinessType = function (businessType) {
+        this['business_type'] = businessType;
+        return this;
+    };
+    Object.defineProperty(ListDomainsRequest.prototype, "businessType", {
+        get: function () {
+            return this['business_type'];
+        },
+        set: function (businessType) {
+            this['business_type'] = businessType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ListDomainsRequest.prototype.withDomainStatus = function (domainStatus) {
+        this['domain_status'] = domainStatus;
+        return this;
+    };
+    Object.defineProperty(ListDomainsRequest.prototype, "domainStatus", {
+        get: function () {
+            return this['domain_status'];
+        },
+        set: function (domainStatus) {
+            this['domain_status'] = domainStatus;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ListDomainsRequest.prototype.withServiceArea = function (serviceArea) {
+        this['service_area'] = serviceArea;
+        return this;
+    };
+    Object.defineProperty(ListDomainsRequest.prototype, "serviceArea", {
+        get: function () {
+            return this['service_area'];
+        },
+        set: function (serviceArea) {
+            this['service_area'] = serviceArea;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ListDomainsRequest.prototype.withPageSize = function (pageSize) {
+        this['page_size'] = pageSize;
+        return this;
+    };
+    Object.defineProperty(ListDomainsRequest.prototype, "pageSize", {
+        get: function () {
+            return this['page_size'];
+        },
+        set: function (pageSize) {
+            this['page_size'] = pageSize;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ListDomainsRequest.prototype.withPageNumber = function (pageNumber) {
+        this['page_number'] = pageNumber;
+        return this;
+    };
+    Object.defineProperty(ListDomainsRequest.prototype, "pageNumber", {
+        get: function () {
+            return this['page_number'];
+        },
+        set: function (pageNumber) {
+            this['page_number'] = pageNumber;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ListDomainsRequest.prototype.withEnterpriseProjectId = function (enterpriseProjectId) {
+        this['enterprise_project_id'] = enterpriseProjectId;
+        return this;
+    };
+    Object.defineProperty(ListDomainsRequest.prototype, "enterpriseProjectId", {
+        get: function () {
+            return this['enterprise_project_id'];
+        },
+        set: function (enterpriseProjectId) {
+            this['enterprise_project_id'] = enterpriseProjectId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ListDomainsRequest;
+}());
+exports.ListDomainsRequest = ListDomainsRequest;
+/**
+    * @export
+    * @enum {string}
+    */
+var ListDomainsRequestBusinessTypeEnum;
+(function (ListDomainsRequestBusinessTypeEnum) {
+    ListDomainsRequestBusinessTypeEnum["WEB"] = "web";
+    ListDomainsRequestBusinessTypeEnum["DOWNLOAD"] = "download";
+    ListDomainsRequestBusinessTypeEnum["VIDEO"] = "video";
+    ListDomainsRequestBusinessTypeEnum["WHOLESITE"] = "wholeSite";
+})(ListDomainsRequestBusinessTypeEnum = exports.ListDomainsRequestBusinessTypeEnum || (exports.ListDomainsRequestBusinessTypeEnum = {}));
+/**
+    * @export
+    * @enum {string}
+    */
+var ListDomainsRequestDomainStatusEnum;
+(function (ListDomainsRequestDomainStatusEnum) {
+    ListDomainsRequestDomainStatusEnum["ONLINE"] = "online";
+    ListDomainsRequestDomainStatusEnum["OFFLINE"] = "offline";
+    ListDomainsRequestDomainStatusEnum["CONFIGURING"] = "configuring";
+    ListDomainsRequestDomainStatusEnum["CONFIGURE_FAILED"] = "configure_failed";
+    ListDomainsRequestDomainStatusEnum["CHECKING"] = "checking";
+    ListDomainsRequestDomainStatusEnum["CHECK_FAILED"] = "check_failed";
+    ListDomainsRequestDomainStatusEnum["DELETING"] = "deleting";
+})(ListDomainsRequestDomainStatusEnum = exports.ListDomainsRequestDomainStatusEnum || (exports.ListDomainsRequestDomainStatusEnum = {}));
+/**
+    * @export
+    * @enum {string}
+    */
+var ListDomainsRequestServiceAreaEnum;
+(function (ListDomainsRequestServiceAreaEnum) {
+    ListDomainsRequestServiceAreaEnum["MAINLAND_CHINA"] = "mainland_china";
+    ListDomainsRequestServiceAreaEnum["OUTSIDE_MAINLAND_CHINA"] = "outside_mainland_china";
+    ListDomainsRequestServiceAreaEnum["GLOBAL"] = "global";
+})(ListDomainsRequestServiceAreaEnum = exports.ListDomainsRequestServiceAreaEnum || (exports.ListDomainsRequestServiceAreaEnum = {}));

package/v1/model/ListDomainsResponse.d.ts

@@ -0,0 +1,9 @@
+import { Domains } from './Domains';
+import { SdkResponse } from "@huaweicloud/huaweicloud-sdk-core/SdkResponse";
+export declare class ListDomainsResponse extends SdkResponse {
+    total?: number;
+    domains?: Array<Domains>;
+    constructor();
+    withTotal(total: number): ListDomainsResponse;
+    withDomains(domains: Array<Domains>): ListDomainsResponse;
+}

package/v1/model/ListDomainsResponse.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListDomainsResponse = void 0;
+var SdkResponse_1 = require("@huaweicloud/huaweicloud-sdk-core/SdkResponse");
+var ListDomainsResponse = /** @class */ (function (_super) {
+    __extends(ListDomainsResponse, _super);
+    function ListDomainsResponse() {
+        return _super.call(this) || this;
+    }
+    ListDomainsResponse.prototype.withTotal = function (total) {
+        this['total'] = total;
+        return this;
+    };
+    ListDomainsResponse.prototype.withDomains = function (domains) {
+        this['domains'] = domains;
+        return this;
+    };
+    return ListDomainsResponse;
+}(SdkResponse_1.SdkResponse));
+exports.ListDomainsResponse = ListDomainsResponse;

package/v1/model/LogObject.d.ts

@@ -0,0 +1,21 @@
+export declare class LogObject {
+    private 'domain_name'?;
+    private 'start_time'?;
+    private 'end_time'?;
+    name?: string;
+    size?: number;
+    link?: string;
+    constructor();
+    withDomainName(domainName: string): LogObject;
+    set domainName(domainName: string | undefined);
+    get domainName(): string | undefined;
+    withStartTime(startTime: number): LogObject;
+    set startTime(startTime: number | undefined);
+    get startTime(): number | undefined;
+    withEndTime(endTime: number): LogObject;
+    set endTime(endTime: number | undefined);
+    get endTime(): number | undefined;
+    withName(name: string): LogObject;
+    withSize(size: number): LogObject;
+    withLink(link: string): LogObject;
+}

package/v1/model/LogObject.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogObject = void 0;
+var LogObject = /** @class */ (function () {
+    function LogObject() {
+    }
+    LogObject.prototype.withDomainName = function (domainName) {
+        this['domain_name'] = domainName;
+        return this;
+    };
+    Object.defineProperty(LogObject.prototype, "domainName", {
+        get: function () {
+            return this['domain_name'];
+        },
+        set: function (domainName) {
+            this['domain_name'] = domainName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LogObject.prototype.withStartTime = function (startTime) {
+        this['start_time'] = startTime;
+        return this;
+    };
+    Object.defineProperty(LogObject.prototype, "startTime", {
+        get: function () {
+            return this['start_time'];
+        },
+        set: function (startTime) {
+            this['start_time'] = startTime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LogObject.prototype.withEndTime = function (endTime) {
+        this['end_time'] = endTime;
+        return this;
+    };
+    Object.defineProperty(LogObject.prototype, "endTime", {
+        get: function () {
+            return this['end_time'];
+        },
+        set: function (endTime) {
+            this['end_time'] = endTime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LogObject.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    LogObject.prototype.withSize = function (size) {
+        this['size'] = size;
+        return this;
+    };
+    LogObject.prototype.withLink = function (link) {
+        this['link'] = link;
+        return this;
+    };
+    return LogObject;
+}());
+exports.LogObject = LogObject;

package/v1/model/ModelMap.d.ts

@@ -0,0 +1,7 @@
+export declare class ModelMap {
+    key: string;
+    value?: string;
+    constructor(key?: any);
+    withKey(key: string): ModelMap;
+    withValue(value: string): ModelMap;
+}

package/v1/model/ModelMap.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelMap = void 0;
+var ModelMap = /** @class */ (function () {
+    function ModelMap(key) {
+        this['key'] = key;
+    }
+    ModelMap.prototype.withKey = function (key) {
+        this['key'] = key;
+        return this;
+    };
+    ModelMap.prototype.withValue = function (value) {
+        this['value'] = value;
+        return this;
+    };
+    return ModelMap;
+}());
+exports.ModelMap = ModelMap;

package/v1/model/ModifyDomainConfigRequestBody.d.ts

@@ -0,0 +1,6 @@
+import { Configs } from './Configs';
+export declare class ModifyDomainConfigRequestBody {
+    configs?: Configs;
+    constructor();
+    withConfigs(configs: Configs): ModifyDomainConfigRequestBody;
+}

package/v1/model/ModifyDomainConfigRequestBody.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModifyDomainConfigRequestBody = void 0;
+var ModifyDomainConfigRequestBody = /** @class */ (function () {
+    function ModifyDomainConfigRequestBody() {
+    }
+    ModifyDomainConfigRequestBody.prototype.withConfigs = function (configs) {
+        this['configs'] = configs;
+        return this;
+    };
+    return ModifyDomainConfigRequestBody;
+}());
+exports.ModifyDomainConfigRequestBody = ModifyDomainConfigRequestBody;

package/v1/model/OriginHostBody.d.ts

@@ -0,0 +1,19 @@
+export declare class OriginHostBody {
+    private 'origin_host_type';
+    private 'customize_domain'?;
+    constructor(originHostType?: any);
+    withOriginHostType(originHostType: OriginHostBodyOriginHostTypeEnum): OriginHostBody;
+    set originHostType(originHostType: OriginHostBodyOriginHostTypeEnum | undefined);
+    get originHostType(): OriginHostBodyOriginHostTypeEnum | undefined;
+    withCustomizeDomain(customizeDomain: string): OriginHostBody;
+    set customizeDomain(customizeDomain: string | undefined);
+    get customizeDomain(): string | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum OriginHostBodyOriginHostTypeEnum {
+    ACCELERATE = "accelerate",
+    CUSTOMIZE = "customize"
+}

package/v1/model/OriginHostBody.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OriginHostBodyOriginHostTypeEnum = exports.OriginHostBody = void 0;
+var OriginHostBody = /** @class */ (function () {
+    function OriginHostBody(originHostType) {
+        this['origin_host_type'] = originHostType;
+    }
+    OriginHostBody.prototype.withOriginHostType = function (originHostType) {
+        this['origin_host_type'] = originHostType;
+        return this;
+    };
+    Object.defineProperty(OriginHostBody.prototype, "originHostType", {
+        get: function () {
+            return this['origin_host_type'];
+        },
+        set: function (originHostType) {
+            this['origin_host_type'] = originHostType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OriginHostBody.prototype.withCustomizeDomain = function (customizeDomain) {
+        this['customize_domain'] = customizeDomain;
+        return this;
+    };
+    Object.defineProperty(OriginHostBody.prototype, "customizeDomain", {
+        get: function () {
+            return this['customize_domain'];
+        },
+        set: function (customizeDomain) {
+            this['customize_domain'] = customizeDomain;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return OriginHostBody;
+}());
+exports.OriginHostBody = OriginHostBody;
+/**
+    * @export
+    * @enum {string}
+    */
+var OriginHostBodyOriginHostTypeEnum;
+(function (OriginHostBodyOriginHostTypeEnum) {
+    OriginHostBodyOriginHostTypeEnum["ACCELERATE"] = "accelerate";
+    OriginHostBodyOriginHostTypeEnum["CUSTOMIZE"] = "customize";
+})(OriginHostBodyOriginHostTypeEnum = exports.OriginHostBodyOriginHostTypeEnum || (exports.OriginHostBodyOriginHostTypeEnum = {}));

package/v1/model/OriginHostRequest.d.ts

@@ -0,0 +1,8 @@
+import { OriginHostBody } from './OriginHostBody';
+export declare class OriginHostRequest {
+    private 'origin_host';
+    constructor(originHost?: any);
+    withOriginHost(originHost: OriginHostBody): OriginHostRequest;
+    set originHost(originHost: OriginHostBody | undefined);
+    get originHost(): OriginHostBody | undefined;
+}

package/v1/model/OriginHostRequest.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OriginHostRequest = void 0;
+var OriginHostRequest = /** @class */ (function () {
+    function OriginHostRequest(originHost) {
+        this['origin_host'] = originHost;
+    }
+    OriginHostRequest.prototype.withOriginHost = function (originHost) {
+        this['origin_host'] = originHost;
+        return this;
+    };
+    Object.defineProperty(OriginHostRequest.prototype, "originHost", {
+        get: function () {
+            return this['origin_host'];
+        },
+        set: function (originHost) {
+            this['origin_host'] = originHost;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return OriginHostRequest;
+}());
+exports.OriginHostRequest = OriginHostRequest;

package/v1/model/OriginRangeBody.d.ts

@@ -0,0 +1,19 @@
+export declare class OriginRangeBody {
+    private 'range_status'?;
+    private 'domain_id'?;
+    constructor();
+    withRangeStatus(rangeStatus: OriginRangeBodyRangeStatusEnum): OriginRangeBody;
+    set rangeStatus(rangeStatus: OriginRangeBodyRangeStatusEnum | undefined);
+    get rangeStatus(): OriginRangeBodyRangeStatusEnum | undefined;
+    withDomainId(domainId: string): OriginRangeBody;
+    set domainId(domainId: string | undefined);
+    get domainId(): string | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum OriginRangeBodyRangeStatusEnum {
+    OFF = "off",
+    ON = "on"
+}

package/v1/model/OriginRangeBody.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OriginRangeBodyRangeStatusEnum = exports.OriginRangeBody = void 0;
+var OriginRangeBody = /** @class */ (function () {
+    function OriginRangeBody() {
+    }
+    OriginRangeBody.prototype.withRangeStatus = function (rangeStatus) {
+        this['range_status'] = rangeStatus;
+        return this;
+    };
+    Object.defineProperty(OriginRangeBody.prototype, "rangeStatus", {
+        get: function () {
+            return this['range_status'];
+        },
+        set: function (rangeStatus) {
+            this['range_status'] = rangeStatus;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OriginRangeBody.prototype.withDomainId = function (domainId) {
+        this['domain_id'] = domainId;
+        return this;
+    };
+    Object.defineProperty(OriginRangeBody.prototype, "domainId", {
+        get: function () {
+            return this['domain_id'];
+        },
+        set: function (domainId) {
+            this['domain_id'] = domainId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return OriginRangeBody;
+}());
+exports.OriginRangeBody = OriginRangeBody;
+/**
+    * @export
+    * @enum {string}
+    */
+var OriginRangeBodyRangeStatusEnum;
+(function (OriginRangeBodyRangeStatusEnum) {
+    OriginRangeBodyRangeStatusEnum["OFF"] = "off";
+    OriginRangeBodyRangeStatusEnum["ON"] = "on";
+})(OriginRangeBodyRangeStatusEnum = exports.OriginRangeBodyRangeStatusEnum || (exports.OriginRangeBodyRangeStatusEnum = {}));

package/v1/model/OriginRequest.d.ts

@@ -0,0 +1,6 @@
+import { ResourceBody } from './ResourceBody';
+export declare class OriginRequest {
+    origin: ResourceBody;
+    constructor(origin?: any);
+    withOrigin(origin: ResourceBody): OriginRequest;
+}

package/v1/model/OriginRequest.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OriginRequest = void 0;
+var OriginRequest = /** @class */ (function () {
+    function OriginRequest(origin) {
+        this['origin'] = origin;
+    }
+    OriginRequest.prototype.withOrigin = function (origin) {
+        this['origin'] = origin;
+        return this;
+    };
+    return OriginRequest;
+}());
+exports.OriginRequest = OriginRequest;

package/v1/model/OriginRequestHeader.d.ts

@@ -0,0 +1,9 @@
+export declare class OriginRequestHeader {
+    name: string;
+    value?: string;
+    action: string;
+    constructor(name?: any, action?: any);
+    withName(name: string): OriginRequestHeader;
+    withValue(value: string): OriginRequestHeader;
+    withAction(action: string): OriginRequestHeader;
+}

package/v1/model/OriginRequestHeader.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OriginRequestHeader = void 0;
+var OriginRequestHeader = /** @class */ (function () {
+    function OriginRequestHeader(name, action) {
+        this['name'] = name;
+        this['action'] = action;
+    }
+    OriginRequestHeader.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    OriginRequestHeader.prototype.withValue = function (value) {
+        this['value'] = value;
+        return this;
+    };
+    OriginRequestHeader.prototype.withAction = function (action) {
+        this['action'] = action;
+        return this;
+    };
+    return OriginRequestHeader;
+}());
+exports.OriginRequestHeader = OriginRequestHeader;

package/v1/model/OriginRequestUrlRewrite.d.ts

@@ -0,0 +1,17 @@
+export declare class OriginRequestUrlRewrite {
+    priority: number;
+    private 'match_type';
+    private 'source_url'?;
+    private 'target_url';
+    constructor(priority?: any, matchType?: any, targetUrl?: any);
+    withPriority(priority: number): OriginRequestUrlRewrite;
+    withMatchType(matchType: string): OriginRequestUrlRewrite;
+    set matchType(matchType: string | undefined);
+    get matchType(): string | undefined;
+    withSourceUrl(sourceUrl: string): OriginRequestUrlRewrite;
+    set sourceUrl(sourceUrl: string | undefined);
+    get sourceUrl(): string | undefined;
+    withTargetUrl(targetUrl: string): OriginRequestUrlRewrite;
+    set targetUrl(targetUrl: string | undefined);
+    get targetUrl(): string | undefined;
+}

package/v1/model/OriginRequestUrlRewrite.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OriginRequestUrlRewrite = void 0;
+var OriginRequestUrlRewrite = /** @class */ (function () {
+    function OriginRequestUrlRewrite(priority, matchType, targetUrl) {
+        this['priority'] = priority;
+        this['match_type'] = matchType;
+        this['target_url'] = targetUrl;
+    }
+    OriginRequestUrlRewrite.prototype.withPriority = function (priority) {
+        this['priority'] = priority;
+        return this;
+    };
+    OriginRequestUrlRewrite.prototype.withMatchType = function (matchType) {
+        this['match_type'] = matchType;
+        return this;
+    };
+    Object.defineProperty(OriginRequestUrlRewrite.prototype, "matchType", {
+        get: function () {
+            return this['match_type'];
+        },
+        set: function (matchType) {
+            this['match_type'] = matchType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OriginRequestUrlRewrite.prototype.withSourceUrl = function (sourceUrl) {
+        this['source_url'] = sourceUrl;
+        return this;
+    };
+    Object.defineProperty(OriginRequestUrlRewrite.prototype, "sourceUrl", {
+        get: function () {
+            return this['source_url'];
+        },
+        set: function (sourceUrl) {
+            this['source_url'] = sourceUrl;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OriginRequestUrlRewrite.prototype.withTargetUrl = function (targetUrl) {
+        this['target_url'] = targetUrl;
+        return this;
+    };
+    Object.defineProperty(OriginRequestUrlRewrite.prototype, "targetUrl", {
+        get: function () {
+            return this['target_url'];
+        },
+        set: function (targetUrl) {
+            this['target_url'] = targetUrl;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return OriginRequestUrlRewrite;
+}());
+exports.OriginRequestUrlRewrite = OriginRequestUrlRewrite;

package/v1/model/PreheatingTaskRequest.d.ts

@@ -0,0 +1,8 @@
+import { PreheatingTaskRequestBody } from './PreheatingTaskRequestBody';
+export declare class PreheatingTaskRequest {
+    private 'preheating_task';
+    constructor(preheatingTask?: any);
+    withPreheatingTask(preheatingTask: PreheatingTaskRequestBody): PreheatingTaskRequest;
+    set preheatingTask(preheatingTask: PreheatingTaskRequestBody | undefined);
+    get preheatingTask(): PreheatingTaskRequestBody | undefined;
+}

package/v1/model/PreheatingTaskRequest.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreheatingTaskRequest = void 0;
+var PreheatingTaskRequest = /** @class */ (function () {
+    function PreheatingTaskRequest(preheatingTask) {
+        this['preheating_task'] = preheatingTask;
+    }
+    PreheatingTaskRequest.prototype.withPreheatingTask = function (preheatingTask) {
+        this['preheating_task'] = preheatingTask;
+        return this;
+    };
+    Object.defineProperty(PreheatingTaskRequest.prototype, "preheatingTask", {
+        get: function () {
+            return this['preheating_task'];
+        },
+        set: function (preheatingTask) {
+            this['preheating_task'] = preheatingTask;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return PreheatingTaskRequest;
+}());
+exports.PreheatingTaskRequest = PreheatingTaskRequest;

package/v1/model/PreheatingTaskRequestBody.d.ts

@@ -0,0 +1,5 @@
+export declare class PreheatingTaskRequestBody {
+    urls: Array<string>;
+    constructor(urls?: any);
+    withUrls(urls: Array<string>): PreheatingTaskRequestBody;
+}