@huaweicloud/huaweicloud-sdk-cdn 3.1.23

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

package/v1/model/ErrorCodeCache.d.ts

@@ -0,0 +1,7 @@
+export declare class ErrorCodeCache {
+    code?: number;
+    ttl?: number;
+    constructor();
+    withCode(code: number): ErrorCodeCache;
+    withTtl(ttl: number): ErrorCodeCache;
+}

package/v1/model/ErrorCodeCache.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCodeCache = void 0;
+var ErrorCodeCache = /** @class */ (function () {
+    function ErrorCodeCache() {
+    }
+    ErrorCodeCache.prototype.withCode = function (code) {
+        this['code'] = code;
+        return this;
+    };
+    ErrorCodeCache.prototype.withTtl = function (ttl) {
+        this['ttl'] = ttl;
+        return this;
+    };
+    return ErrorCodeCache;
+}());
+exports.ErrorCodeCache = ErrorCodeCache;

package/v1/model/ErrorCodeRedirectRules.d.ts

@@ -0,0 +1,15 @@
+export declare class ErrorCodeRedirectRules {
+    private 'error_code';
+    private 'target_code';
+    private 'target_link';
+    constructor(errorCode?: any, targetCode?: any, targetLink?: any);
+    withErrorCode(errorCode: string): ErrorCodeRedirectRules;
+    set errorCode(errorCode: string | undefined);
+    get errorCode(): string | undefined;
+    withTargetCode(targetCode: string): ErrorCodeRedirectRules;
+    set targetCode(targetCode: string | undefined);
+    get targetCode(): string | undefined;
+    withTargetLink(targetLink: string): ErrorCodeRedirectRules;
+    set targetLink(targetLink: string | undefined);
+    get targetLink(): string | undefined;
+}

package/v1/model/ErrorCodeRedirectRules.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCodeRedirectRules = void 0;
+var ErrorCodeRedirectRules = /** @class */ (function () {
+    function ErrorCodeRedirectRules(errorCode, targetCode, targetLink) {
+        this['error_code'] = errorCode;
+        this['target_code'] = targetCode;
+        this['target_link'] = targetLink;
+    }
+    ErrorCodeRedirectRules.prototype.withErrorCode = function (errorCode) {
+        this['error_code'] = errorCode;
+        return this;
+    };
+    Object.defineProperty(ErrorCodeRedirectRules.prototype, "errorCode", {
+        get: function () {
+            return this['error_code'];
+        },
+        set: function (errorCode) {
+            this['error_code'] = errorCode;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ErrorCodeRedirectRules.prototype.withTargetCode = function (targetCode) {
+        this['target_code'] = targetCode;
+        return this;
+    };
+    Object.defineProperty(ErrorCodeRedirectRules.prototype, "targetCode", {
+        get: function () {
+            return this['target_code'];
+        },
+        set: function (targetCode) {
+            this['target_code'] = targetCode;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ErrorCodeRedirectRules.prototype.withTargetLink = function (targetLink) {
+        this['target_link'] = targetLink;
+        return this;
+    };
+    Object.defineProperty(ErrorCodeRedirectRules.prototype, "targetLink", {
+        get: function () {
+            return this['target_link'];
+        },
+        set: function (targetLink) {
+            this['target_link'] = targetLink;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ErrorCodeRedirectRules;
+}());
+exports.ErrorCodeRedirectRules = ErrorCodeRedirectRules;

package/v1/model/Follow302StatusBody.d.ts

@@ -0,0 +1,19 @@
+export declare class Follow302StatusBody {
+    private 'domain_id'?;
+    private 'follow_status'?;
+    constructor();
+    withDomainId(domainId: string): Follow302StatusBody;
+    set domainId(domainId: string | undefined);
+    get domainId(): string | undefined;
+    withFollowStatus(followStatus: Follow302StatusBodyFollowStatusEnum): Follow302StatusBody;
+    set followStatus(followStatus: Follow302StatusBodyFollowStatusEnum | undefined);
+    get followStatus(): Follow302StatusBodyFollowStatusEnum | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum Follow302StatusBodyFollowStatusEnum {
+    OFF = "off",
+    ON = "on"
+}

package/v1/model/Follow302StatusBody.js

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

package/v1/model/Follow302StatusRequest.d.ts

@@ -0,0 +1,15 @@
+export declare class Follow302StatusRequest {
+    private 'follow302_status';
+    constructor(follow302Status?: any);
+    withFollow302Status(follow302Status: Follow302StatusRequestFollow302StatusEnum): Follow302StatusRequest;
+    set follow302Status(follow302Status: Follow302StatusRequestFollow302StatusEnum | undefined);
+    get follow302Status(): Follow302StatusRequestFollow302StatusEnum | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum Follow302StatusRequestFollow302StatusEnum {
+    OFF = "off",
+    ON = "on"
+}

package/v1/model/Follow302StatusRequest.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Follow302StatusRequestFollow302StatusEnum = exports.Follow302StatusRequest = void 0;
+var Follow302StatusRequest = /** @class */ (function () {
+    function Follow302StatusRequest(follow302Status) {
+        this['follow302_status'] = follow302Status;
+    }
+    Follow302StatusRequest.prototype.withFollow302Status = function (follow302Status) {
+        this['follow302_status'] = follow302Status;
+        return this;
+    };
+    Object.defineProperty(Follow302StatusRequest.prototype, "follow302Status", {
+        get: function () {
+            return this['follow302_status'];
+        },
+        set: function (follow302Status) {
+            this['follow302_status'] = follow302Status;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Follow302StatusRequest;
+}());
+exports.Follow302StatusRequest = Follow302StatusRequest;
+/**
+    * @export
+    * @enum {string}
+    */
+var Follow302StatusRequestFollow302StatusEnum;
+(function (Follow302StatusRequestFollow302StatusEnum) {
+    Follow302StatusRequestFollow302StatusEnum["OFF"] = "off";
+    Follow302StatusRequestFollow302StatusEnum["ON"] = "on";
+})(Follow302StatusRequestFollow302StatusEnum = exports.Follow302StatusRequestFollow302StatusEnum || (exports.Follow302StatusRequestFollow302StatusEnum = {}));

package/v1/model/ForceRedirect.d.ts

@@ -0,0 +1,11 @@
+export declare class ForceRedirect {
+    private 'switch';
+    private 'redirect_type'?;
+    constructor(_switch?: any);
+    withSwitch(_switch: number): ForceRedirect;
+    set _switch(_switch: number | undefined);
+    get _switch(): number | undefined;
+    withRedirectType(redirectType: string): ForceRedirect;
+    set redirectType(redirectType: string | undefined);
+    get redirectType(): string | undefined;
+}

package/v1/model/ForceRedirect.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForceRedirect = void 0;
+var ForceRedirect = /** @class */ (function () {
+    function ForceRedirect(_switch) {
+        this['switch'] = _switch;
+    }
+    ForceRedirect.prototype.withSwitch = function (_switch) {
+        this['switch'] = _switch;
+        return this;
+    };
+    Object.defineProperty(ForceRedirect.prototype, "_switch", {
+        get: function () {
+            return this['switch'];
+        },
+        set: function (_switch) {
+            this['switch'] = _switch;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ForceRedirect.prototype.withRedirectType = function (redirectType) {
+        this['redirect_type'] = redirectType;
+        return this;
+    };
+    Object.defineProperty(ForceRedirect.prototype, "redirectType", {
+        get: function () {
+            return this['redirect_type'];
+        },
+        set: function (redirectType) {
+            this['redirect_type'] = redirectType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ForceRedirect;
+}());
+exports.ForceRedirect = ForceRedirect;

package/v1/model/ForceRedirectConfig.d.ts

@@ -0,0 +1,7 @@
+export declare class ForceRedirectConfig {
+    status: string;
+    type?: string;
+    constructor(status?: any);
+    withStatus(status: string): ForceRedirectConfig;
+    withType(type: string): ForceRedirectConfig;
+}

package/v1/model/ForceRedirectConfig.js

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

package/v1/model/HeaderBody.d.ts

@@ -0,0 +1,6 @@
+import { HeaderMap } from './HeaderMap';
+export declare class HeaderBody {
+    headers?: HeaderMap;
+    constructor();
+    withHeaders(headers: HeaderMap): HeaderBody;
+}

package/v1/model/HeaderBody.js

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

package/v1/model/HeaderMap.d.ts

@@ -0,0 +1,27 @@
+export declare class HeaderMap {
+    private 'Content-Disposition'?;
+    private 'Content-Language'?;
+    private 'Access-Control-Allow-Origin'?;
+    private 'Access-Control-Allow-Methods'?;
+    private 'Access-Control-Max-Age'?;
+    private 'Access-Control-Expose-Headers'?;
+    constructor();
+    withContentDisposition(contentDisposition: string): HeaderMap;
+    set contentDisposition(contentDisposition: string | undefined);
+    get contentDisposition(): string | undefined;
+    withContentLanguage(contentLanguage: string): HeaderMap;
+    set contentLanguage(contentLanguage: string | undefined);
+    get contentLanguage(): string | undefined;
+    withAccessControlAllowOrigin(accessControlAllowOrigin: string): HeaderMap;
+    set accessControlAllowOrigin(accessControlAllowOrigin: string | undefined);
+    get accessControlAllowOrigin(): string | undefined;
+    withAccessControlAllowMethods(accessControlAllowMethods: string): HeaderMap;
+    set accessControlAllowMethods(accessControlAllowMethods: string | undefined);
+    get accessControlAllowMethods(): string | undefined;
+    withAccessControlMaxAge(accessControlMaxAge: string): HeaderMap;
+    set accessControlMaxAge(accessControlMaxAge: string | undefined);
+    get accessControlMaxAge(): string | undefined;
+    withAccessControlExposeHeaders(accessControlExposeHeaders: string): HeaderMap;
+    set accessControlExposeHeaders(accessControlExposeHeaders: string | undefined);
+    get accessControlExposeHeaders(): string | undefined;
+}

package/v1/model/HeaderMap.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderMap = void 0;
+var HeaderMap = /** @class */ (function () {
+    function HeaderMap() {
+    }
+    HeaderMap.prototype.withContentDisposition = function (contentDisposition) {
+        this['Content-Disposition'] = contentDisposition;
+        return this;
+    };
+    Object.defineProperty(HeaderMap.prototype, "contentDisposition", {
+        get: function () {
+            return this['Content-Disposition'];
+        },
+        set: function (contentDisposition) {
+            this['Content-Disposition'] = contentDisposition;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HeaderMap.prototype.withContentLanguage = function (contentLanguage) {
+        this['Content-Language'] = contentLanguage;
+        return this;
+    };
+    Object.defineProperty(HeaderMap.prototype, "contentLanguage", {
+        get: function () {
+            return this['Content-Language'];
+        },
+        set: function (contentLanguage) {
+            this['Content-Language'] = contentLanguage;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HeaderMap.prototype.withAccessControlAllowOrigin = function (accessControlAllowOrigin) {
+        this['Access-Control-Allow-Origin'] = accessControlAllowOrigin;
+        return this;
+    };
+    Object.defineProperty(HeaderMap.prototype, "accessControlAllowOrigin", {
+        get: function () {
+            return this['Access-Control-Allow-Origin'];
+        },
+        set: function (accessControlAllowOrigin) {
+            this['Access-Control-Allow-Origin'] = accessControlAllowOrigin;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HeaderMap.prototype.withAccessControlAllowMethods = function (accessControlAllowMethods) {
+        this['Access-Control-Allow-Methods'] = accessControlAllowMethods;
+        return this;
+    };
+    Object.defineProperty(HeaderMap.prototype, "accessControlAllowMethods", {
+        get: function () {
+            return this['Access-Control-Allow-Methods'];
+        },
+        set: function (accessControlAllowMethods) {
+            this['Access-Control-Allow-Methods'] = accessControlAllowMethods;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HeaderMap.prototype.withAccessControlMaxAge = function (accessControlMaxAge) {
+        this['Access-Control-Max-Age'] = accessControlMaxAge;
+        return this;
+    };
+    Object.defineProperty(HeaderMap.prototype, "accessControlMaxAge", {
+        get: function () {
+            return this['Access-Control-Max-Age'];
+        },
+        set: function (accessControlMaxAge) {
+            this['Access-Control-Max-Age'] = accessControlMaxAge;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HeaderMap.prototype.withAccessControlExposeHeaders = function (accessControlExposeHeaders) {
+        this['Access-Control-Expose-Headers'] = accessControlExposeHeaders;
+        return this;
+    };
+    Object.defineProperty(HeaderMap.prototype, "accessControlExposeHeaders", {
+        get: function () {
+            return this['Access-Control-Expose-Headers'];
+        },
+        set: function (accessControlExposeHeaders) {
+            this['Access-Control-Expose-Headers'] = accessControlExposeHeaders;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return HeaderMap;
+}());
+exports.HeaderMap = HeaderMap;

package/v1/model/HttpGetBody.d.ts

@@ -0,0 +1,27 @@
+export declare class HttpGetBody {
+    private 'https_status'?;
+    private 'certificate_name'?;
+    private 'certificate_value'?;
+    private 'certificate_source'?;
+    private 'http2_status'?;
+    private 'tls_version'?;
+    constructor();
+    withHttpsStatus(httpsStatus: string): HttpGetBody;
+    set httpsStatus(httpsStatus: string | undefined);
+    get httpsStatus(): string | undefined;
+    withCertificateName(certificateName: string): HttpGetBody;
+    set certificateName(certificateName: string | undefined);
+    get certificateName(): string | undefined;
+    withCertificateValue(certificateValue: string): HttpGetBody;
+    set certificateValue(certificateValue: string | undefined);
+    get certificateValue(): string | undefined;
+    withCertificateSource(certificateSource: number): HttpGetBody;
+    set certificateSource(certificateSource: number | undefined);
+    get certificateSource(): number | undefined;
+    withHttp2Status(http2Status: string): HttpGetBody;
+    set http2Status(http2Status: string | undefined);
+    get http2Status(): string | undefined;
+    withTlsVersion(tlsVersion: string): HttpGetBody;
+    set tlsVersion(tlsVersion: string | undefined);
+    get tlsVersion(): string | undefined;
+}

package/v1/model/HttpGetBody.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpGetBody = void 0;
+var HttpGetBody = /** @class */ (function () {
+    function HttpGetBody() {
+    }
+    HttpGetBody.prototype.withHttpsStatus = function (httpsStatus) {
+        this['https_status'] = httpsStatus;
+        return this;
+    };
+    Object.defineProperty(HttpGetBody.prototype, "httpsStatus", {
+        get: function () {
+            return this['https_status'];
+        },
+        set: function (httpsStatus) {
+            this['https_status'] = httpsStatus;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HttpGetBody.prototype.withCertificateName = function (certificateName) {
+        this['certificate_name'] = certificateName;
+        return this;
+    };
+    Object.defineProperty(HttpGetBody.prototype, "certificateName", {
+        get: function () {
+            return this['certificate_name'];
+        },
+        set: function (certificateName) {
+            this['certificate_name'] = certificateName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HttpGetBody.prototype.withCertificateValue = function (certificateValue) {
+        this['certificate_value'] = certificateValue;
+        return this;
+    };
+    Object.defineProperty(HttpGetBody.prototype, "certificateValue", {
+        get: function () {
+            return this['certificate_value'];
+        },
+        set: function (certificateValue) {
+            this['certificate_value'] = certificateValue;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HttpGetBody.prototype.withCertificateSource = function (certificateSource) {
+        this['certificate_source'] = certificateSource;
+        return this;
+    };
+    Object.defineProperty(HttpGetBody.prototype, "certificateSource", {
+        get: function () {
+            return this['certificate_source'];
+        },
+        set: function (certificateSource) {
+            this['certificate_source'] = certificateSource;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HttpGetBody.prototype.withHttp2Status = function (http2Status) {
+        this['http2_status'] = http2Status;
+        return this;
+    };
+    Object.defineProperty(HttpGetBody.prototype, "http2Status", {
+        get: function () {
+            return this['http2_status'];
+        },
+        set: function (http2Status) {
+            this['http2_status'] = http2Status;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HttpGetBody.prototype.withTlsVersion = function (tlsVersion) {
+        this['tls_version'] = tlsVersion;
+        return this;
+    };
+    Object.defineProperty(HttpGetBody.prototype, "tlsVersion", {
+        get: function () {
+            return this['tls_version'];
+        },
+        set: function (tlsVersion) {
+            this['tls_version'] = tlsVersion;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return HttpGetBody;
+}());
+exports.HttpGetBody = HttpGetBody;

package/v1/model/HttpInfoRequest.d.ts

@@ -0,0 +1,6 @@
+import { HttpInfoRequestBody } from './HttpInfoRequestBody';
+export declare class HttpInfoRequest {
+    https: HttpInfoRequestBody;
+    constructor(https?: any);
+    withHttps(https: HttpInfoRequestBody): HttpInfoRequest;
+}

package/v1/model/HttpInfoRequest.js

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

package/v1/model/HttpInfoRequestBody.d.ts

@@ -0,0 +1,32 @@
+import { ForceRedirect } from './ForceRedirect';
+export declare class HttpInfoRequestBody {
+    private 'cert_name';
+    private 'https_status';
+    certificate?: string;
+    private 'private_key'?;
+    http2?: number;
+    private 'certificate_type'?;
+    private 'force_redirect_https'?;
+    private 'force_redirect_config'?;
+    constructor(certName?: any, httpsStatus?: any);
+    withCertName(certName: string): HttpInfoRequestBody;
+    set certName(certName: string | undefined);
+    get certName(): string | undefined;
+    withHttpsStatus(httpsStatus: number): HttpInfoRequestBody;
+    set httpsStatus(httpsStatus: number | undefined);
+    get httpsStatus(): number | undefined;
+    withCertificate(certificate: string): HttpInfoRequestBody;
+    withPrivateKey(privateKey: string): HttpInfoRequestBody;
+    set privateKey(privateKey: string | undefined);
+    get privateKey(): string | undefined;
+    withHttp2(http2: number): HttpInfoRequestBody;
+    withCertificateType(certificateType: number): HttpInfoRequestBody;
+    set certificateType(certificateType: number | undefined);
+    get certificateType(): number | undefined;
+    withForceRedirectHttps(forceRedirectHttps: number): HttpInfoRequestBody;
+    set forceRedirectHttps(forceRedirectHttps: number | undefined);
+    get forceRedirectHttps(): number | undefined;
+    withForceRedirectConfig(forceRedirectConfig: ForceRedirect): HttpInfoRequestBody;
+    set forceRedirectConfig(forceRedirectConfig: ForceRedirect | undefined);
+    get forceRedirectConfig(): ForceRedirect | undefined;
+}