@huaweicloud/huaweicloud-sdk-cdn 3.1.23

package/v1/CdnRegion.d.ts

@@ -0,0 +1,7 @@
+export declare class CdnRegion {
+    static CN_NORTH_1: any;
+    static AP_SOUTHEAST_1: any;
+    private static STATIC_FIELDS;
+    private static createStaticFields;
+    static valueOf(regionId: String): any;
+}

package/v1/CdnRegion.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdnRegion = void 0;
+var region_1 = require("@huaweicloud/huaweicloud-sdk-core/region/region");
+var CdnRegion = /** @class */ (function () {
+    function CdnRegion() {
+    }
+    CdnRegion.createStaticFields = function () {
+        var map = new Map();
+        map.set("cn-north-1", CdnRegion.CN_NORTH_1);
+        map.set("ap-southeast-1", CdnRegion.AP_SOUTHEAST_1);
+        return map;
+    };
+    CdnRegion.valueOf = function (regionId) {
+        if (!regionId) {
+            throw new Error("Unexpected empty parameter: regionId.");
+        }
+        var result = this.STATIC_FIELDS.get(regionId);
+        if (result) {
+            return result;
+        }
+        throw new Error("Unexpected regionId: ".concat(regionId, "."));
+    };
+    CdnRegion.CN_NORTH_1 = new region_1.Region("cn-north-1", "https://cdn.myhuaweicloud.com");
+    CdnRegion.AP_SOUTHEAST_1 = new region_1.Region("ap-southeast-1", "https://cdn.myhuaweicloud.com");
+    CdnRegion.STATIC_FIELDS = CdnRegion.createStaticFields();
+    return CdnRegion;
+}());
+exports.CdnRegion = CdnRegion;

package/v1/model/BatchDeleteTagsRequest.d.ts

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

package/v1/model/BatchDeleteTagsRequest.js

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

package/v1/model/BatchDeleteTagsResponse.d.ts

@@ -0,0 +1,4 @@
+import { SdkResponse } from "@huaweicloud/huaweicloud-sdk-core/SdkResponse";
+export declare class BatchDeleteTagsResponse extends SdkResponse {
+    constructor();
+}

package/v1/model/BatchDeleteTagsResponse.js

@@ -0,0 +1,27 @@
+"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.BatchDeleteTagsResponse = void 0;
+var SdkResponse_1 = require("@huaweicloud/huaweicloud-sdk-core/SdkResponse");
+var BatchDeleteTagsResponse = /** @class */ (function (_super) {
+    __extends(BatchDeleteTagsResponse, _super);
+    function BatchDeleteTagsResponse() {
+        return _super.call(this) || this;
+    }
+    return BatchDeleteTagsResponse;
+}(SdkResponse_1.SdkResponse));
+exports.BatchDeleteTagsResponse = BatchDeleteTagsResponse;

package/v1/model/BlackWhiteListBody.d.ts

@@ -0,0 +1,9 @@
+export declare class BlackWhiteListBody {
+    type: number;
+    private 'ip_list'?;
+    constructor(type?: any);
+    withType(type: number): BlackWhiteListBody;
+    withIpList(ipList: Array<string>): BlackWhiteListBody;
+    set ipList(ipList: Array<string> | undefined);
+    get ipList(): Array<string> | undefined;
+}

package/v1/model/BlackWhiteListBody.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlackWhiteListBody = void 0;
+var BlackWhiteListBody = /** @class */ (function () {
+    function BlackWhiteListBody(type) {
+        this['type'] = type;
+    }
+    BlackWhiteListBody.prototype.withType = function (type) {
+        this['type'] = type;
+        return this;
+    };
+    BlackWhiteListBody.prototype.withIpList = function (ipList) {
+        this['ip_list'] = ipList;
+        return this;
+    };
+    Object.defineProperty(BlackWhiteListBody.prototype, "ipList", {
+        get: function () {
+            return this['ip_list'];
+        },
+        set: function (ipList) {
+            this['ip_list'] = ipList;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BlackWhiteListBody;
+}());
+exports.BlackWhiteListBody = BlackWhiteListBody;

package/v1/model/CacheConfig.d.ts

@@ -0,0 +1,17 @@
+import { CompressResponse } from './CompressResponse';
+import { Rules } from './Rules';
+export declare class CacheConfig {
+    private 'ignore_url_parameter'?;
+    private 'follow_origin'?;
+    compress?: CompressResponse;
+    rules?: Array<Rules>;
+    constructor();
+    withIgnoreUrlParameter(ignoreUrlParameter: boolean): CacheConfig;
+    set ignoreUrlParameter(ignoreUrlParameter: boolean | undefined);
+    get ignoreUrlParameter(): boolean | undefined;
+    withFollowOrigin(followOrigin: boolean): CacheConfig;
+    set followOrigin(followOrigin: boolean | undefined);
+    get followOrigin(): boolean | undefined;
+    withCompress(compress: CompressResponse): CacheConfig;
+    withRules(rules: Array<Rules>): CacheConfig;
+}

package/v1/model/CacheConfig.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheConfig = void 0;
+var CacheConfig = /** @class */ (function () {
+    function CacheConfig() {
+    }
+    CacheConfig.prototype.withIgnoreUrlParameter = function (ignoreUrlParameter) {
+        this['ignore_url_parameter'] = ignoreUrlParameter;
+        return this;
+    };
+    Object.defineProperty(CacheConfig.prototype, "ignoreUrlParameter", {
+        get: function () {
+            return this['ignore_url_parameter'];
+        },
+        set: function (ignoreUrlParameter) {
+            this['ignore_url_parameter'] = ignoreUrlParameter;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CacheConfig.prototype.withFollowOrigin = function (followOrigin) {
+        this['follow_origin'] = followOrigin;
+        return this;
+    };
+    Object.defineProperty(CacheConfig.prototype, "followOrigin", {
+        get: function () {
+            return this['follow_origin'];
+        },
+        set: function (followOrigin) {
+            this['follow_origin'] = followOrigin;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CacheConfig.prototype.withCompress = function (compress) {
+        this['compress'] = compress;
+        return this;
+    };
+    CacheConfig.prototype.withRules = function (rules) {
+        this['rules'] = rules;
+        return this;
+    };
+    return CacheConfig;
+}());
+exports.CacheConfig = CacheConfig;

package/v1/model/CacheConfigRequest.d.ts

@@ -0,0 +1,17 @@
+import { CompressRequest } from './CompressRequest';
+import { Rules } from './Rules';
+export declare class CacheConfigRequest {
+    private 'ignore_url_parameter'?;
+    private 'follow_origin'?;
+    compress?: CompressRequest;
+    rules?: Array<Rules>;
+    constructor();
+    withIgnoreUrlParameter(ignoreUrlParameter: boolean): CacheConfigRequest;
+    set ignoreUrlParameter(ignoreUrlParameter: boolean | undefined);
+    get ignoreUrlParameter(): boolean | undefined;
+    withFollowOrigin(followOrigin: boolean): CacheConfigRequest;
+    set followOrigin(followOrigin: boolean | undefined);
+    get followOrigin(): boolean | undefined;
+    withCompress(compress: CompressRequest): CacheConfigRequest;
+    withRules(rules: Array<Rules>): CacheConfigRequest;
+}

package/v1/model/CacheConfigRequest.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheConfigRequest = void 0;
+var CacheConfigRequest = /** @class */ (function () {
+    function CacheConfigRequest() {
+    }
+    CacheConfigRequest.prototype.withIgnoreUrlParameter = function (ignoreUrlParameter) {
+        this['ignore_url_parameter'] = ignoreUrlParameter;
+        return this;
+    };
+    Object.defineProperty(CacheConfigRequest.prototype, "ignoreUrlParameter", {
+        get: function () {
+            return this['ignore_url_parameter'];
+        },
+        set: function (ignoreUrlParameter) {
+            this['ignore_url_parameter'] = ignoreUrlParameter;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CacheConfigRequest.prototype.withFollowOrigin = function (followOrigin) {
+        this['follow_origin'] = followOrigin;
+        return this;
+    };
+    Object.defineProperty(CacheConfigRequest.prototype, "followOrigin", {
+        get: function () {
+            return this['follow_origin'];
+        },
+        set: function (followOrigin) {
+            this['follow_origin'] = followOrigin;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CacheConfigRequest.prototype.withCompress = function (compress) {
+        this['compress'] = compress;
+        return this;
+    };
+    CacheConfigRequest.prototype.withRules = function (rules) {
+        this['rules'] = rules;
+        return this;
+    };
+    return CacheConfigRequest;
+}());
+exports.CacheConfigRequest = CacheConfigRequest;

package/v1/model/CacheConfigRequestBody.d.ts

@@ -0,0 +1,8 @@
+import { CacheConfigRequest } from './CacheConfigRequest';
+export declare class CacheConfigRequestBody {
+    private 'cache_config';
+    constructor(cacheConfig?: any);
+    withCacheConfig(cacheConfig: CacheConfigRequest): CacheConfigRequestBody;
+    set cacheConfig(cacheConfig: CacheConfigRequest | undefined);
+    get cacheConfig(): CacheConfigRequest | undefined;
+}

package/v1/model/CacheConfigRequestBody.js

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

package/v1/model/CacheUrlParameterFilter.d.ts

@@ -0,0 +1,7 @@
+export declare class CacheUrlParameterFilter {
+    type?: string;
+    value?: string;
+    constructor();
+    withType(type: string): CacheUrlParameterFilter;
+    withValue(value: string): CacheUrlParameterFilter;
+}

package/v1/model/CacheUrlParameterFilter.js

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

package/v1/model/CdnIps.d.ts

@@ -0,0 +1,13 @@
+export declare class CdnIps {
+    ip?: string;
+    belongs?: boolean;
+    region?: string;
+    isp?: string;
+    platform?: string;
+    constructor();
+    withIp(ip: string): CdnIps;
+    withBelongs(belongs: boolean): CdnIps;
+    withRegion(region: string): CdnIps;
+    withIsp(isp: string): CdnIps;
+    withPlatform(platform: string): CdnIps;
+}

package/v1/model/CdnIps.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdnIps = void 0;
+var CdnIps = /** @class */ (function () {
+    function CdnIps() {
+    }
+    CdnIps.prototype.withIp = function (ip) {
+        this['ip'] = ip;
+        return this;
+    };
+    CdnIps.prototype.withBelongs = function (belongs) {
+        this['belongs'] = belongs;
+        return this;
+    };
+    CdnIps.prototype.withRegion = function (region) {
+        this['region'] = region;
+        return this;
+    };
+    CdnIps.prototype.withIsp = function (isp) {
+        this['isp'] = isp;
+        return this;
+    };
+    CdnIps.prototype.withPlatform = function (platform) {
+        this['platform'] = platform;
+        return this;
+    };
+    return CdnIps;
+}());
+exports.CdnIps = CdnIps;

package/v1/model/Compress.d.ts

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

package/v1/model/Compress.js

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

package/v1/model/CompressRequest.d.ts

@@ -0,0 +1,7 @@
+export declare class CompressRequest {
+    private 'compress_switch'?;
+    constructor();
+    withCompressSwitch(compressSwitch: number): CompressRequest;
+    set compressSwitch(compressSwitch: number | undefined);
+    get compressSwitch(): number | undefined;
+}

package/v1/model/CompressRequest.js

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

package/v1/model/CompressResponse.d.ts

@@ -0,0 +1,12 @@
+import { CompressRules } from './CompressRules';
+export declare class CompressResponse {
+    private 'compress_switch';
+    private 'compress_rules'?;
+    constructor(compressSwitch?: any);
+    withCompressSwitch(compressSwitch: number): CompressResponse;
+    set compressSwitch(compressSwitch: number | undefined);
+    get compressSwitch(): number | undefined;
+    withCompressRules(compressRules: Array<CompressRules>): CompressResponse;
+    set compressRules(compressRules: Array<CompressRules> | undefined);
+    get compressRules(): Array<CompressRules> | undefined;
+}

package/v1/model/CompressResponse.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressResponse = void 0;
+var CompressResponse = /** @class */ (function () {
+    function CompressResponse(compressSwitch) {
+        this['compress_switch'] = compressSwitch;
+    }
+    CompressResponse.prototype.withCompressSwitch = function (compressSwitch) {
+        this['compress_switch'] = compressSwitch;
+        return this;
+    };
+    Object.defineProperty(CompressResponse.prototype, "compressSwitch", {
+        get: function () {
+            return this['compress_switch'];
+        },
+        set: function (compressSwitch) {
+            this['compress_switch'] = compressSwitch;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CompressResponse.prototype.withCompressRules = function (compressRules) {
+        this['compress_rules'] = compressRules;
+        return this;
+    };
+    Object.defineProperty(CompressResponse.prototype, "compressRules", {
+        get: function () {
+            return this['compress_rules'];
+        },
+        set: function (compressRules) {
+            this['compress_rules'] = compressRules;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return CompressResponse;
+}());
+exports.CompressResponse = CompressResponse;

package/v1/model/CompressRules.d.ts

@@ -0,0 +1,11 @@
+export declare class CompressRules {
+    private 'compress_type'?;
+    private 'compress_file_type'?;
+    constructor();
+    withCompressType(compressType: string): CompressRules;
+    set compressType(compressType: string | undefined);
+    get compressType(): string | undefined;
+    withCompressFileType(compressFileType: string): CompressRules;
+    set compressFileType(compressFileType: string | undefined);
+    get compressFileType(): string | undefined;
+}

package/v1/model/CompressRules.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressRules = void 0;
+var CompressRules = /** @class */ (function () {
+    function CompressRules() {
+    }
+    CompressRules.prototype.withCompressType = function (compressType) {
+        this['compress_type'] = compressType;
+        return this;
+    };
+    Object.defineProperty(CompressRules.prototype, "compressType", {
+        get: function () {
+            return this['compress_type'];
+        },
+        set: function (compressType) {
+            this['compress_type'] = compressType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CompressRules.prototype.withCompressFileType = function (compressFileType) {
+        this['compress_file_type'] = compressFileType;
+        return this;
+    };
+    Object.defineProperty(CompressRules.prototype, "compressFileType", {
+        get: function () {
+            return this['compress_file_type'];
+        },
+        set: function (compressFileType) {
+            this['compress_file_type'] = compressFileType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return CompressRules;
+}());
+exports.CompressRules = CompressRules;

package/v1/model/Configs.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 { HttpPutBody } from './HttpPutBody';
+import { HttpResponseHeader } from './HttpResponseHeader';
+import { OriginRequestHeader } from './OriginRequestHeader';
+import { OriginRequestUrlRewrite } from './OriginRequestUrlRewrite';
+import { SourcesConfig } from './SourcesConfig';
+import { UrlAuth } from './UrlAuth';
+import { UserAgentFilter } from './UserAgentFilter';
+export declare class Configs {
+    private 'origin_request_header'?;
+    private 'http_response_header'?;
+    private 'url_auth'?;
+    https?: HttpPutBody;
+    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>): Configs;
+    set originRequestHeader(originRequestHeader: Array<OriginRequestHeader> | undefined);
+    get originRequestHeader(): Array<OriginRequestHeader> | undefined;
+    withHttpResponseHeader(httpResponseHeader: Array<HttpResponseHeader>): Configs;
+    set httpResponseHeader(httpResponseHeader: Array<HttpResponseHeader> | undefined);
+    get httpResponseHeader(): Array<HttpResponseHeader> | undefined;
+    withUrlAuth(urlAuth: UrlAuth): Configs;
+    set urlAuth(urlAuth: UrlAuth | undefined);
+    get urlAuth(): UrlAuth | undefined;
+    withHttps(https: HttpPutBody): Configs;
+    withSources(sources: Array<SourcesConfig>): Configs;
+    withOriginProtocol(originProtocol: string): Configs;
+    set originProtocol(originProtocol: string | undefined);
+    get originProtocol(): string | undefined;
+    withForceRedirect(forceRedirect: ForceRedirectConfig): Configs;
+    set forceRedirect(forceRedirect: ForceRedirectConfig | undefined);
+    get forceRedirect(): ForceRedirectConfig | undefined;
+    withCompress(compress: Compress): Configs;
+    withCacheUrlParameterFilter(cacheUrlParameterFilter: CacheUrlParameterFilter): Configs;
+    set cacheUrlParameterFilter(cacheUrlParameterFilter: CacheUrlParameterFilter | undefined);
+    get cacheUrlParameterFilter(): CacheUrlParameterFilter | undefined;
+    withIpv6Accelerate(ipv6Accelerate: number): Configs;
+    set ipv6Accelerate(ipv6Accelerate: number | undefined);
+    get ipv6Accelerate(): number | undefined;
+    withErrorCodeCache(errorCodeCache: Array<ErrorCodeCache>): Configs;
+    set errorCodeCache(errorCodeCache: Array<ErrorCodeCache> | undefined);
+    get errorCodeCache(): Array<ErrorCodeCache> | undefined;
+    withOriginRangeStatus(originRangeStatus: string): Configs;
+    set originRangeStatus(originRangeStatus: string | undefined);
+    get originRangeStatus(): string | undefined;
+    withUserAgentFilter(userAgentFilter: UserAgentFilter): Configs;
+    set userAgentFilter(userAgentFilter: UserAgentFilter | undefined);
+    get userAgentFilter(): UserAgentFilter | undefined;
+    withOriginRequestUrlRewrite(originRequestUrlRewrite: Array<OriginRequestUrlRewrite>): Configs;
+    set originRequestUrlRewrite(originRequestUrlRewrite: Array<OriginRequestUrlRewrite> | undefined);
+    get originRequestUrlRewrite(): Array<OriginRequestUrlRewrite> | undefined;
+    withErrorCodeRedirectRules(errorCodeRedirectRules: Array<ErrorCodeRedirectRules>): Configs;
+    set errorCodeRedirectRules(errorCodeRedirectRules: Array<ErrorCodeRedirectRules> | undefined);
+    get errorCodeRedirectRules(): Array<ErrorCodeRedirectRules> | undefined;
+}