@huaweicloud/huaweicloud-sdk-cdn 3.1.23

package/v1/model/Configs.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configs = void 0;
+var Configs = /** @class */ (function () {
+    function Configs() {
+    }
+    Configs.prototype.withOriginRequestHeader = function (originRequestHeader) {
+        this['origin_request_header'] = originRequestHeader;
+        return this;
+    };
+    Object.defineProperty(Configs.prototype, "originRequestHeader", {
+        get: function () {
+            return this['origin_request_header'];
+        },
+        set: function (originRequestHeader) {
+            this['origin_request_header'] = originRequestHeader;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Configs.prototype.withHttpResponseHeader = function (httpResponseHeader) {
+        this['http_response_header'] = httpResponseHeader;
+        return this;
+    };
+    Object.defineProperty(Configs.prototype, "httpResponseHeader", {
+        get: function () {
+            return this['http_response_header'];
+        },
+        set: function (httpResponseHeader) {
+            this['http_response_header'] = httpResponseHeader;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Configs.prototype.withUrlAuth = function (urlAuth) {
+        this['url_auth'] = urlAuth;
+        return this;
+    };
+    Object.defineProperty(Configs.prototype, "urlAuth", {
+        get: function () {
+            return this['url_auth'];
+        },
+        set: function (urlAuth) {
+            this['url_auth'] = urlAuth;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Configs.prototype.withHttps = function (https) {
+        this['https'] = https;
+        return this;
+    };
+    Configs.prototype.withSources = function (sources) {
+        this['sources'] = sources;
+        return this;
+    };
+    Configs.prototype.withOriginProtocol = function (originProtocol) {
+        this['origin_protocol'] = originProtocol;
+        return this;
+    };
+    Object.defineProperty(Configs.prototype, "originProtocol", {
+        get: function () {
+            return this['origin_protocol'];
+        },
+        set: function (originProtocol) {
+            this['origin_protocol'] = originProtocol;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Configs.prototype.withForceRedirect = function (forceRedirect) {
+        this['force_redirect'] = forceRedirect;
+        return this;
+    };
+    Object.defineProperty(Configs.prototype, "forceRedirect", {
+        get: function () {
+            return this['force_redirect'];
+        },
+        set: function (forceRedirect) {
+            this['force_redirect'] = forceRedirect;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Configs.prototype.withCompress = function (compress) {
+        this['compress'] = compress;
+        return this;
+    };
+    Configs.prototype.withCacheUrlParameterFilter = function (cacheUrlParameterFilter) {
+        this['cache_url_parameter_filter'] = cacheUrlParameterFilter;
+        return this;
+    };
+    Object.defineProperty(Configs.prototype, "cacheUrlParameterFilter", {
+        get: function () {
+            return this['cache_url_parameter_filter'];
+        },
+        set: function (cacheUrlParameterFilter) {
+            this['cache_url_parameter_filter'] = cacheUrlParameterFilter;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Configs.prototype.withIpv6Accelerate = function (ipv6Accelerate) {
+        this['ipv6_accelerate'] = ipv6Accelerate;
+        return this;
+    };
+    Object.defineProperty(Configs.prototype, "ipv6Accelerate", {
+        get: function () {
+            return this['ipv6_accelerate'];
+        },
+        set: function (ipv6Accelerate) {
+            this['ipv6_accelerate'] = ipv6Accelerate;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Configs.prototype.withErrorCodeCache = function (errorCodeCache) {
+        this['error_code_cache'] = errorCodeCache;
+        return this;
+    };
+    Object.defineProperty(Configs.prototype, "errorCodeCache", {
+        get: function () {
+            return this['error_code_cache'];
+        },
+        set: function (errorCodeCache) {
+            this['error_code_cache'] = errorCodeCache;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Configs.prototype.withOriginRangeStatus = function (originRangeStatus) {
+        this['origin_range_status'] = originRangeStatus;
+        return this;
+    };
+    Object.defineProperty(Configs.prototype, "originRangeStatus", {
+        get: function () {
+            return this['origin_range_status'];
+        },
+        set: function (originRangeStatus) {
+            this['origin_range_status'] = originRangeStatus;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Configs.prototype.withUserAgentFilter = function (userAgentFilter) {
+        this['user_agent_filter'] = userAgentFilter;
+        return this;
+    };
+    Object.defineProperty(Configs.prototype, "userAgentFilter", {
+        get: function () {
+            return this['user_agent_filter'];
+        },
+        set: function (userAgentFilter) {
+            this['user_agent_filter'] = userAgentFilter;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Configs.prototype.withOriginRequestUrlRewrite = function (originRequestUrlRewrite) {
+        this['origin_request_url_rewrite'] = originRequestUrlRewrite;
+        return this;
+    };
+    Object.defineProperty(Configs.prototype, "originRequestUrlRewrite", {
+        get: function () {
+            return this['origin_request_url_rewrite'];
+        },
+        set: function (originRequestUrlRewrite) {
+            this['origin_request_url_rewrite'] = originRequestUrlRewrite;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Configs.prototype.withErrorCodeRedirectRules = function (errorCodeRedirectRules) {
+        this['error_code_redirect_rules'] = errorCodeRedirectRules;
+        return this;
+    };
+    Object.defineProperty(Configs.prototype, "errorCodeRedirectRules", {
+        get: function () {
+            return this['error_code_redirect_rules'];
+        },
+        set: function (errorCodeRedirectRules) {
+            this['error_code_redirect_rules'] = errorCodeRedirectRules;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Configs;
+}());
+exports.Configs = Configs;

package/v1/model/ConfigsGetBody.d.ts

@@ -0,0 +1,69 @@
+import { CacheUrlParameterFilter } from './CacheUrlParameterFilter';
+import { Compress } from './Compress';
+import { ErrorCodeCache } from './ErrorCodeCache';
+import { ErrorCodeRedirectRules } from './ErrorCodeRedirectRules';
+import { ForceRedirectConfig } from './ForceRedirectConfig';
+import { HttpGetBody } from './HttpGetBody';
+import { HttpResponseHeader } from './HttpResponseHeader';
+import { OriginRequestHeader } from './OriginRequestHeader';
+import { OriginRequestUrlRewrite } from './OriginRequestUrlRewrite';
+import { SourcesConfig } from './SourcesConfig';
+import { UrlAuthGetBody } from './UrlAuthGetBody';
+import { UserAgentFilter } from './UserAgentFilter';
+export declare class ConfigsGetBody {
+    private 'origin_request_header'?;
+    private 'http_response_header'?;
+    private 'url_auth'?;
+    https?: HttpGetBody;
+    sources?: Array<SourcesConfig>;
+    private 'origin_protocol'?;
+    private 'force_redirect'?;
+    compress?: Compress;
+    private 'cache_url_parameter_filter'?;
+    private 'ipv6_accelerate'?;
+    private 'error_code_cache'?;
+    private 'origin_range_status'?;
+    private 'user_agent_filter'?;
+    private 'origin_request_url_rewrite'?;
+    private 'error_code_redirect_rules'?;
+    constructor();
+    withOriginRequestHeader(originRequestHeader: Array<OriginRequestHeader>): ConfigsGetBody;
+    set originRequestHeader(originRequestHeader: Array<OriginRequestHeader> | undefined);
+    get originRequestHeader(): Array<OriginRequestHeader> | undefined;
+    withHttpResponseHeader(httpResponseHeader: Array<HttpResponseHeader>): ConfigsGetBody;
+    set httpResponseHeader(httpResponseHeader: Array<HttpResponseHeader> | undefined);
+    get httpResponseHeader(): Array<HttpResponseHeader> | undefined;
+    withUrlAuth(urlAuth: UrlAuthGetBody): ConfigsGetBody;
+    set urlAuth(urlAuth: UrlAuthGetBody | undefined);
+    get urlAuth(): UrlAuthGetBody | undefined;
+    withHttps(https: HttpGetBody): ConfigsGetBody;
+    withSources(sources: Array<SourcesConfig>): ConfigsGetBody;
+    withOriginProtocol(originProtocol: string): ConfigsGetBody;
+    set originProtocol(originProtocol: string | undefined);
+    get originProtocol(): string | undefined;
+    withForceRedirect(forceRedirect: ForceRedirectConfig): ConfigsGetBody;
+    set forceRedirect(forceRedirect: ForceRedirectConfig | undefined);
+    get forceRedirect(): ForceRedirectConfig | undefined;
+    withCompress(compress: Compress): ConfigsGetBody;
+    withCacheUrlParameterFilter(cacheUrlParameterFilter: CacheUrlParameterFilter): ConfigsGetBody;
+    set cacheUrlParameterFilter(cacheUrlParameterFilter: CacheUrlParameterFilter | undefined);
+    get cacheUrlParameterFilter(): CacheUrlParameterFilter | undefined;
+    withIpv6Accelerate(ipv6Accelerate: number): ConfigsGetBody;
+    set ipv6Accelerate(ipv6Accelerate: number | undefined);
+    get ipv6Accelerate(): number | undefined;
+    withErrorCodeCache(errorCodeCache: Array<ErrorCodeCache>): ConfigsGetBody;
+    set errorCodeCache(errorCodeCache: Array<ErrorCodeCache> | undefined);
+    get errorCodeCache(): Array<ErrorCodeCache> | undefined;
+    withOriginRangeStatus(originRangeStatus: string): ConfigsGetBody;
+    set originRangeStatus(originRangeStatus: string | undefined);
+    get originRangeStatus(): string | undefined;
+    withUserAgentFilter(userAgentFilter: UserAgentFilter): ConfigsGetBody;
+    set userAgentFilter(userAgentFilter: UserAgentFilter | undefined);
+    get userAgentFilter(): UserAgentFilter | undefined;
+    withOriginRequestUrlRewrite(originRequestUrlRewrite: Array<OriginRequestUrlRewrite>): ConfigsGetBody;
+    set originRequestUrlRewrite(originRequestUrlRewrite: Array<OriginRequestUrlRewrite> | undefined);
+    get originRequestUrlRewrite(): Array<OriginRequestUrlRewrite> | undefined;
+    withErrorCodeRedirectRules(errorCodeRedirectRules: Array<ErrorCodeRedirectRules>): ConfigsGetBody;
+    set errorCodeRedirectRules(errorCodeRedirectRules: Array<ErrorCodeRedirectRules> | undefined);
+    get errorCodeRedirectRules(): Array<ErrorCodeRedirectRules> | undefined;
+}

package/v1/model/ConfigsGetBody.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigsGetBody = void 0;
+var ConfigsGetBody = /** @class */ (function () {
+    function ConfigsGetBody() {
+    }
+    ConfigsGetBody.prototype.withOriginRequestHeader = function (originRequestHeader) {
+        this['origin_request_header'] = originRequestHeader;
+        return this;
+    };
+    Object.defineProperty(ConfigsGetBody.prototype, "originRequestHeader", {
+        get: function () {
+            return this['origin_request_header'];
+        },
+        set: function (originRequestHeader) {
+            this['origin_request_header'] = originRequestHeader;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConfigsGetBody.prototype.withHttpResponseHeader = function (httpResponseHeader) {
+        this['http_response_header'] = httpResponseHeader;
+        return this;
+    };
+    Object.defineProperty(ConfigsGetBody.prototype, "httpResponseHeader", {
+        get: function () {
+            return this['http_response_header'];
+        },
+        set: function (httpResponseHeader) {
+            this['http_response_header'] = httpResponseHeader;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConfigsGetBody.prototype.withUrlAuth = function (urlAuth) {
+        this['url_auth'] = urlAuth;
+        return this;
+    };
+    Object.defineProperty(ConfigsGetBody.prototype, "urlAuth", {
+        get: function () {
+            return this['url_auth'];
+        },
+        set: function (urlAuth) {
+            this['url_auth'] = urlAuth;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConfigsGetBody.prototype.withHttps = function (https) {
+        this['https'] = https;
+        return this;
+    };
+    ConfigsGetBody.prototype.withSources = function (sources) {
+        this['sources'] = sources;
+        return this;
+    };
+    ConfigsGetBody.prototype.withOriginProtocol = function (originProtocol) {
+        this['origin_protocol'] = originProtocol;
+        return this;
+    };
+    Object.defineProperty(ConfigsGetBody.prototype, "originProtocol", {
+        get: function () {
+            return this['origin_protocol'];
+        },
+        set: function (originProtocol) {
+            this['origin_protocol'] = originProtocol;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConfigsGetBody.prototype.withForceRedirect = function (forceRedirect) {
+        this['force_redirect'] = forceRedirect;
+        return this;
+    };
+    Object.defineProperty(ConfigsGetBody.prototype, "forceRedirect", {
+        get: function () {
+            return this['force_redirect'];
+        },
+        set: function (forceRedirect) {
+            this['force_redirect'] = forceRedirect;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConfigsGetBody.prototype.withCompress = function (compress) {
+        this['compress'] = compress;
+        return this;
+    };
+    ConfigsGetBody.prototype.withCacheUrlParameterFilter = function (cacheUrlParameterFilter) {
+        this['cache_url_parameter_filter'] = cacheUrlParameterFilter;
+        return this;
+    };
+    Object.defineProperty(ConfigsGetBody.prototype, "cacheUrlParameterFilter", {
+        get: function () {
+            return this['cache_url_parameter_filter'];
+        },
+        set: function (cacheUrlParameterFilter) {
+            this['cache_url_parameter_filter'] = cacheUrlParameterFilter;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConfigsGetBody.prototype.withIpv6Accelerate = function (ipv6Accelerate) {
+        this['ipv6_accelerate'] = ipv6Accelerate;
+        return this;
+    };
+    Object.defineProperty(ConfigsGetBody.prototype, "ipv6Accelerate", {
+        get: function () {
+            return this['ipv6_accelerate'];
+        },
+        set: function (ipv6Accelerate) {
+            this['ipv6_accelerate'] = ipv6Accelerate;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConfigsGetBody.prototype.withErrorCodeCache = function (errorCodeCache) {
+        this['error_code_cache'] = errorCodeCache;
+        return this;
+    };
+    Object.defineProperty(ConfigsGetBody.prototype, "errorCodeCache", {
+        get: function () {
+            return this['error_code_cache'];
+        },
+        set: function (errorCodeCache) {
+            this['error_code_cache'] = errorCodeCache;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConfigsGetBody.prototype.withOriginRangeStatus = function (originRangeStatus) {
+        this['origin_range_status'] = originRangeStatus;
+        return this;
+    };
+    Object.defineProperty(ConfigsGetBody.prototype, "originRangeStatus", {
+        get: function () {
+            return this['origin_range_status'];
+        },
+        set: function (originRangeStatus) {
+            this['origin_range_status'] = originRangeStatus;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConfigsGetBody.prototype.withUserAgentFilter = function (userAgentFilter) {
+        this['user_agent_filter'] = userAgentFilter;
+        return this;
+    };
+    Object.defineProperty(ConfigsGetBody.prototype, "userAgentFilter", {
+        get: function () {
+            return this['user_agent_filter'];
+        },
+        set: function (userAgentFilter) {
+            this['user_agent_filter'] = userAgentFilter;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConfigsGetBody.prototype.withOriginRequestUrlRewrite = function (originRequestUrlRewrite) {
+        this['origin_request_url_rewrite'] = originRequestUrlRewrite;
+        return this;
+    };
+    Object.defineProperty(ConfigsGetBody.prototype, "originRequestUrlRewrite", {
+        get: function () {
+            return this['origin_request_url_rewrite'];
+        },
+        set: function (originRequestUrlRewrite) {
+            this['origin_request_url_rewrite'] = originRequestUrlRewrite;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConfigsGetBody.prototype.withErrorCodeRedirectRules = function (errorCodeRedirectRules) {
+        this['error_code_redirect_rules'] = errorCodeRedirectRules;
+        return this;
+    };
+    Object.defineProperty(ConfigsGetBody.prototype, "errorCodeRedirectRules", {
+        get: function () {
+            return this['error_code_redirect_rules'];
+        },
+        set: function (errorCodeRedirectRules) {
+            this['error_code_redirect_rules'] = errorCodeRedirectRules;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ConfigsGetBody;
+}());
+exports.ConfigsGetBody = ConfigsGetBody;

package/v1/model/CreateDomainRequest.d.ts

@@ -0,0 +1,6 @@
+import { CreateDomainRequestBody } from './CreateDomainRequestBody';
+export declare class CreateDomainRequest {
+    body?: CreateDomainRequestBody;
+    constructor();
+    withBody(body: CreateDomainRequestBody): CreateDomainRequest;
+}

package/v1/model/CreateDomainRequest.js

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

package/v1/model/CreateDomainRequestBody.d.ts

@@ -0,0 +1,6 @@
+import { DomainBody } from './DomainBody';
+export declare class CreateDomainRequestBody {
+    domain: DomainBody;
+    constructor(domain?: any);
+    withDomain(domain: DomainBody): CreateDomainRequestBody;
+}

package/v1/model/CreateDomainRequestBody.js

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

package/v1/model/CreateDomainResponse.d.ts

@@ -0,0 +1,7 @@
+import { CreateDomainResponseBodyContent } from './CreateDomainResponseBodyContent';
+import { SdkResponse } from "@huaweicloud/huaweicloud-sdk-core/SdkResponse";
+export declare class CreateDomainResponse extends SdkResponse {
+    domain?: CreateDomainResponseBodyContent;
+    constructor();
+    withDomain(domain: CreateDomainResponseBodyContent): CreateDomainResponse;
+}

package/v1/model/CreateDomainResponse.js

@@ -0,0 +1,31 @@
+"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.CreateDomainResponse = void 0;
+var SdkResponse_1 = require("@huaweicloud/huaweicloud-sdk-core/SdkResponse");
+var CreateDomainResponse = /** @class */ (function (_super) {
+    __extends(CreateDomainResponse, _super);
+    function CreateDomainResponse() {
+        return _super.call(this) || this;
+    }
+    CreateDomainResponse.prototype.withDomain = function (domain) {
+        this['domain'] = domain;
+        return this;
+    };
+    return CreateDomainResponse;
+}(SdkResponse_1.SdkResponse));
+exports.CreateDomainResponse = CreateDomainResponse;

package/v1/model/CreateDomainResponseBodyContent.d.ts

@@ -0,0 +1,67 @@
+import { DomainOriginHost } from './DomainOriginHost';
+import { Sources } from './Sources';
+export declare class CreateDomainResponseBodyContent {
+    id?: string;
+    private 'domain_name'?;
+    private 'business_type'?;
+    private 'service_area'?;
+    private 'user_domain_id'?;
+    private 'domain_status'?;
+    cname?: string;
+    sources?: Array<Sources>;
+    private 'domain_origin_host'?;
+    private 'https_status'?;
+    private 'create_time'?;
+    private 'modify_time'?;
+    disabled?: number;
+    locked?: number;
+    private 'range_status'?;
+    private 'follow_status'?;
+    private 'origin_status'?;
+    private 'auto_refresh_preheat'?;
+    constructor();
+    withId(id: string): CreateDomainResponseBodyContent;
+    withDomainName(domainName: string): CreateDomainResponseBodyContent;
+    set domainName(domainName: string | undefined);
+    get domainName(): string | undefined;
+    withBusinessType(businessType: string): CreateDomainResponseBodyContent;
+    set businessType(businessType: string | undefined);
+    get businessType(): string | undefined;
+    withServiceArea(serviceArea: string): CreateDomainResponseBodyContent;
+    set serviceArea(serviceArea: string | undefined);
+    get serviceArea(): string | undefined;
+    withUserDomainId(userDomainId: string): CreateDomainResponseBodyContent;
+    set userDomainId(userDomainId: string | undefined);
+    get userDomainId(): string | undefined;
+    withDomainStatus(domainStatus: string): CreateDomainResponseBodyContent;
+    set domainStatus(domainStatus: string | undefined);
+    get domainStatus(): string | undefined;
+    withCname(cname: string): CreateDomainResponseBodyContent;
+    withSources(sources: Array<Sources>): CreateDomainResponseBodyContent;
+    withDomainOriginHost(domainOriginHost: DomainOriginHost): CreateDomainResponseBodyContent;
+    set domainOriginHost(domainOriginHost: DomainOriginHost | undefined);
+    get domainOriginHost(): DomainOriginHost | undefined;
+    withHttpsStatus(httpsStatus: number): CreateDomainResponseBodyContent;
+    set httpsStatus(httpsStatus: number | undefined);
+    get httpsStatus(): number | undefined;
+    withCreateTime(createTime: number): CreateDomainResponseBodyContent;
+    set createTime(createTime: number | undefined);
+    get createTime(): number | undefined;
+    withModifyTime(modifyTime: number): CreateDomainResponseBodyContent;
+    set modifyTime(modifyTime: number | undefined);
+    get modifyTime(): number | undefined;
+    withDisabled(disabled: number): CreateDomainResponseBodyContent;
+    withLocked(locked: number): CreateDomainResponseBodyContent;
+    withRangeStatus(rangeStatus: string): CreateDomainResponseBodyContent;
+    set rangeStatus(rangeStatus: string | undefined);
+    get rangeStatus(): string | undefined;
+    withFollowStatus(followStatus: string): CreateDomainResponseBodyContent;
+    set followStatus(followStatus: string | undefined);
+    get followStatus(): string | undefined;
+    withOriginStatus(originStatus: string): CreateDomainResponseBodyContent;
+    set originStatus(originStatus: string | undefined);
+    get originStatus(): string | undefined;
+    withAutoRefreshPreheat(autoRefreshPreheat: number): CreateDomainResponseBodyContent;
+    set autoRefreshPreheat(autoRefreshPreheat: number | undefined);
+    get autoRefreshPreheat(): number | undefined;
+}