@aws-sdk/client-route53resolver 3.34.0 → 3.37.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1921 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace AccessDeniedException {
+    
+    const filterSensitiveLog: (obj: AccessDeniedException) => any;
+}
+export declare enum Action {
+    ALERT = "ALERT",
+    ALLOW = "ALLOW",
+    BLOCK = "BLOCK"
+}
+export declare enum MutationProtectionStatus {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface AssociateFirewallRuleGroupRequest {
+    
+    CreatorRequestId?: string;
+    
+    FirewallRuleGroupId: string | undefined;
+    
+    VpcId: string | undefined;
+    
+    Priority: number | undefined;
+    
+    Name: string | undefined;
+    
+    MutationProtection?: MutationProtectionStatus | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace AssociateFirewallRuleGroupRequest {
+    
+    const filterSensitiveLog: (obj: AssociateFirewallRuleGroupRequest) => any;
+}
+export declare enum FirewallRuleGroupAssociationStatus {
+    COMPLETE = "COMPLETE",
+    DELETING = "DELETING",
+    UPDATING = "UPDATING"
+}
+
+export interface FirewallRuleGroupAssociation {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    FirewallRuleGroupId?: string;
+    
+    VpcId?: string;
+    
+    Name?: string;
+    
+    Priority?: number;
+    
+    MutationProtection?: MutationProtectionStatus | string;
+    
+    ManagedOwnerName?: string;
+    
+    Status?: FirewallRuleGroupAssociationStatus | string;
+    
+    StatusMessage?: string;
+    
+    CreatorRequestId?: string;
+    
+    CreationTime?: string;
+    
+    ModificationTime?: string;
+}
+export declare namespace FirewallRuleGroupAssociation {
+    
+    const filterSensitiveLog: (obj: FirewallRuleGroupAssociation) => any;
+}
+export interface AssociateFirewallRuleGroupResponse {
+    
+    FirewallRuleGroupAssociation?: FirewallRuleGroupAssociation;
+}
+export declare namespace AssociateFirewallRuleGroupResponse {
+    
+    const filterSensitiveLog: (obj: AssociateFirewallRuleGroupResponse) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ConflictException {
+    
+    const filterSensitiveLog: (obj: ConflictException) => any;
+}
+
+export interface InternalServiceErrorException extends __SmithyException, $MetadataBearer {
+    name: "InternalServiceErrorException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InternalServiceErrorException {
+    
+    const filterSensitiveLog: (obj: InternalServiceErrorException) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    Message?: string;
+    
+    ResourceType?: string;
+}
+export declare namespace LimitExceededException {
+    
+    const filterSensitiveLog: (obj: LimitExceededException) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    Message?: string;
+    
+    ResourceType?: string;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ThrottlingException {
+    
+    const filterSensitiveLog: (obj: ThrottlingException) => any;
+}
+
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ValidationException {
+    
+    const filterSensitiveLog: (obj: ValidationException) => any;
+}
+
+export interface IpAddressUpdate {
+    
+    IpId?: string;
+    
+    SubnetId?: string;
+    
+    Ip?: string;
+}
+export declare namespace IpAddressUpdate {
+    
+    const filterSensitiveLog: (obj: IpAddressUpdate) => any;
+}
+export interface AssociateResolverEndpointIpAddressRequest {
+    
+    ResolverEndpointId: string | undefined;
+    
+    IpAddress: IpAddressUpdate | undefined;
+}
+export declare namespace AssociateResolverEndpointIpAddressRequest {
+    
+    const filterSensitiveLog: (obj: AssociateResolverEndpointIpAddressRequest) => any;
+}
+export declare enum ResolverEndpointDirection {
+    Inbound = "INBOUND",
+    Outbound = "OUTBOUND"
+}
+export declare enum ResolverEndpointStatus {
+    ActionNeeded = "ACTION_NEEDED",
+    AutoRecovering = "AUTO_RECOVERING",
+    Creating = "CREATING",
+    Deleting = "DELETING",
+    Operational = "OPERATIONAL",
+    Updating = "UPDATING"
+}
+
+export interface ResolverEndpoint {
+    
+    Id?: string;
+    
+    CreatorRequestId?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    SecurityGroupIds?: string[];
+    
+    Direction?: ResolverEndpointDirection | string;
+    
+    IpAddressCount?: number;
+    
+    HostVPCId?: string;
+    
+    Status?: ResolverEndpointStatus | string;
+    
+    StatusMessage?: string;
+    
+    CreationTime?: string;
+    
+    ModificationTime?: string;
+}
+export declare namespace ResolverEndpoint {
+    
+    const filterSensitiveLog: (obj: ResolverEndpoint) => any;
+}
+export interface AssociateResolverEndpointIpAddressResponse {
+    
+    ResolverEndpoint?: ResolverEndpoint;
+}
+export declare namespace AssociateResolverEndpointIpAddressResponse {
+    
+    const filterSensitiveLog: (obj: AssociateResolverEndpointIpAddressResponse) => any;
+}
+
+export interface InvalidParameterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameterException";
+    $fault: "client";
+    Message: string | undefined;
+    
+    FieldName?: string;
+}
+export declare namespace InvalidParameterException {
+    
+    const filterSensitiveLog: (obj: InvalidParameterException) => any;
+}
+
+export interface InvalidRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRequestException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidRequestException {
+    
+    const filterSensitiveLog: (obj: InvalidRequestException) => any;
+}
+
+export interface ResourceExistsException extends __SmithyException, $MetadataBearer {
+    name: "ResourceExistsException";
+    $fault: "client";
+    Message?: string;
+    
+    ResourceType?: string;
+}
+export declare namespace ResourceExistsException {
+    
+    const filterSensitiveLog: (obj: ResourceExistsException) => any;
+}
+export interface AssociateResolverQueryLogConfigRequest {
+    
+    ResolverQueryLogConfigId: string | undefined;
+    
+    ResourceId: string | undefined;
+}
+export declare namespace AssociateResolverQueryLogConfigRequest {
+    
+    const filterSensitiveLog: (obj: AssociateResolverQueryLogConfigRequest) => any;
+}
+export declare enum ResolverQueryLogConfigAssociationError {
+    AccessDenied = "ACCESS_DENIED",
+    DestinationNotFound = "DESTINATION_NOT_FOUND",
+    InternalServiceError = "INTERNAL_SERVICE_ERROR",
+    None = "NONE"
+}
+export declare enum ResolverQueryLogConfigAssociationStatus {
+    ActionNeeded = "ACTION_NEEDED",
+    Active = "ACTIVE",
+    Creating = "CREATING",
+    Deleting = "DELETING",
+    Failed = "FAILED"
+}
+
+export interface ResolverQueryLogConfigAssociation {
+    
+    Id?: string;
+    
+    ResolverQueryLogConfigId?: string;
+    
+    ResourceId?: string;
+    
+    Status?: ResolverQueryLogConfigAssociationStatus | string;
+    
+    Error?: ResolverQueryLogConfigAssociationError | string;
+    
+    ErrorMessage?: string;
+    
+    CreationTime?: string;
+}
+export declare namespace ResolverQueryLogConfigAssociation {
+    
+    const filterSensitiveLog: (obj: ResolverQueryLogConfigAssociation) => any;
+}
+export interface AssociateResolverQueryLogConfigResponse {
+    
+    ResolverQueryLogConfigAssociation?: ResolverQueryLogConfigAssociation;
+}
+export declare namespace AssociateResolverQueryLogConfigResponse {
+    
+    const filterSensitiveLog: (obj: AssociateResolverQueryLogConfigResponse) => any;
+}
+export interface AssociateResolverRuleRequest {
+    
+    ResolverRuleId: string | undefined;
+    
+    Name?: string;
+    
+    VPCId: string | undefined;
+}
+export declare namespace AssociateResolverRuleRequest {
+    
+    const filterSensitiveLog: (obj: AssociateResolverRuleRequest) => any;
+}
+export declare enum ResolverRuleAssociationStatus {
+    Complete = "COMPLETE",
+    Creating = "CREATING",
+    Deleting = "DELETING",
+    Failed = "FAILED",
+    Overridden = "OVERRIDDEN"
+}
+
+export interface ResolverRuleAssociation {
+    
+    Id?: string;
+    
+    ResolverRuleId?: string;
+    
+    Name?: string;
+    
+    VPCId?: string;
+    
+    Status?: ResolverRuleAssociationStatus | string;
+    
+    StatusMessage?: string;
+}
+export declare namespace ResolverRuleAssociation {
+    
+    const filterSensitiveLog: (obj: ResolverRuleAssociation) => any;
+}
+export interface AssociateResolverRuleResponse {
+    
+    ResolverRuleAssociation?: ResolverRuleAssociation;
+}
+export declare namespace AssociateResolverRuleResponse {
+    
+    const filterSensitiveLog: (obj: AssociateResolverRuleResponse) => any;
+}
+
+export interface ResourceUnavailableException extends __SmithyException, $MetadataBearer {
+    name: "ResourceUnavailableException";
+    $fault: "client";
+    Message?: string;
+    
+    ResourceType?: string;
+}
+export declare namespace ResourceUnavailableException {
+    
+    const filterSensitiveLog: (obj: ResourceUnavailableException) => any;
+}
+export declare enum BlockOverrideDnsType {
+    CNAME = "CNAME"
+}
+export declare enum BlockResponse {
+    NODATA = "NODATA",
+    NXDOMAIN = "NXDOMAIN",
+    OVERRIDE = "OVERRIDE"
+}
+export interface CreateFirewallDomainListRequest {
+    
+    CreatorRequestId?: string;
+    
+    Name: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateFirewallDomainListRequest {
+    
+    const filterSensitiveLog: (obj: CreateFirewallDomainListRequest) => any;
+}
+export declare enum FirewallDomainListStatus {
+    COMPLETE = "COMPLETE",
+    COMPLETE_IMPORT_FAILED = "COMPLETE_IMPORT_FAILED",
+    DELETING = "DELETING",
+    IMPORTING = "IMPORTING",
+    UPDATING = "UPDATING"
+}
+
+export interface FirewallDomainList {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    DomainCount?: number;
+    
+    Status?: FirewallDomainListStatus | string;
+    
+    StatusMessage?: string;
+    
+    ManagedOwnerName?: string;
+    
+    CreatorRequestId?: string;
+    
+    CreationTime?: string;
+    
+    ModificationTime?: string;
+}
+export declare namespace FirewallDomainList {
+    
+    const filterSensitiveLog: (obj: FirewallDomainList) => any;
+}
+export interface CreateFirewallDomainListResponse {
+    
+    FirewallDomainList?: FirewallDomainList;
+}
+export declare namespace CreateFirewallDomainListResponse {
+    
+    const filterSensitiveLog: (obj: CreateFirewallDomainListResponse) => any;
+}
+export interface CreateFirewallRuleRequest {
+    
+    CreatorRequestId?: string;
+    
+    FirewallRuleGroupId: string | undefined;
+    
+    FirewallDomainListId: string | undefined;
+    
+    Priority: number | undefined;
+    
+    Action: Action | string | undefined;
+    
+    BlockResponse?: BlockResponse | string;
+    
+    BlockOverrideDomain?: string;
+    
+    BlockOverrideDnsType?: BlockOverrideDnsType | string;
+    
+    BlockOverrideTtl?: number;
+    
+    Name: string | undefined;
+}
+export declare namespace CreateFirewallRuleRequest {
+    
+    const filterSensitiveLog: (obj: CreateFirewallRuleRequest) => any;
+}
+
+export interface FirewallRule {
+    
+    FirewallRuleGroupId?: string;
+    
+    FirewallDomainListId?: string;
+    
+    Name?: string;
+    
+    Priority?: number;
+    
+    Action?: Action | string;
+    
+    BlockResponse?: BlockResponse | string;
+    
+    BlockOverrideDomain?: string;
+    
+    BlockOverrideDnsType?: BlockOverrideDnsType | string;
+    
+    BlockOverrideTtl?: number;
+    
+    CreatorRequestId?: string;
+    
+    CreationTime?: string;
+    
+    ModificationTime?: string;
+}
+export declare namespace FirewallRule {
+    
+    const filterSensitiveLog: (obj: FirewallRule) => any;
+}
+export interface CreateFirewallRuleResponse {
+    
+    FirewallRule?: FirewallRule;
+}
+export declare namespace CreateFirewallRuleResponse {
+    
+    const filterSensitiveLog: (obj: CreateFirewallRuleResponse) => any;
+}
+export interface CreateFirewallRuleGroupRequest {
+    
+    CreatorRequestId?: string;
+    
+    Name: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateFirewallRuleGroupRequest {
+    
+    const filterSensitiveLog: (obj: CreateFirewallRuleGroupRequest) => any;
+}
+export declare enum ShareStatus {
+    NotShared = "NOT_SHARED",
+    SharedByMe = "SHARED_BY_ME",
+    SharedWithMe = "SHARED_WITH_ME"
+}
+export declare enum FirewallRuleGroupStatus {
+    COMPLETE = "COMPLETE",
+    DELETING = "DELETING",
+    UPDATING = "UPDATING"
+}
+
+export interface FirewallRuleGroup {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    RuleCount?: number;
+    
+    Status?: FirewallRuleGroupStatus | string;
+    
+    StatusMessage?: string;
+    
+    OwnerId?: string;
+    
+    CreatorRequestId?: string;
+    
+    ShareStatus?: ShareStatus | string;
+    
+    CreationTime?: string;
+    
+    ModificationTime?: string;
+}
+export declare namespace FirewallRuleGroup {
+    
+    const filterSensitiveLog: (obj: FirewallRuleGroup) => any;
+}
+export interface CreateFirewallRuleGroupResponse {
+    
+    FirewallRuleGroup?: FirewallRuleGroup;
+}
+export declare namespace CreateFirewallRuleGroupResponse {
+    
+    const filterSensitiveLog: (obj: CreateFirewallRuleGroupResponse) => any;
+}
+
+export interface IpAddressRequest {
+    
+    SubnetId: string | undefined;
+    
+    Ip?: string;
+}
+export declare namespace IpAddressRequest {
+    
+    const filterSensitiveLog: (obj: IpAddressRequest) => any;
+}
+export interface CreateResolverEndpointRequest {
+    
+    CreatorRequestId: string | undefined;
+    
+    Name?: string;
+    
+    SecurityGroupIds: string[] | undefined;
+    
+    Direction: ResolverEndpointDirection | string | undefined;
+    
+    IpAddresses: IpAddressRequest[] | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateResolverEndpointRequest {
+    
+    const filterSensitiveLog: (obj: CreateResolverEndpointRequest) => any;
+}
+export interface CreateResolverEndpointResponse {
+    
+    ResolverEndpoint?: ResolverEndpoint;
+}
+export declare namespace CreateResolverEndpointResponse {
+    
+    const filterSensitiveLog: (obj: CreateResolverEndpointResponse) => any;
+}
+export interface CreateResolverQueryLogConfigRequest {
+    
+    Name: string | undefined;
+    
+    DestinationArn: string | undefined;
+    
+    CreatorRequestId?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateResolverQueryLogConfigRequest {
+    
+    const filterSensitiveLog: (obj: CreateResolverQueryLogConfigRequest) => any;
+}
+export declare enum ResolverQueryLogConfigStatus {
+    Created = "CREATED",
+    Creating = "CREATING",
+    Deleting = "DELETING",
+    Failed = "FAILED"
+}
+
+export interface ResolverQueryLogConfig {
+    
+    Id?: string;
+    
+    OwnerId?: string;
+    
+    Status?: ResolverQueryLogConfigStatus | string;
+    
+    ShareStatus?: ShareStatus | string;
+    
+    AssociationCount?: number;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    DestinationArn?: string;
+    
+    CreatorRequestId?: string;
+    
+    CreationTime?: string;
+}
+export declare namespace ResolverQueryLogConfig {
+    
+    const filterSensitiveLog: (obj: ResolverQueryLogConfig) => any;
+}
+export interface CreateResolverQueryLogConfigResponse {
+    
+    ResolverQueryLogConfig?: ResolverQueryLogConfig;
+}
+export declare namespace CreateResolverQueryLogConfigResponse {
+    
+    const filterSensitiveLog: (obj: CreateResolverQueryLogConfigResponse) => any;
+}
+export declare enum RuleTypeOption {
+    Forward = "FORWARD",
+    Recursive = "RECURSIVE",
+    System = "SYSTEM"
+}
+
+export interface TargetAddress {
+    
+    Ip: string | undefined;
+    
+    Port?: number;
+}
+export declare namespace TargetAddress {
+    
+    const filterSensitiveLog: (obj: TargetAddress) => any;
+}
+export interface CreateResolverRuleRequest {
+    
+    CreatorRequestId: string | undefined;
+    
+    Name?: string;
+    
+    RuleType: RuleTypeOption | string | undefined;
+    
+    DomainName: string | undefined;
+    
+    TargetIps?: TargetAddress[];
+    
+    ResolverEndpointId?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateResolverRuleRequest {
+    
+    const filterSensitiveLog: (obj: CreateResolverRuleRequest) => any;
+}
+export declare enum ResolverRuleStatus {
+    Complete = "COMPLETE",
+    Deleting = "DELETING",
+    Failed = "FAILED",
+    Updating = "UPDATING"
+}
+
+export interface ResolverRule {
+    
+    Id?: string;
+    
+    CreatorRequestId?: string;
+    
+    Arn?: string;
+    
+    DomainName?: string;
+    
+    Status?: ResolverRuleStatus | string;
+    
+    StatusMessage?: string;
+    
+    RuleType?: RuleTypeOption | string;
+    
+    Name?: string;
+    
+    TargetIps?: TargetAddress[];
+    
+    ResolverEndpointId?: string;
+    
+    OwnerId?: string;
+    
+    ShareStatus?: ShareStatus | string;
+    
+    CreationTime?: string;
+    
+    ModificationTime?: string;
+}
+export declare namespace ResolverRule {
+    
+    const filterSensitiveLog: (obj: ResolverRule) => any;
+}
+export interface CreateResolverRuleResponse {
+    
+    ResolverRule?: ResolverRule;
+}
+export declare namespace CreateResolverRuleResponse {
+    
+    const filterSensitiveLog: (obj: CreateResolverRuleResponse) => any;
+}
+export interface DeleteFirewallDomainListRequest {
+    
+    FirewallDomainListId: string | undefined;
+}
+export declare namespace DeleteFirewallDomainListRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFirewallDomainListRequest) => any;
+}
+export interface DeleteFirewallDomainListResponse {
+    
+    FirewallDomainList?: FirewallDomainList;
+}
+export declare namespace DeleteFirewallDomainListResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFirewallDomainListResponse) => any;
+}
+export interface DeleteFirewallRuleRequest {
+    
+    FirewallRuleGroupId: string | undefined;
+    
+    FirewallDomainListId: string | undefined;
+}
+export declare namespace DeleteFirewallRuleRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFirewallRuleRequest) => any;
+}
+export interface DeleteFirewallRuleResponse {
+    
+    FirewallRule?: FirewallRule;
+}
+export declare namespace DeleteFirewallRuleResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFirewallRuleResponse) => any;
+}
+export interface DeleteFirewallRuleGroupRequest {
+    
+    FirewallRuleGroupId: string | undefined;
+}
+export declare namespace DeleteFirewallRuleGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFirewallRuleGroupRequest) => any;
+}
+export interface DeleteFirewallRuleGroupResponse {
+    
+    FirewallRuleGroup?: FirewallRuleGroup;
+}
+export declare namespace DeleteFirewallRuleGroupResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFirewallRuleGroupResponse) => any;
+}
+export interface DeleteResolverEndpointRequest {
+    
+    ResolverEndpointId: string | undefined;
+}
+export declare namespace DeleteResolverEndpointRequest {
+    
+    const filterSensitiveLog: (obj: DeleteResolverEndpointRequest) => any;
+}
+export interface DeleteResolverEndpointResponse {
+    
+    ResolverEndpoint?: ResolverEndpoint;
+}
+export declare namespace DeleteResolverEndpointResponse {
+    
+    const filterSensitiveLog: (obj: DeleteResolverEndpointResponse) => any;
+}
+export interface DeleteResolverQueryLogConfigRequest {
+    
+    ResolverQueryLogConfigId: string | undefined;
+}
+export declare namespace DeleteResolverQueryLogConfigRequest {
+    
+    const filterSensitiveLog: (obj: DeleteResolverQueryLogConfigRequest) => any;
+}
+export interface DeleteResolverQueryLogConfigResponse {
+    
+    ResolverQueryLogConfig?: ResolverQueryLogConfig;
+}
+export declare namespace DeleteResolverQueryLogConfigResponse {
+    
+    const filterSensitiveLog: (obj: DeleteResolverQueryLogConfigResponse) => any;
+}
+export interface DeleteResolverRuleRequest {
+    
+    ResolverRuleId: string | undefined;
+}
+export declare namespace DeleteResolverRuleRequest {
+    
+    const filterSensitiveLog: (obj: DeleteResolverRuleRequest) => any;
+}
+export interface DeleteResolverRuleResponse {
+    
+    ResolverRule?: ResolverRule;
+}
+export declare namespace DeleteResolverRuleResponse {
+    
+    const filterSensitiveLog: (obj: DeleteResolverRuleResponse) => any;
+}
+
+export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
+    name: "ResourceInUseException";
+    $fault: "client";
+    Message?: string;
+    
+    ResourceType?: string;
+}
+export declare namespace ResourceInUseException {
+    
+    const filterSensitiveLog: (obj: ResourceInUseException) => any;
+}
+export interface DisassociateFirewallRuleGroupRequest {
+    
+    FirewallRuleGroupAssociationId: string | undefined;
+}
+export declare namespace DisassociateFirewallRuleGroupRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateFirewallRuleGroupRequest) => any;
+}
+export interface DisassociateFirewallRuleGroupResponse {
+    
+    FirewallRuleGroupAssociation?: FirewallRuleGroupAssociation;
+}
+export declare namespace DisassociateFirewallRuleGroupResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateFirewallRuleGroupResponse) => any;
+}
+export interface DisassociateResolverEndpointIpAddressRequest {
+    
+    ResolverEndpointId: string | undefined;
+    
+    IpAddress: IpAddressUpdate | undefined;
+}
+export declare namespace DisassociateResolverEndpointIpAddressRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateResolverEndpointIpAddressRequest) => any;
+}
+export interface DisassociateResolverEndpointIpAddressResponse {
+    
+    ResolverEndpoint?: ResolverEndpoint;
+}
+export declare namespace DisassociateResolverEndpointIpAddressResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateResolverEndpointIpAddressResponse) => any;
+}
+export interface DisassociateResolverQueryLogConfigRequest {
+    
+    ResolverQueryLogConfigId: string | undefined;
+    
+    ResourceId: string | undefined;
+}
+export declare namespace DisassociateResolverQueryLogConfigRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateResolverQueryLogConfigRequest) => any;
+}
+export interface DisassociateResolverQueryLogConfigResponse {
+    
+    ResolverQueryLogConfigAssociation?: ResolverQueryLogConfigAssociation;
+}
+export declare namespace DisassociateResolverQueryLogConfigResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateResolverQueryLogConfigResponse) => any;
+}
+export interface DisassociateResolverRuleRequest {
+    
+    VPCId: string | undefined;
+    
+    ResolverRuleId: string | undefined;
+}
+export declare namespace DisassociateResolverRuleRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateResolverRuleRequest) => any;
+}
+export interface DisassociateResolverRuleResponse {
+    
+    ResolverRuleAssociation?: ResolverRuleAssociation;
+}
+export declare namespace DisassociateResolverRuleResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateResolverRuleResponse) => any;
+}
+
+export interface Filter {
+    
+    Name?: string;
+    
+    Values?: string[];
+}
+export declare namespace Filter {
+    
+    const filterSensitiveLog: (obj: Filter) => any;
+}
+export declare enum FirewallFailOpenStatus {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface FirewallConfig {
+    
+    Id?: string;
+    
+    ResourceId?: string;
+    
+    OwnerId?: string;
+    
+    FirewallFailOpen?: FirewallFailOpenStatus | string;
+}
+export declare namespace FirewallConfig {
+    
+    const filterSensitiveLog: (obj: FirewallConfig) => any;
+}
+export declare enum FirewallDomainImportOperation {
+    REPLACE = "REPLACE"
+}
+
+export interface FirewallDomainListMetadata {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    CreatorRequestId?: string;
+    
+    ManagedOwnerName?: string;
+}
+export declare namespace FirewallDomainListMetadata {
+    
+    const filterSensitiveLog: (obj: FirewallDomainListMetadata) => any;
+}
+export declare enum FirewallDomainUpdateOperation {
+    ADD = "ADD",
+    REMOVE = "REMOVE",
+    REPLACE = "REPLACE"
+}
+
+export interface FirewallRuleGroupMetadata {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    OwnerId?: string;
+    
+    CreatorRequestId?: string;
+    
+    ShareStatus?: ShareStatus | string;
+}
+export declare namespace FirewallRuleGroupMetadata {
+    
+    const filterSensitiveLog: (obj: FirewallRuleGroupMetadata) => any;
+}
+export interface GetFirewallConfigRequest {
+    
+    ResourceId: string | undefined;
+}
+export declare namespace GetFirewallConfigRequest {
+    
+    const filterSensitiveLog: (obj: GetFirewallConfigRequest) => any;
+}
+export interface GetFirewallConfigResponse {
+    
+    FirewallConfig?: FirewallConfig;
+}
+export declare namespace GetFirewallConfigResponse {
+    
+    const filterSensitiveLog: (obj: GetFirewallConfigResponse) => any;
+}
+export interface GetFirewallDomainListRequest {
+    
+    FirewallDomainListId: string | undefined;
+}
+export declare namespace GetFirewallDomainListRequest {
+    
+    const filterSensitiveLog: (obj: GetFirewallDomainListRequest) => any;
+}
+export interface GetFirewallDomainListResponse {
+    
+    FirewallDomainList?: FirewallDomainList;
+}
+export declare namespace GetFirewallDomainListResponse {
+    
+    const filterSensitiveLog: (obj: GetFirewallDomainListResponse) => any;
+}
+export interface GetFirewallRuleGroupRequest {
+    
+    FirewallRuleGroupId: string | undefined;
+}
+export declare namespace GetFirewallRuleGroupRequest {
+    
+    const filterSensitiveLog: (obj: GetFirewallRuleGroupRequest) => any;
+}
+export interface GetFirewallRuleGroupResponse {
+    
+    FirewallRuleGroup?: FirewallRuleGroup;
+}
+export declare namespace GetFirewallRuleGroupResponse {
+    
+    const filterSensitiveLog: (obj: GetFirewallRuleGroupResponse) => any;
+}
+export interface GetFirewallRuleGroupAssociationRequest {
+    
+    FirewallRuleGroupAssociationId: string | undefined;
+}
+export declare namespace GetFirewallRuleGroupAssociationRequest {
+    
+    const filterSensitiveLog: (obj: GetFirewallRuleGroupAssociationRequest) => any;
+}
+export interface GetFirewallRuleGroupAssociationResponse {
+    
+    FirewallRuleGroupAssociation?: FirewallRuleGroupAssociation;
+}
+export declare namespace GetFirewallRuleGroupAssociationResponse {
+    
+    const filterSensitiveLog: (obj: GetFirewallRuleGroupAssociationResponse) => any;
+}
+export interface GetFirewallRuleGroupPolicyRequest {
+    
+    Arn: string | undefined;
+}
+export declare namespace GetFirewallRuleGroupPolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetFirewallRuleGroupPolicyRequest) => any;
+}
+export interface GetFirewallRuleGroupPolicyResponse {
+    
+    FirewallRuleGroupPolicy?: string;
+}
+export declare namespace GetFirewallRuleGroupPolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetFirewallRuleGroupPolicyResponse) => any;
+}
+export interface GetResolverDnssecConfigRequest {
+    
+    ResourceId: string | undefined;
+}
+export declare namespace GetResolverDnssecConfigRequest {
+    
+    const filterSensitiveLog: (obj: GetResolverDnssecConfigRequest) => any;
+}
+export declare enum ResolverDNSSECValidationStatus {
+    Disabled = "DISABLED",
+    Disabling = "DISABLING",
+    Enabled = "ENABLED",
+    Enabling = "ENABLING"
+}
+
+export interface ResolverDnssecConfig {
+    
+    Id?: string;
+    
+    OwnerId?: string;
+    
+    ResourceId?: string;
+    
+    ValidationStatus?: ResolverDNSSECValidationStatus | string;
+}
+export declare namespace ResolverDnssecConfig {
+    
+    const filterSensitiveLog: (obj: ResolverDnssecConfig) => any;
+}
+export interface GetResolverDnssecConfigResponse {
+    
+    ResolverDNSSECConfig?: ResolverDnssecConfig;
+}
+export declare namespace GetResolverDnssecConfigResponse {
+    
+    const filterSensitiveLog: (obj: GetResolverDnssecConfigResponse) => any;
+}
+export interface GetResolverEndpointRequest {
+    
+    ResolverEndpointId: string | undefined;
+}
+export declare namespace GetResolverEndpointRequest {
+    
+    const filterSensitiveLog: (obj: GetResolverEndpointRequest) => any;
+}
+export interface GetResolverEndpointResponse {
+    
+    ResolverEndpoint?: ResolverEndpoint;
+}
+export declare namespace GetResolverEndpointResponse {
+    
+    const filterSensitiveLog: (obj: GetResolverEndpointResponse) => any;
+}
+export interface GetResolverQueryLogConfigRequest {
+    
+    ResolverQueryLogConfigId: string | undefined;
+}
+export declare namespace GetResolverQueryLogConfigRequest {
+    
+    const filterSensitiveLog: (obj: GetResolverQueryLogConfigRequest) => any;
+}
+export interface GetResolverQueryLogConfigResponse {
+    
+    ResolverQueryLogConfig?: ResolverQueryLogConfig;
+}
+export declare namespace GetResolverQueryLogConfigResponse {
+    
+    const filterSensitiveLog: (obj: GetResolverQueryLogConfigResponse) => any;
+}
+export interface GetResolverQueryLogConfigAssociationRequest {
+    
+    ResolverQueryLogConfigAssociationId: string | undefined;
+}
+export declare namespace GetResolverQueryLogConfigAssociationRequest {
+    
+    const filterSensitiveLog: (obj: GetResolverQueryLogConfigAssociationRequest) => any;
+}
+export interface GetResolverQueryLogConfigAssociationResponse {
+    
+    ResolverQueryLogConfigAssociation?: ResolverQueryLogConfigAssociation;
+}
+export declare namespace GetResolverQueryLogConfigAssociationResponse {
+    
+    const filterSensitiveLog: (obj: GetResolverQueryLogConfigAssociationResponse) => any;
+}
+export interface GetResolverQueryLogConfigPolicyRequest {
+    
+    Arn: string | undefined;
+}
+export declare namespace GetResolverQueryLogConfigPolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetResolverQueryLogConfigPolicyRequest) => any;
+}
+export interface GetResolverQueryLogConfigPolicyResponse {
+    
+    ResolverQueryLogConfigPolicy?: string;
+}
+export declare namespace GetResolverQueryLogConfigPolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetResolverQueryLogConfigPolicyResponse) => any;
+}
+
+export interface UnknownResourceException extends __SmithyException, $MetadataBearer {
+    name: "UnknownResourceException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace UnknownResourceException {
+    
+    const filterSensitiveLog: (obj: UnknownResourceException) => any;
+}
+export interface GetResolverRuleRequest {
+    
+    ResolverRuleId: string | undefined;
+}
+export declare namespace GetResolverRuleRequest {
+    
+    const filterSensitiveLog: (obj: GetResolverRuleRequest) => any;
+}
+export interface GetResolverRuleResponse {
+    
+    ResolverRule?: ResolverRule;
+}
+export declare namespace GetResolverRuleResponse {
+    
+    const filterSensitiveLog: (obj: GetResolverRuleResponse) => any;
+}
+export interface GetResolverRuleAssociationRequest {
+    
+    ResolverRuleAssociationId: string | undefined;
+}
+export declare namespace GetResolverRuleAssociationRequest {
+    
+    const filterSensitiveLog: (obj: GetResolverRuleAssociationRequest) => any;
+}
+export interface GetResolverRuleAssociationResponse {
+    
+    ResolverRuleAssociation?: ResolverRuleAssociation;
+}
+export declare namespace GetResolverRuleAssociationResponse {
+    
+    const filterSensitiveLog: (obj: GetResolverRuleAssociationResponse) => any;
+}
+export interface GetResolverRulePolicyRequest {
+    
+    Arn: string | undefined;
+}
+export declare namespace GetResolverRulePolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetResolverRulePolicyRequest) => any;
+}
+export interface GetResolverRulePolicyResponse {
+    
+    ResolverRulePolicy?: string;
+}
+export declare namespace GetResolverRulePolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetResolverRulePolicyResponse) => any;
+}
+export interface ImportFirewallDomainsRequest {
+    
+    FirewallDomainListId: string | undefined;
+    
+    Operation: FirewallDomainImportOperation | string | undefined;
+    
+    DomainFileUrl: string | undefined;
+}
+export declare namespace ImportFirewallDomainsRequest {
+    
+    const filterSensitiveLog: (obj: ImportFirewallDomainsRequest) => any;
+}
+export interface ImportFirewallDomainsResponse {
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Status?: FirewallDomainListStatus | string;
+    
+    StatusMessage?: string;
+}
+export declare namespace ImportFirewallDomainsResponse {
+    
+    const filterSensitiveLog: (obj: ImportFirewallDomainsResponse) => any;
+}
+
+export interface InvalidNextTokenException extends __SmithyException, $MetadataBearer {
+    name: "InvalidNextTokenException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidNextTokenException {
+    
+    const filterSensitiveLog: (obj: InvalidNextTokenException) => any;
+}
+
+export interface InvalidPolicyDocument extends __SmithyException, $MetadataBearer {
+    name: "InvalidPolicyDocument";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidPolicyDocument {
+    
+    const filterSensitiveLog: (obj: InvalidPolicyDocument) => any;
+}
+
+export interface InvalidTagException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTagException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidTagException {
+    
+    const filterSensitiveLog: (obj: InvalidTagException) => any;
+}
+export declare enum IpAddressStatus {
+    Attached = "ATTACHED",
+    Attaching = "ATTACHING",
+    Creating = "CREATING",
+    DeleteFailedFasExpired = "DELETE_FAILED_FAS_EXPIRED",
+    Deleting = "DELETING",
+    Detaching = "DETACHING",
+    FailedCreation = "FAILED_CREATION",
+    FailedResourceGone = "FAILED_RESOURCE_GONE",
+    RemapAttaching = "REMAP_ATTACHING",
+    RemapDetaching = "REMAP_DETACHING"
+}
+
+export interface IpAddressResponse {
+    
+    IpId?: string;
+    
+    SubnetId?: string;
+    
+    Ip?: string;
+    
+    Status?: IpAddressStatus | string;
+    
+    StatusMessage?: string;
+    
+    CreationTime?: string;
+    
+    ModificationTime?: string;
+}
+export declare namespace IpAddressResponse {
+    
+    const filterSensitiveLog: (obj: IpAddressResponse) => any;
+}
+export interface ListFirewallConfigsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListFirewallConfigsRequest {
+    
+    const filterSensitiveLog: (obj: ListFirewallConfigsRequest) => any;
+}
+export interface ListFirewallConfigsResponse {
+    
+    NextToken?: string;
+    
+    FirewallConfigs?: FirewallConfig[];
+}
+export declare namespace ListFirewallConfigsResponse {
+    
+    const filterSensitiveLog: (obj: ListFirewallConfigsResponse) => any;
+}
+export interface ListFirewallDomainListsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListFirewallDomainListsRequest {
+    
+    const filterSensitiveLog: (obj: ListFirewallDomainListsRequest) => any;
+}
+export interface ListFirewallDomainListsResponse {
+    
+    NextToken?: string;
+    
+    FirewallDomainLists?: FirewallDomainListMetadata[];
+}
+export declare namespace ListFirewallDomainListsResponse {
+    
+    const filterSensitiveLog: (obj: ListFirewallDomainListsResponse) => any;
+}
+export interface ListFirewallDomainsRequest {
+    
+    FirewallDomainListId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListFirewallDomainsRequest {
+    
+    const filterSensitiveLog: (obj: ListFirewallDomainsRequest) => any;
+}
+export interface ListFirewallDomainsResponse {
+    
+    NextToken?: string;
+    
+    Domains?: string[];
+}
+export declare namespace ListFirewallDomainsResponse {
+    
+    const filterSensitiveLog: (obj: ListFirewallDomainsResponse) => any;
+}
+export interface ListFirewallRuleGroupAssociationsRequest {
+    
+    FirewallRuleGroupId?: string;
+    
+    VpcId?: string;
+    
+    Priority?: number;
+    
+    Status?: FirewallRuleGroupAssociationStatus | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListFirewallRuleGroupAssociationsRequest {
+    
+    const filterSensitiveLog: (obj: ListFirewallRuleGroupAssociationsRequest) => any;
+}
+export interface ListFirewallRuleGroupAssociationsResponse {
+    
+    NextToken?: string;
+    
+    FirewallRuleGroupAssociations?: FirewallRuleGroupAssociation[];
+}
+export declare namespace ListFirewallRuleGroupAssociationsResponse {
+    
+    const filterSensitiveLog: (obj: ListFirewallRuleGroupAssociationsResponse) => any;
+}
+export interface ListFirewallRuleGroupsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListFirewallRuleGroupsRequest {
+    
+    const filterSensitiveLog: (obj: ListFirewallRuleGroupsRequest) => any;
+}
+export interface ListFirewallRuleGroupsResponse {
+    
+    NextToken?: string;
+    
+    FirewallRuleGroups?: FirewallRuleGroupMetadata[];
+}
+export declare namespace ListFirewallRuleGroupsResponse {
+    
+    const filterSensitiveLog: (obj: ListFirewallRuleGroupsResponse) => any;
+}
+export interface ListFirewallRulesRequest {
+    
+    FirewallRuleGroupId: string | undefined;
+    
+    Priority?: number;
+    
+    Action?: Action | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListFirewallRulesRequest {
+    
+    const filterSensitiveLog: (obj: ListFirewallRulesRequest) => any;
+}
+export interface ListFirewallRulesResponse {
+    
+    NextToken?: string;
+    
+    FirewallRules?: FirewallRule[];
+}
+export declare namespace ListFirewallRulesResponse {
+    
+    const filterSensitiveLog: (obj: ListFirewallRulesResponse) => any;
+}
+export interface ListResolverDnssecConfigsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    Filters?: Filter[];
+}
+export declare namespace ListResolverDnssecConfigsRequest {
+    
+    const filterSensitiveLog: (obj: ListResolverDnssecConfigsRequest) => any;
+}
+export interface ListResolverDnssecConfigsResponse {
+    
+    NextToken?: string;
+    
+    ResolverDnssecConfigs?: ResolverDnssecConfig[];
+}
+export declare namespace ListResolverDnssecConfigsResponse {
+    
+    const filterSensitiveLog: (obj: ListResolverDnssecConfigsResponse) => any;
+}
+export interface ListResolverEndpointIpAddressesRequest {
+    
+    ResolverEndpointId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListResolverEndpointIpAddressesRequest {
+    
+    const filterSensitiveLog: (obj: ListResolverEndpointIpAddressesRequest) => any;
+}
+export interface ListResolverEndpointIpAddressesResponse {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    IpAddresses?: IpAddressResponse[];
+}
+export declare namespace ListResolverEndpointIpAddressesResponse {
+    
+    const filterSensitiveLog: (obj: ListResolverEndpointIpAddressesResponse) => any;
+}
+export interface ListResolverEndpointsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    Filters?: Filter[];
+}
+export declare namespace ListResolverEndpointsRequest {
+    
+    const filterSensitiveLog: (obj: ListResolverEndpointsRequest) => any;
+}
+export interface ListResolverEndpointsResponse {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ResolverEndpoints?: ResolverEndpoint[];
+}
+export declare namespace ListResolverEndpointsResponse {
+    
+    const filterSensitiveLog: (obj: ListResolverEndpointsResponse) => any;
+}
+export declare enum SortOrder {
+    Ascending = "ASCENDING",
+    Descending = "DESCENDING"
+}
+export interface ListResolverQueryLogConfigAssociationsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    Filters?: Filter[];
+    
+    SortBy?: string;
+    
+    SortOrder?: SortOrder | string;
+}
+export declare namespace ListResolverQueryLogConfigAssociationsRequest {
+    
+    const filterSensitiveLog: (obj: ListResolverQueryLogConfigAssociationsRequest) => any;
+}
+export interface ListResolverQueryLogConfigAssociationsResponse {
+    
+    NextToken?: string;
+    
+    TotalCount?: number;
+    
+    TotalFilteredCount?: number;
+    
+    ResolverQueryLogConfigAssociations?: ResolverQueryLogConfigAssociation[];
+}
+export declare namespace ListResolverQueryLogConfigAssociationsResponse {
+    
+    const filterSensitiveLog: (obj: ListResolverQueryLogConfigAssociationsResponse) => any;
+}
+export interface ListResolverQueryLogConfigsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    Filters?: Filter[];
+    
+    SortBy?: string;
+    
+    SortOrder?: SortOrder | string;
+}
+export declare namespace ListResolverQueryLogConfigsRequest {
+    
+    const filterSensitiveLog: (obj: ListResolverQueryLogConfigsRequest) => any;
+}
+export interface ListResolverQueryLogConfigsResponse {
+    
+    NextToken?: string;
+    
+    TotalCount?: number;
+    
+    TotalFilteredCount?: number;
+    
+    ResolverQueryLogConfigs?: ResolverQueryLogConfig[];
+}
+export declare namespace ListResolverQueryLogConfigsResponse {
+    
+    const filterSensitiveLog: (obj: ListResolverQueryLogConfigsResponse) => any;
+}
+export interface ListResolverRuleAssociationsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    Filters?: Filter[];
+}
+export declare namespace ListResolverRuleAssociationsRequest {
+    
+    const filterSensitiveLog: (obj: ListResolverRuleAssociationsRequest) => any;
+}
+export interface ListResolverRuleAssociationsResponse {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ResolverRuleAssociations?: ResolverRuleAssociation[];
+}
+export declare namespace ListResolverRuleAssociationsResponse {
+    
+    const filterSensitiveLog: (obj: ListResolverRuleAssociationsResponse) => any;
+}
+export interface ListResolverRulesRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    Filters?: Filter[];
+}
+export declare namespace ListResolverRulesRequest {
+    
+    const filterSensitiveLog: (obj: ListResolverRulesRequest) => any;
+}
+export interface ListResolverRulesResponse {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ResolverRules?: ResolverRule[];
+}
+export declare namespace ListResolverRulesResponse {
+    
+    const filterSensitiveLog: (obj: ListResolverRulesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface PutFirewallRuleGroupPolicyRequest {
+    
+    Arn: string | undefined;
+    
+    FirewallRuleGroupPolicy: string | undefined;
+}
+export declare namespace PutFirewallRuleGroupPolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutFirewallRuleGroupPolicyRequest) => any;
+}
+export interface PutFirewallRuleGroupPolicyResponse {
+    
+    ReturnValue?: boolean;
+}
+export declare namespace PutFirewallRuleGroupPolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutFirewallRuleGroupPolicyResponse) => any;
+}
+export interface PutResolverQueryLogConfigPolicyRequest {
+    
+    Arn: string | undefined;
+    
+    ResolverQueryLogConfigPolicy: string | undefined;
+}
+export declare namespace PutResolverQueryLogConfigPolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutResolverQueryLogConfigPolicyRequest) => any;
+}
+
+export interface PutResolverQueryLogConfigPolicyResponse {
+    
+    ReturnValue?: boolean;
+}
+export declare namespace PutResolverQueryLogConfigPolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutResolverQueryLogConfigPolicyResponse) => any;
+}
+export interface PutResolverRulePolicyRequest {
+    
+    Arn: string | undefined;
+    
+    ResolverRulePolicy: string | undefined;
+}
+export declare namespace PutResolverRulePolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutResolverRulePolicyRequest) => any;
+}
+
+export interface PutResolverRulePolicyResponse {
+    
+    ReturnValue?: boolean;
+}
+export declare namespace PutResolverRulePolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutResolverRulePolicyResponse) => any;
+}
+
+export interface ResolverRuleConfig {
+    
+    Name?: string;
+    
+    TargetIps?: TargetAddress[];
+    
+    ResolverEndpointId?: string;
+}
+export declare namespace ResolverRuleConfig {
+    
+    const filterSensitiveLog: (obj: ResolverRuleConfig) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateFirewallConfigRequest {
+    
+    ResourceId: string | undefined;
+    
+    FirewallFailOpen: FirewallFailOpenStatus | string | undefined;
+}
+export declare namespace UpdateFirewallConfigRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFirewallConfigRequest) => any;
+}
+export interface UpdateFirewallConfigResponse {
+    
+    FirewallConfig?: FirewallConfig;
+}
+export declare namespace UpdateFirewallConfigResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFirewallConfigResponse) => any;
+}
+export interface UpdateFirewallDomainsRequest {
+    
+    FirewallDomainListId: string | undefined;
+    
+    Operation: FirewallDomainUpdateOperation | string | undefined;
+    
+    Domains: string[] | undefined;
+}
+export declare namespace UpdateFirewallDomainsRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFirewallDomainsRequest) => any;
+}
+export interface UpdateFirewallDomainsResponse {
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Status?: FirewallDomainListStatus | string;
+    
+    StatusMessage?: string;
+}
+export declare namespace UpdateFirewallDomainsResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFirewallDomainsResponse) => any;
+}
+export interface UpdateFirewallRuleRequest {
+    
+    FirewallRuleGroupId: string | undefined;
+    
+    FirewallDomainListId: string | undefined;
+    
+    Priority?: number;
+    
+    Action?: Action | string;
+    
+    BlockResponse?: BlockResponse | string;
+    
+    BlockOverrideDomain?: string;
+    
+    BlockOverrideDnsType?: BlockOverrideDnsType | string;
+    
+    BlockOverrideTtl?: number;
+    
+    Name?: string;
+}
+export declare namespace UpdateFirewallRuleRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFirewallRuleRequest) => any;
+}
+export interface UpdateFirewallRuleResponse {
+    
+    FirewallRule?: FirewallRule;
+}
+export declare namespace UpdateFirewallRuleResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFirewallRuleResponse) => any;
+}
+export interface UpdateFirewallRuleGroupAssociationRequest {
+    
+    FirewallRuleGroupAssociationId: string | undefined;
+    
+    Priority?: number;
+    
+    MutationProtection?: MutationProtectionStatus | string;
+    
+    Name?: string;
+}
+export declare namespace UpdateFirewallRuleGroupAssociationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFirewallRuleGroupAssociationRequest) => any;
+}
+export interface UpdateFirewallRuleGroupAssociationResponse {
+    
+    FirewallRuleGroupAssociation?: FirewallRuleGroupAssociation;
+}
+export declare namespace UpdateFirewallRuleGroupAssociationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFirewallRuleGroupAssociationResponse) => any;
+}
+export declare enum Validation {
+    DISABLE = "DISABLE",
+    ENABLE = "ENABLE"
+}
+export interface UpdateResolverDnssecConfigRequest {
+    
+    ResourceId: string | undefined;
+    
+    Validation: Validation | string | undefined;
+}
+export declare namespace UpdateResolverDnssecConfigRequest {
+    
+    const filterSensitiveLog: (obj: UpdateResolverDnssecConfigRequest) => any;
+}
+export interface UpdateResolverDnssecConfigResponse {
+    
+    ResolverDNSSECConfig?: ResolverDnssecConfig;
+}
+export declare namespace UpdateResolverDnssecConfigResponse {
+    
+    const filterSensitiveLog: (obj: UpdateResolverDnssecConfigResponse) => any;
+}
+export interface UpdateResolverEndpointRequest {
+    
+    ResolverEndpointId: string | undefined;
+    
+    Name?: string;
+}
+export declare namespace UpdateResolverEndpointRequest {
+    
+    const filterSensitiveLog: (obj: UpdateResolverEndpointRequest) => any;
+}
+export interface UpdateResolverEndpointResponse {
+    
+    ResolverEndpoint?: ResolverEndpoint;
+}
+export declare namespace UpdateResolverEndpointResponse {
+    
+    const filterSensitiveLog: (obj: UpdateResolverEndpointResponse) => any;
+}
+export interface UpdateResolverRuleRequest {
+    
+    ResolverRuleId: string | undefined;
+    
+    Config: ResolverRuleConfig | undefined;
+}
+export declare namespace UpdateResolverRuleRequest {
+    
+    const filterSensitiveLog: (obj: UpdateResolverRuleRequest) => any;
+}
+export interface UpdateResolverRuleResponse {
+    
+    ResolverRule?: ResolverRule;
+}
+export declare namespace UpdateResolverRuleResponse {
+    
+    const filterSensitiveLog: (obj: UpdateResolverRuleResponse) => any;
+}