interface OrStatementProperty

Language	Type name
.NET	Amazon.CDK.AWS.WAFv2.CfnWebACL.OrStatementProperty
Java	software.amazon.awscdk.services.wafv2.CfnWebACL.OrStatementProperty
Python	aws_cdk.aws_wafv2.CfnWebACL.OrStatementProperty
TypeScript	@aws-cdk/aws-wafv2 » CfnWebACL » OrStatementProperty

A logical rule statement used to combine other rule statements with OR logic.

You provide more than one Statement within the OrStatement .

Example

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import * as wafv2 from '@aws-cdk/aws-wafv2';

declare const all: any;
declare const allQueryArguments: any;
declare const method: any;
declare const queryString: any;
declare const singleHeader: any;
declare const singleQueryArgument: any;
declare const statementProperty_: wafv2.CfnWebACL.StatementProperty;
declare const uriPath: any;
const orStatementProperty: wafv2.CfnWebACL.OrStatementProperty = {
  statements: [{
    andStatement: {
      statements: [statementProperty_],
    },
    byteMatchStatement: {
      fieldToMatch: {
        allQueryArguments: allQueryArguments,
        body: {
          oversizeHandling: 'oversizeHandling',
        },
        cookies: {
          matchPattern: {
            all: all,
            excludedCookies: ['excludedCookies'],
            includedCookies: ['includedCookies'],
          },
          matchScope: 'matchScope',
          oversizeHandling: 'oversizeHandling',
        },
        headers: {
          matchPattern: {
            all: all,
            excludedHeaders: ['excludedHeaders'],
            includedHeaders: ['includedHeaders'],
          },
          matchScope: 'matchScope',
          oversizeHandling: 'oversizeHandling',
        },
        jsonBody: {
          matchPattern: {
            all: all,
            includedPaths: ['includedPaths'],
          },
          matchScope: 'matchScope',

          // the properties below are optional
          invalidFallbackBehavior: 'invalidFallbackBehavior',
          oversizeHandling: 'oversizeHandling',
        },
        method: method,
        queryString: queryString,
        singleHeader: singleHeader,
        singleQueryArgument: singleQueryArgument,
        uriPath: uriPath,
      },
      positionalConstraint: 'positionalConstraint',
      textTransformations: [{
        priority: 123,
        type: 'type',
      }],

      // the properties below are optional
      searchString: 'searchString',
      searchStringBase64: 'searchStringBase64',
    },
    geoMatchStatement: {
      countryCodes: ['countryCodes'],
      forwardedIpConfig: {
        fallbackBehavior: 'fallbackBehavior',
        headerName: 'headerName',
      },
    },
    ipSetReferenceStatement: {
      arn: 'arn',

      // the properties below are optional
      ipSetForwardedIpConfig: {
        fallbackBehavior: 'fallbackBehavior',
        headerName: 'headerName',
        position: 'position',
      },
    },
    labelMatchStatement: {
      key: 'key',
      scope: 'scope',
    },
    managedRuleGroupStatement: {
      name: 'name',
      vendorName: 'vendorName',

      // the properties below are optional
      excludedRules: [{
        name: 'name',
      }],
      managedRuleGroupConfigs: [{
        awsManagedRulesAtpRuleSet: {
          loginPath: 'loginPath',

          // the properties below are optional
          requestInspection: {
            passwordField: {
              identifier: 'identifier',
            },
            payloadType: 'payloadType',
            usernameField: {
              identifier: 'identifier',
            },
          },
          responseInspection: {
            bodyContains: {
              failureStrings: ['failureStrings'],
              successStrings: ['successStrings'],
            },
            header: {
              failureValues: ['failureValues'],
              name: 'name',
              successValues: ['successValues'],
            },
            json: {
              failureValues: ['failureValues'],
              identifier: 'identifier',
              successValues: ['successValues'],
            },
            statusCode: {
              failureCodes: [123],
              successCodes: [123],
            },
          },
        },
        awsManagedRulesBotControlRuleSet: {
          inspectionLevel: 'inspectionLevel',
        },
        loginPath: 'loginPath',
        passwordField: {
          identifier: 'identifier',
        },
        payloadType: 'payloadType',
        usernameField: {
          identifier: 'identifier',
        },
      }],
      ruleActionOverrides: [{
        actionToUse: {
          allow: {
            customRequestHandling: {
              insertHeaders: [{
                name: 'name',
                value: 'value',
              }],
            },
          },
          block: {
            customResponse: {
              responseCode: 123,

              // the properties below are optional
              customResponseBodyKey: 'customResponseBodyKey',
              responseHeaders: [{
                name: 'name',
                value: 'value',
              }],
            },
          },
          captcha: {
            customRequestHandling: {
              insertHeaders: [{
                name: 'name',
                value: 'value',
              }],
            },
          },
          challenge: {
            customRequestHandling: {
              insertHeaders: [{
                name: 'name',
                value: 'value',
              }],
            },
          },
          count: {
            customRequestHandling: {
              insertHeaders: [{
                name: 'name',
                value: 'value',
              }],
            },
          },
        },
        name: 'name',
      }],
      scopeDownStatement: statementProperty_,
      version: 'version',
    },
    notStatement: {
      statement: statementProperty_,
    },
    orStatement: {
      statements: [statementProperty_],
    },
    rateBasedStatement: {
      aggregateKeyType: 'aggregateKeyType',
      limit: 123,

      // the properties below are optional
      forwardedIpConfig: {
        fallbackBehavior: 'fallbackBehavior',
        headerName: 'headerName',
      },
      scopeDownStatement: statementProperty_,
    },
    regexMatchStatement: {
      fieldToMatch: {
        allQueryArguments: allQueryArguments,
        body: {
          oversizeHandling: 'oversizeHandling',
        },
        cookies: {
          matchPattern: {
            all: all,
            excludedCookies: ['excludedCookies'],
            includedCookies: ['includedCookies'],
          },
          matchScope: 'matchScope',
          oversizeHandling: 'oversizeHandling',
        },
        headers: {
          matchPattern: {
            all: all,
            excludedHeaders: ['excludedHeaders'],
            includedHeaders: ['includedHeaders'],
          },
          matchScope: 'matchScope',
          oversizeHandling: 'oversizeHandling',
        },
        jsonBody: {
          matchPattern: {
            all: all,
            includedPaths: ['includedPaths'],
          },
          matchScope: 'matchScope',

          // the properties below are optional
          invalidFallbackBehavior: 'invalidFallbackBehavior',
          oversizeHandling: 'oversizeHandling',
        },
        method: method,
        queryString: queryString,
        singleHeader: singleHeader,
        singleQueryArgument: singleQueryArgument,
        uriPath: uriPath,
      },
      regexString: 'regexString',
      textTransformations: [{
        priority: 123,
        type: 'type',
      }],
    },
    regexPatternSetReferenceStatement: {
      arn: 'arn',
      fieldToMatch: {
        allQueryArguments: allQueryArguments,
        body: {
          oversizeHandling: 'oversizeHandling',
        },
        cookies: {
          matchPattern: {
            all: all,
            excludedCookies: ['excludedCookies'],
            includedCookies: ['includedCookies'],
          },
          matchScope: 'matchScope',
          oversizeHandling: 'oversizeHandling',
        },
        headers: {
          matchPattern: {
            all: all,
            excludedHeaders: ['excludedHeaders'],
            includedHeaders: ['includedHeaders'],
          },
          matchScope: 'matchScope',
          oversizeHandling: 'oversizeHandling',
        },
        jsonBody: {
          matchPattern: {
            all: all,
            includedPaths: ['includedPaths'],
          },
          matchScope: 'matchScope',

          // the properties below are optional
          invalidFallbackBehavior: 'invalidFallbackBehavior',
          oversizeHandling: 'oversizeHandling',
        },
        method: method,
        queryString: queryString,
        singleHeader: singleHeader,
        singleQueryArgument: singleQueryArgument,
        uriPath: uriPath,
      },
      textTransformations: [{
        priority: 123,
        type: 'type',
      }],
    },
    ruleGroupReferenceStatement: {
      arn: 'arn',

      // the properties below are optional
      excludedRules: [{
        name: 'name',
      }],
      ruleActionOverrides: [{
        actionToUse: {
          allow: {
            customRequestHandling: {
              insertHeaders: [{
                name: 'name',
                value: 'value',
              }],
            },
          },
          block: {
            customResponse: {
              responseCode: 123,

              // the properties below are optional
              customResponseBodyKey: 'customResponseBodyKey',
              responseHeaders: [{
                name: 'name',
                value: 'value',
              }],
            },
          },
          captcha: {
            customRequestHandling: {
              insertHeaders: [{
                name: 'name',
                value: 'value',
              }],
            },
          },
          challenge: {
            customRequestHandling: {
              insertHeaders: [{
                name: 'name',
                value: 'value',
              }],
            },
          },
          count: {
            customRequestHandling: {
              insertHeaders: [{
                name: 'name',
                value: 'value',
              }],
            },
          },
        },
        name: 'name',
      }],
    },
    sizeConstraintStatement: {
      comparisonOperator: 'comparisonOperator',
      fieldToMatch: {
        allQueryArguments: allQueryArguments,
        body: {
          oversizeHandling: 'oversizeHandling',
        },
        cookies: {
          matchPattern: {
            all: all,
            excludedCookies: ['excludedCookies'],
            includedCookies: ['includedCookies'],
          },
          matchScope: 'matchScope',
          oversizeHandling: 'oversizeHandling',
        },
        headers: {
          matchPattern: {
            all: all,
            excludedHeaders: ['excludedHeaders'],
            includedHeaders: ['includedHeaders'],
          },
          matchScope: 'matchScope',
          oversizeHandling: 'oversizeHandling',
        },
        jsonBody: {
          matchPattern: {
            all: all,
            includedPaths: ['includedPaths'],
          },
          matchScope: 'matchScope',

          // the properties below are optional
          invalidFallbackBehavior: 'invalidFallbackBehavior',
          oversizeHandling: 'oversizeHandling',
        },
        method: method,
        queryString: queryString,
        singleHeader: singleHeader,
        singleQueryArgument: singleQueryArgument,
        uriPath: uriPath,
      },
      size: 123,
      textTransformations: [{
        priority: 123,
        type: 'type',
      }],
    },
    sqliMatchStatement: {
      fieldToMatch: {
        allQueryArguments: allQueryArguments,
        body: {
          oversizeHandling: 'oversizeHandling',
        },
        cookies: {
          matchPattern: {
            all: all,
            excludedCookies: ['excludedCookies'],
            includedCookies: ['includedCookies'],
          },
          matchScope: 'matchScope',
          oversizeHandling: 'oversizeHandling',
        },
        headers: {
          matchPattern: {
            all: all,
            excludedHeaders: ['excludedHeaders'],
            includedHeaders: ['includedHeaders'],
          },
          matchScope: 'matchScope',
          oversizeHandling: 'oversizeHandling',
        },
        jsonBody: {
          matchPattern: {
            all: all,
            includedPaths: ['includedPaths'],
          },
          matchScope: 'matchScope',

          // the properties below are optional
          invalidFallbackBehavior: 'invalidFallbackBehavior',
          oversizeHandling: 'oversizeHandling',
        },
        method: method,
        queryString: queryString,
        singleHeader: singleHeader,
        singleQueryArgument: singleQueryArgument,
        uriPath: uriPath,
      },
      textTransformations: [{
        priority: 123,
        type: 'type',
      }],

      // the properties below are optional
      sensitivityLevel: 'sensitivityLevel',
    },
    xssMatchStatement: {
      fieldToMatch: {
        allQueryArguments: allQueryArguments,
        body: {
          oversizeHandling: 'oversizeHandling',
        },
        cookies: {
          matchPattern: {
            all: all,
            excludedCookies: ['excludedCookies'],
            includedCookies: ['includedCookies'],
          },
          matchScope: 'matchScope',
          oversizeHandling: 'oversizeHandling',
        },
        headers: {
          matchPattern: {
            all: all,
            excludedHeaders: ['excludedHeaders'],
            includedHeaders: ['includedHeaders'],
          },
          matchScope: 'matchScope',
          oversizeHandling: 'oversizeHandling',
        },
        jsonBody: {
          matchPattern: {
            all: all,
            includedPaths: ['includedPaths'],
          },
          matchScope: 'matchScope',

          // the properties below are optional
          invalidFallbackBehavior: 'invalidFallbackBehavior',
          oversizeHandling: 'oversizeHandling',
        },
        method: method,
        queryString: queryString,
        singleHeader: singleHeader,
        singleQueryArgument: singleQueryArgument,
        uriPath: uriPath,
      },
      textTransformations: [{
        priority: 123,
        type: 'type',
      }],
    },
  }],
};

Properties

Name	Type	Description
statements	IResolvable | IResolvable | StatementProperty[]	The statements to combine with OR logic.

---

statements

Type: IResolvable | IResolvable | StatementProperty[]

The statements to combine with OR logic.

You can use any statements that can be nested.