@aws-sdk/client-waf-regional 3.934.0 → 3.936.0

package/dist-es/index.js

@@ -1,5 +1,6 @@
 export * from "./WAFRegionalClient";
 export * from "./WAFRegional";
 export * from "./commands";
-export * from "./models";
+export * from "./models/enums";
+export * from "./models/errors";
 export { WAFRegionalServiceException } from "./models/WAFRegionalServiceException";

package/dist-es/models/enums.js

@@ -0,0 +1,364 @@
+export const WafActionType = {
+    ALLOW: "ALLOW",
+    BLOCK: "BLOCK",
+    COUNT: "COUNT",
+};
+export const WafOverrideActionType = {
+    COUNT: "COUNT",
+    NONE: "NONE",
+};
+export const WafRuleType = {
+    GROUP: "GROUP",
+    RATE_BASED: "RATE_BASED",
+    REGULAR: "REGULAR",
+};
+export const ParameterExceptionField = {
+    BYTE_MATCH_FIELD_TYPE: "BYTE_MATCH_FIELD_TYPE",
+    BYTE_MATCH_POSITIONAL_CONSTRAINT: "BYTE_MATCH_POSITIONAL_CONSTRAINT",
+    BYTE_MATCH_TEXT_TRANSFORMATION: "BYTE_MATCH_TEXT_TRANSFORMATION",
+    CHANGE_ACTION: "CHANGE_ACTION",
+    GEO_MATCH_LOCATION_TYPE: "GEO_MATCH_LOCATION_TYPE",
+    GEO_MATCH_LOCATION_VALUE: "GEO_MATCH_LOCATION_VALUE",
+    IPSET_TYPE: "IPSET_TYPE",
+    NEXT_MARKER: "NEXT_MARKER",
+    PREDICATE_TYPE: "PREDICATE_TYPE",
+    RATE_KEY: "RATE_KEY",
+    RESOURCE_ARN: "RESOURCE_ARN",
+    RULE_TYPE: "RULE_TYPE",
+    SIZE_CONSTRAINT_COMPARISON_OPERATOR: "SIZE_CONSTRAINT_COMPARISON_OPERATOR",
+    SQL_INJECTION_MATCH_FIELD_TYPE: "SQL_INJECTION_MATCH_FIELD_TYPE",
+    TAGS: "TAGS",
+    TAG_KEYS: "TAG_KEYS",
+    WAF_ACTION: "WAF_ACTION",
+    WAF_OVERRIDE_ACTION: "WAF_OVERRIDE_ACTION",
+};
+export const ParameterExceptionReason = {
+    ILLEGAL_ARGUMENT: "ILLEGAL_ARGUMENT",
+    ILLEGAL_COMBINATION: "ILLEGAL_COMBINATION",
+    INVALID_OPTION: "INVALID_OPTION",
+    INVALID_TAG_KEY: "INVALID_TAG_KEY",
+};
+export const MatchFieldType = {
+    ALL_QUERY_ARGS: "ALL_QUERY_ARGS",
+    BODY: "BODY",
+    HEADER: "HEADER",
+    METHOD: "METHOD",
+    QUERY_STRING: "QUERY_STRING",
+    SINGLE_QUERY_ARG: "SINGLE_QUERY_ARG",
+    URI: "URI",
+};
+export const PositionalConstraint = {
+    CONTAINS: "CONTAINS",
+    CONTAINS_WORD: "CONTAINS_WORD",
+    ENDS_WITH: "ENDS_WITH",
+    EXACTLY: "EXACTLY",
+    STARTS_WITH: "STARTS_WITH",
+};
+export const TextTransformation = {
+    CMD_LINE: "CMD_LINE",
+    COMPRESS_WHITE_SPACE: "COMPRESS_WHITE_SPACE",
+    HTML_ENTITY_DECODE: "HTML_ENTITY_DECODE",
+    LOWERCASE: "LOWERCASE",
+    NONE: "NONE",
+    URL_DECODE: "URL_DECODE",
+};
+export const GeoMatchConstraintType = {
+    Country: "Country",
+};
+export const GeoMatchConstraintValue = {
+    AD: "AD",
+    AE: "AE",
+    AF: "AF",
+    AG: "AG",
+    AI: "AI",
+    AL: "AL",
+    AM: "AM",
+    AO: "AO",
+    AQ: "AQ",
+    AR: "AR",
+    AS: "AS",
+    AT: "AT",
+    AU: "AU",
+    AW: "AW",
+    AX: "AX",
+    AZ: "AZ",
+    BA: "BA",
+    BB: "BB",
+    BD: "BD",
+    BE: "BE",
+    BF: "BF",
+    BG: "BG",
+    BH: "BH",
+    BI: "BI",
+    BJ: "BJ",
+    BL: "BL",
+    BM: "BM",
+    BN: "BN",
+    BO: "BO",
+    BQ: "BQ",
+    BR: "BR",
+    BS: "BS",
+    BT: "BT",
+    BV: "BV",
+    BW: "BW",
+    BY: "BY",
+    BZ: "BZ",
+    CA: "CA",
+    CC: "CC",
+    CD: "CD",
+    CF: "CF",
+    CG: "CG",
+    CH: "CH",
+    CI: "CI",
+    CK: "CK",
+    CL: "CL",
+    CM: "CM",
+    CN: "CN",
+    CO: "CO",
+    CR: "CR",
+    CU: "CU",
+    CV: "CV",
+    CW: "CW",
+    CX: "CX",
+    CY: "CY",
+    CZ: "CZ",
+    DE: "DE",
+    DJ: "DJ",
+    DK: "DK",
+    DM: "DM",
+    DO: "DO",
+    DZ: "DZ",
+    EC: "EC",
+    EE: "EE",
+    EG: "EG",
+    EH: "EH",
+    ER: "ER",
+    ES: "ES",
+    ET: "ET",
+    FI: "FI",
+    FJ: "FJ",
+    FK: "FK",
+    FM: "FM",
+    FO: "FO",
+    FR: "FR",
+    GA: "GA",
+    GB: "GB",
+    GD: "GD",
+    GE: "GE",
+    GF: "GF",
+    GG: "GG",
+    GH: "GH",
+    GI: "GI",
+    GL: "GL",
+    GM: "GM",
+    GN: "GN",
+    GP: "GP",
+    GQ: "GQ",
+    GR: "GR",
+    GS: "GS",
+    GT: "GT",
+    GU: "GU",
+    GW: "GW",
+    GY: "GY",
+    HK: "HK",
+    HM: "HM",
+    HN: "HN",
+    HR: "HR",
+    HT: "HT",
+    HU: "HU",
+    ID: "ID",
+    IE: "IE",
+    IL: "IL",
+    IM: "IM",
+    IN: "IN",
+    IO: "IO",
+    IQ: "IQ",
+    IR: "IR",
+    IS: "IS",
+    IT: "IT",
+    JE: "JE",
+    JM: "JM",
+    JO: "JO",
+    JP: "JP",
+    KE: "KE",
+    KG: "KG",
+    KH: "KH",
+    KI: "KI",
+    KM: "KM",
+    KN: "KN",
+    KP: "KP",
+    KR: "KR",
+    KW: "KW",
+    KY: "KY",
+    KZ: "KZ",
+    LA: "LA",
+    LB: "LB",
+    LC: "LC",
+    LI: "LI",
+    LK: "LK",
+    LR: "LR",
+    LS: "LS",
+    LT: "LT",
+    LU: "LU",
+    LV: "LV",
+    LY: "LY",
+    MA: "MA",
+    MC: "MC",
+    MD: "MD",
+    ME: "ME",
+    MF: "MF",
+    MG: "MG",
+    MH: "MH",
+    MK: "MK",
+    ML: "ML",
+    MM: "MM",
+    MN: "MN",
+    MO: "MO",
+    MP: "MP",
+    MQ: "MQ",
+    MR: "MR",
+    MS: "MS",
+    MT: "MT",
+    MU: "MU",
+    MV: "MV",
+    MW: "MW",
+    MX: "MX",
+    MY: "MY",
+    MZ: "MZ",
+    NA: "NA",
+    NC: "NC",
+    NE: "NE",
+    NF: "NF",
+    NG: "NG",
+    NI: "NI",
+    NL: "NL",
+    NO: "NO",
+    NP: "NP",
+    NR: "NR",
+    NU: "NU",
+    NZ: "NZ",
+    OM: "OM",
+    PA: "PA",
+    PE: "PE",
+    PF: "PF",
+    PG: "PG",
+    PH: "PH",
+    PK: "PK",
+    PL: "PL",
+    PM: "PM",
+    PN: "PN",
+    PR: "PR",
+    PS: "PS",
+    PT: "PT",
+    PW: "PW",
+    PY: "PY",
+    QA: "QA",
+    RE: "RE",
+    RO: "RO",
+    RS: "RS",
+    RU: "RU",
+    RW: "RW",
+    SA: "SA",
+    SB: "SB",
+    SC: "SC",
+    SD: "SD",
+    SE: "SE",
+    SG: "SG",
+    SH: "SH",
+    SI: "SI",
+    SJ: "SJ",
+    SK: "SK",
+    SL: "SL",
+    SM: "SM",
+    SN: "SN",
+    SO: "SO",
+    SR: "SR",
+    SS: "SS",
+    ST: "ST",
+    SV: "SV",
+    SX: "SX",
+    SY: "SY",
+    SZ: "SZ",
+    TC: "TC",
+    TD: "TD",
+    TF: "TF",
+    TG: "TG",
+    TH: "TH",
+    TJ: "TJ",
+    TK: "TK",
+    TL: "TL",
+    TM: "TM",
+    TN: "TN",
+    TO: "TO",
+    TR: "TR",
+    TT: "TT",
+    TV: "TV",
+    TW: "TW",
+    TZ: "TZ",
+    UA: "UA",
+    UG: "UG",
+    UM: "UM",
+    US: "US",
+    UY: "UY",
+    UZ: "UZ",
+    VA: "VA",
+    VC: "VC",
+    VE: "VE",
+    VG: "VG",
+    VI: "VI",
+    VN: "VN",
+    VU: "VU",
+    WF: "WF",
+    WS: "WS",
+    YE: "YE",
+    YT: "YT",
+    ZA: "ZA",
+    ZM: "ZM",
+    ZW: "ZW",
+};
+export const IPSetDescriptorType = {
+    IPV4: "IPV4",
+    IPV6: "IPV6",
+};
+export const RateKey = {
+    IP: "IP",
+};
+export const PredicateType = {
+    BYTE_MATCH: "ByteMatch",
+    GEO_MATCH: "GeoMatch",
+    IP_MATCH: "IPMatch",
+    REGEX_MATCH: "RegexMatch",
+    SIZE_CONSTRAINT: "SizeConstraint",
+    SQL_INJECTION_MATCH: "SqlInjectionMatch",
+    XSS_MATCH: "XssMatch",
+};
+export const ComparisonOperator = {
+    EQ: "EQ",
+    GE: "GE",
+    GT: "GT",
+    LE: "LE",
+    LT: "LT",
+    NE: "NE",
+};
+export const MigrationErrorType = {
+    ENTITY_NOT_FOUND: "ENTITY_NOT_FOUND",
+    ENTITY_NOT_SUPPORTED: "ENTITY_NOT_SUPPORTED",
+    S3_BUCKET_INVALID_REGION: "S3_BUCKET_INVALID_REGION",
+    S3_BUCKET_NOT_ACCESSIBLE: "S3_BUCKET_NOT_ACCESSIBLE",
+    S3_BUCKET_NOT_FOUND: "S3_BUCKET_NOT_FOUND",
+    S3_BUCKET_NO_PERMISSION: "S3_BUCKET_NO_PERMISSION",
+    S3_INTERNAL_ERROR: "S3_INTERNAL_ERROR",
+};
+export const ChangeTokenStatus = {
+    INSYNC: "INSYNC",
+    PENDING: "PENDING",
+    PROVISIONED: "PROVISIONED",
+};
+export const ResourceType = {
+    API_GATEWAY: "API_GATEWAY",
+    APPLICATION_LOAD_BALANCER: "APPLICATION_LOAD_BALANCER",
+};
+export const ChangeAction = {
+    DELETE: "DELETE",
+    INSERT: "INSERT",
+};

package/dist-es/models/errors.js

@@ -0,0 +1,251 @@
+import { WAFRegionalServiceException as __BaseException } from "./WAFRegionalServiceException";
+export class WAFInternalErrorException extends __BaseException {
+    name = "WAFInternalErrorException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "WAFInternalErrorException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFInternalErrorException.prototype);
+    }
+}
+export class WAFInvalidAccountException extends __BaseException {
+    name = "WAFInvalidAccountException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFInvalidAccountException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFInvalidAccountException.prototype);
+    }
+}
+export class WAFInvalidParameterException extends __BaseException {
+    name = "WAFInvalidParameterException";
+    $fault = "client";
+    field;
+    parameter;
+    reason;
+    constructor(opts) {
+        super({
+            name: "WAFInvalidParameterException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFInvalidParameterException.prototype);
+        this.field = opts.field;
+        this.parameter = opts.parameter;
+        this.reason = opts.reason;
+    }
+}
+export class WAFNonexistentItemException extends __BaseException {
+    name = "WAFNonexistentItemException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFNonexistentItemException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFNonexistentItemException.prototype);
+    }
+}
+export class WAFUnavailableEntityException extends __BaseException {
+    name = "WAFUnavailableEntityException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFUnavailableEntityException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFUnavailableEntityException.prototype);
+    }
+}
+export class WAFDisallowedNameException extends __BaseException {
+    name = "WAFDisallowedNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFDisallowedNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFDisallowedNameException.prototype);
+    }
+}
+export class WAFLimitsExceededException extends __BaseException {
+    name = "WAFLimitsExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFLimitsExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFLimitsExceededException.prototype);
+    }
+}
+export class WAFStaleDataException extends __BaseException {
+    name = "WAFStaleDataException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFStaleDataException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFStaleDataException.prototype);
+    }
+}
+export class WAFBadRequestException extends __BaseException {
+    name = "WAFBadRequestException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFBadRequestException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFBadRequestException.prototype);
+    }
+}
+export class WAFTagOperationException extends __BaseException {
+    name = "WAFTagOperationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFTagOperationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFTagOperationException.prototype);
+    }
+}
+export class WAFTagOperationInternalErrorException extends __BaseException {
+    name = "WAFTagOperationInternalErrorException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "WAFTagOperationInternalErrorException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFTagOperationInternalErrorException.prototype);
+    }
+}
+export class WAFEntityMigrationException extends __BaseException {
+    name = "WAFEntityMigrationException";
+    $fault = "client";
+    MigrationErrorType;
+    MigrationErrorReason;
+    constructor(opts) {
+        super({
+            name: "WAFEntityMigrationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFEntityMigrationException.prototype);
+        this.MigrationErrorType = opts.MigrationErrorType;
+        this.MigrationErrorReason = opts.MigrationErrorReason;
+    }
+}
+export class WAFInvalidOperationException extends __BaseException {
+    name = "WAFInvalidOperationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFInvalidOperationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFInvalidOperationException.prototype);
+    }
+}
+export class WAFNonEmptyEntityException extends __BaseException {
+    name = "WAFNonEmptyEntityException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFNonEmptyEntityException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFNonEmptyEntityException.prototype);
+    }
+}
+export class WAFReferencedItemException extends __BaseException {
+    name = "WAFReferencedItemException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFReferencedItemException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFReferencedItemException.prototype);
+    }
+}
+export class WAFServiceLinkedRoleErrorException extends __BaseException {
+    name = "WAFServiceLinkedRoleErrorException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFServiceLinkedRoleErrorException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFServiceLinkedRoleErrorException.prototype);
+    }
+}
+export class WAFInvalidPermissionPolicyException extends __BaseException {
+    name = "WAFInvalidPermissionPolicyException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFInvalidPermissionPolicyException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFInvalidPermissionPolicyException.prototype);
+    }
+}
+export class WAFNonexistentContainerException extends __BaseException {
+    name = "WAFNonexistentContainerException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFNonexistentContainerException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFNonexistentContainerException.prototype);
+    }
+}
+export class WAFInvalidRegexPatternException extends __BaseException {
+    name = "WAFInvalidRegexPatternException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFInvalidRegexPatternException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFInvalidRegexPatternException.prototype);
+    }
+}
+export class WAFSubscriptionNotFoundException extends __BaseException {
+    name = "WAFSubscriptionNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WAFSubscriptionNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WAFSubscriptionNotFoundException.prototype);
+    }
+}