@aws-sdk/client-wafv2 3.933.0 → 3.935.0

package/dist-types/models/errors.d.ts

@@ -0,0 +1,368 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { ParameterExceptionField } from "./enums";
+import { DisallowedFeature } from "./models_0";
+import { WAFV2ServiceException as __BaseException } from "./WAFV2ServiceException";
+/**
+ * <p>The operation failed because the specified WAF feature isn't supported by the CloudFront pricing plan associated with the web ACL.</p>
+ * @public
+ */
+export declare class WAFFeatureNotIncludedInPricingPlanException extends __BaseException {
+    readonly name: "WAFFeatureNotIncludedInPricingPlanException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * <p>The names of the disallowed WAF features.</p>
+     * @public
+     */
+    DisallowedFeatures?: DisallowedFeature[] | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFFeatureNotIncludedInPricingPlanException, __BaseException>);
+}
+/**
+ * <p>Your request is valid, but WAF couldn’t perform the operation because of a system
+ *          problem. Retry your request. </p>
+ * @public
+ */
+export declare class WAFInternalErrorException extends __BaseException {
+    readonly name: "WAFInternalErrorException";
+    readonly $fault: "server";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFInternalErrorException, __BaseException>);
+}
+/**
+ * <p>The operation isn't valid. </p>
+ * @public
+ */
+export declare class WAFInvalidOperationException extends __BaseException {
+    readonly name: "WAFInvalidOperationException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFInvalidOperationException, __BaseException>);
+}
+/**
+ * <p>The operation failed because WAF didn't recognize a parameter in the request. For
+ *          example: </p>
+ *          <ul>
+ *             <li>
+ *                <p>You specified a parameter name or value that isn't valid.</p>
+ *             </li>
+ *             <li>
+ *                <p>Your nested statement isn't valid. You might have tried to nest a statement that
+ *                can’t be nested. </p>
+ *             </li>
+ *             <li>
+ *                <p>You tried to update a <code>WebACL</code> with a <code>DefaultAction</code> that
+ *                isn't among the types available at <a>DefaultAction</a>.</p>
+ *             </li>
+ *             <li>
+ *                <p>Your request references an ARN that is malformed, or corresponds to a resource
+ *                with which a web ACL can't be associated.</p>
+ *             </li>
+ *          </ul>
+ * @public
+ */
+export declare class WAFInvalidParameterException extends __BaseException {
+    readonly name: "WAFInvalidParameterException";
+    readonly $fault: "client";
+    /**
+     * <p>The settings where the invalid parameter was found. </p>
+     * @public
+     */
+    Field?: ParameterExceptionField | undefined;
+    /**
+     * <p>The invalid parameter that resulted in the exception. </p>
+     * @public
+     */
+    Parameter?: string | undefined;
+    /**
+     * <p>Additional information about the exception.</p>
+     * @public
+     */
+    Reason?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFInvalidParameterException, __BaseException>);
+}
+/**
+ * <p>WAF couldn’t perform the operation because you exceeded your resource limit. For
+ *          example, the maximum number of <code>WebACL</code> objects that you can create for an Amazon Web Services
+ *          account. For more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/limits.html">WAF quotas</a> in the
+ *             <i>WAF Developer Guide</i>.</p>
+ * @public
+ */
+export declare class WAFLimitsExceededException extends __BaseException {
+    readonly name: "WAFLimitsExceededException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * <p>Source type for the exception. </p>
+     * @public
+     */
+    SourceType?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFLimitsExceededException, __BaseException>);
+}
+/**
+ * <p>WAF couldn’t perform the operation because your resource doesn't exist.
+ *        If you've just created a resource that you're using in this operation, you might
+ *        just need to wait a few minutes. It can take from a few seconds to a number of minutes
+ *        for changes to propagate. </p>
+ * @public
+ */
+export declare class WAFNonexistentItemException extends __BaseException {
+    readonly name: "WAFNonexistentItemException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFNonexistentItemException, __BaseException>);
+}
+/**
+ * <p>WAF couldn’t retrieve a resource that you specified for this operation.
+ *        If you've just created a resource that you're using in this operation, you might
+ *        just need to wait a few minutes. It can take from a few seconds to a number of minutes
+ *        for changes to propagate. Verify the resource specifications in your request
+ *        parameters and then retry the operation.</p>
+ * @public
+ */
+export declare class WAFUnavailableEntityException extends __BaseException {
+    readonly name: "WAFUnavailableEntityException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFUnavailableEntityException, __BaseException>);
+}
+/**
+ * <p>The operation failed because the specified version for the managed rule group has
+ *          expired. You can retrieve the available versions for the managed rule group by calling
+ *             <a>ListAvailableManagedRuleGroupVersions</a>.</p>
+ * @public
+ */
+export declare class WAFExpiredManagedRuleGroupVersionException extends __BaseException {
+    readonly name: "WAFExpiredManagedRuleGroupVersionException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFExpiredManagedRuleGroupVersionException, __BaseException>);
+}
+/**
+ * <p>WAF couldn’t perform the operation because the resource that you requested isn’t
+ *          valid. Check the resource, and try again.</p>
+ * @public
+ */
+export declare class WAFInvalidResourceException extends __BaseException {
+    readonly name: "WAFInvalidResourceException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFInvalidResourceException, __BaseException>);
+}
+/**
+ * <p>You tried to use a managed rule group that's available by subscription, but you aren't
+ *          subscribed to it yet. </p>
+ * @public
+ */
+export declare class WAFSubscriptionNotFoundException extends __BaseException {
+    readonly name: "WAFSubscriptionNotFoundException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFSubscriptionNotFoundException, __BaseException>);
+}
+/**
+ * <p>WAF couldn’t perform the operation because the resource that you tried to save is
+ *          a duplicate of an existing one.</p>
+ * @public
+ */
+export declare class WAFDuplicateItemException extends __BaseException {
+    readonly name: "WAFDuplicateItemException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFDuplicateItemException, __BaseException>);
+}
+/**
+ * <p>WAF couldn’t save your changes because you tried to update or delete a resource
+ *          that has changed since you last retrieved it. Get the resource again, make any changes you
+ *          need to make to the new copy, and retry your operation. </p>
+ * @public
+ */
+export declare class WAFOptimisticLockException extends __BaseException {
+    readonly name: "WAFOptimisticLockException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFOptimisticLockException, __BaseException>);
+}
+/**
+ * <p>An error occurred during the tagging operation. Retry your request.</p>
+ * @public
+ */
+export declare class WAFTagOperationException extends __BaseException {
+    readonly name: "WAFTagOperationException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFTagOperationException, __BaseException>);
+}
+/**
+ * <p>WAF couldn’t perform your tagging operation because of an internal error. Retry
+ *          your request.</p>
+ * @public
+ */
+export declare class WAFTagOperationInternalErrorException extends __BaseException {
+    readonly name: "WAFTagOperationInternalErrorException";
+    readonly $fault: "server";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFTagOperationInternalErrorException, __BaseException>);
+}
+/**
+ * <p>The operation failed because you are inspecting the web request body, headers, or
+ *          cookies without specifying how to handle oversize components. Rules that inspect the body
+ *          must either provide an <code>OversizeHandling</code> configuration or they must be preceded
+ *          by a <code>SizeConstraintStatement</code> that blocks the body content from being too
+ *          large. Rules that inspect the headers or cookies must provide an
+ *             <code>OversizeHandling</code> configuration. </p>
+ *          <p>Provide the handling configuration and retry your operation.</p>
+ *          <p>Alternately, you can suppress this warning by adding the following tag to the resource
+ *          that you provide to this operation: <code>Tag</code>
+ *             (key:<code>WAF:OversizeFieldsHandlingConstraintOptOut</code>,
+ *          value:<code>true</code>).</p>
+ * @public
+ */
+export declare class WAFConfigurationWarningException extends __BaseException {
+    readonly name: "WAFConfigurationWarningException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFConfigurationWarningException, __BaseException>);
+}
+/**
+ * <p>WAF couldn’t perform the operation because your resource is being used by another
+ *          resource or it’s associated with another resource. </p>
+ * @public
+ */
+export declare class WAFAssociatedItemException extends __BaseException {
+    readonly name: "WAFAssociatedItemException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFAssociatedItemException, __BaseException>);
+}
+/**
+ * <p>The rule that you've named doesn't aggregate solely on the IP address or solely on the forwarded IP address. This call
+ *            is only available for rate-based rules with an <code>AggregateKeyType</code> setting of <code>IP</code> or <code>FORWARDED_IP</code>.</p>
+ * @public
+ */
+export declare class WAFUnsupportedAggregateKeyTypeException extends __BaseException {
+    readonly name: "WAFUnsupportedAggregateKeyTypeException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFUnsupportedAggregateKeyTypeException, __BaseException>);
+}
+/**
+ * <p>The operation failed because you don't have the permissions that your logging
+ *          configuration requires. For information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/logging.html">Logging web ACL traffic information</a>
+ *          in the <i>WAF Developer Guide</i>.</p>
+ * @public
+ */
+export declare class WAFLogDestinationPermissionIssueException extends __BaseException {
+    readonly name: "WAFLogDestinationPermissionIssueException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFLogDestinationPermissionIssueException, __BaseException>);
+}
+/**
+ * <p>WAF is not able to access the service linked role. This can be caused by a
+ *          previous <code>PutLoggingConfiguration</code> request, which can lock the service linked
+ *          role for about 20 seconds. Please try your request again. The service linked role can also
+ *          be locked by a previous <code>DeleteServiceLinkedRole</code> request, which can lock the
+ *          role for 15 minutes or more. If you recently made a call to
+ *             <code>DeleteServiceLinkedRole</code>, wait at least 15 minutes and try the request
+ *          again. If you receive this same exception again, you will have to wait additional time
+ *          until the role is unlocked.</p>
+ * @public
+ */
+export declare class WAFServiceLinkedRoleErrorException extends __BaseException {
+    readonly name: "WAFServiceLinkedRoleErrorException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFServiceLinkedRoleErrorException, __BaseException>);
+}
+/**
+ * <p>The operation failed because the specified policy isn't in the proper format. </p>
+ *          <p>The policy specifications must conform to the following:</p>
+ *          <ul>
+ *             <li>
+ *                <p>The policy must be composed using IAM Policy version 2012-10-17.</p>
+ *             </li>
+ *             <li>
+ *                <p>The policy must include specifications for <code>Effect</code>, <code>Action</code>, and <code>Principal</code>.</p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <code>Effect</code> must specify <code>Allow</code>.</p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <code>Action</code> must specify <code>wafv2:CreateWebACL</code>, <code>wafv2:UpdateWebACL</code>, and
+ *              <code>wafv2:PutFirewallManagerRuleGroups</code> and may optionally specify <code>wafv2:GetRuleGroup</code>.
+ *                  WAF rejects any extra actions or wildcard actions in the policy.</p>
+ *             </li>
+ *             <li>
+ *                <p>The policy must not include a <code>Resource</code> parameter.</p>
+ *             </li>
+ *          </ul>
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html">IAM Policies</a>.  </p>
+ * @public
+ */
+export declare class WAFInvalidPermissionPolicyException extends __BaseException {
+    readonly name: "WAFInvalidPermissionPolicyException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WAFInvalidPermissionPolicyException, __BaseException>);
+}