@aws-sdk/client-mailmanager 3.581.0

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

@@ -0,0 +1,1514 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { MailManagerServiceException as __BaseException } from "./MailManagerServiceException";
+export declare const AcceptAction: {
+  readonly ALLOW: "ALLOW";
+  readonly DENY: "DENY";
+};
+export type AcceptAction = (typeof AcceptAction)[keyof typeof AcceptAction];
+export declare class AccessDeniedException extends __BaseException {
+  readonly name: "AccessDeniedException";
+  readonly $fault: "client";
+  Message?: string;
+  constructor(
+    opts: __ExceptionOptionType<AccessDeniedException, __BaseException>
+  );
+}
+export declare const ActionFailurePolicy: {
+  readonly CONTINUE: "CONTINUE";
+  readonly DROP: "DROP";
+};
+export type ActionFailurePolicy =
+  (typeof ActionFailurePolicy)[keyof typeof ActionFailurePolicy];
+export interface AddHeaderAction {
+  HeaderName: string | undefined;
+  HeaderValue: string | undefined;
+}
+export interface AddonInstance {
+  AddonInstanceId?: string;
+  AddonSubscriptionId?: string;
+  AddonName?: string;
+  AddonInstanceArn?: string;
+  CreatedTimestamp?: Date;
+}
+export declare class ConflictException extends __BaseException {
+  readonly name: "ConflictException";
+  readonly $fault: "client";
+  Message?: string;
+  constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+export interface Tag {
+  Key: string | undefined;
+  Value: string | undefined;
+}
+export interface CreateAddonInstanceRequest {
+  ClientToken?: string;
+  AddonSubscriptionId: string | undefined;
+  Tags?: Tag[];
+}
+export interface CreateAddonInstanceResponse {
+  AddonInstanceId: string | undefined;
+}
+export declare class ResourceNotFoundException extends __BaseException {
+  readonly name: "ResourceNotFoundException";
+  readonly $fault: "client";
+  Message?: string;
+  constructor(
+    opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>
+  );
+}
+export declare class ServiceQuotaExceededException extends __BaseException {
+  readonly name: "ServiceQuotaExceededException";
+  readonly $fault: "client";
+  Message?: string;
+  constructor(
+    opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>
+  );
+}
+export declare class ValidationException extends __BaseException {
+  readonly name: "ValidationException";
+  readonly $fault: "client";
+  Message?: string;
+  constructor(
+    opts: __ExceptionOptionType<ValidationException, __BaseException>
+  );
+}
+export interface DeleteAddonInstanceRequest {
+  AddonInstanceId: string | undefined;
+}
+export interface DeleteAddonInstanceResponse {}
+export interface GetAddonInstanceRequest {
+  AddonInstanceId: string | undefined;
+}
+export interface GetAddonInstanceResponse {
+  AddonSubscriptionId?: string;
+  AddonName?: string;
+  AddonInstanceArn?: string;
+  CreatedTimestamp?: Date;
+}
+export interface ListAddonInstancesRequest {
+  NextToken?: string;
+  PageSize?: number;
+}
+export interface ListAddonInstancesResponse {
+  AddonInstances?: AddonInstance[];
+  NextToken?: string;
+}
+export interface AddonSubscription {
+  AddonSubscriptionId?: string;
+  AddonName?: string;
+  AddonSubscriptionArn?: string;
+  CreatedTimestamp?: Date;
+}
+export interface CreateAddonSubscriptionRequest {
+  ClientToken?: string;
+  AddonName: string | undefined;
+  Tags?: Tag[];
+}
+export interface CreateAddonSubscriptionResponse {
+  AddonSubscriptionId: string | undefined;
+}
+export interface DeleteAddonSubscriptionRequest {
+  AddonSubscriptionId: string | undefined;
+}
+export interface DeleteAddonSubscriptionResponse {}
+export interface GetAddonSubscriptionRequest {
+  AddonSubscriptionId: string | undefined;
+}
+export interface GetAddonSubscriptionResponse {
+  AddonName?: string;
+  AddonSubscriptionArn?: string;
+  CreatedTimestamp?: Date;
+}
+export interface ListAddonSubscriptionsRequest {
+  NextToken?: string;
+  PageSize?: number;
+}
+export interface ListAddonSubscriptionsResponse {
+  AddonSubscriptions?: AddonSubscription[];
+  NextToken?: string;
+}
+export interface Analysis {
+  Analyzer: string | undefined;
+  ResultField: string | undefined;
+}
+export declare const ArchiveState: {
+  readonly ACTIVE: "ACTIVE";
+  readonly PENDING_DELETION: "PENDING_DELETION";
+};
+export type ArchiveState = (typeof ArchiveState)[keyof typeof ArchiveState];
+export interface Archive {
+  ArchiveId: string | undefined;
+  ArchiveName?: string;
+  ArchiveState?: ArchiveState;
+  LastUpdatedTimestamp?: Date;
+}
+export interface ArchiveAction {
+  ActionFailurePolicy?: ActionFailurePolicy;
+  TargetArchive: string | undefined;
+}
+export declare const ArchiveBooleanEmailAttribute: {
+  readonly HAS_ATTACHMENTS: "HAS_ATTACHMENTS";
+};
+export type ArchiveBooleanEmailAttribute =
+  (typeof ArchiveBooleanEmailAttribute)[keyof typeof ArchiveBooleanEmailAttribute];
+export type ArchiveBooleanToEvaluate =
+  | ArchiveBooleanToEvaluate.AttributeMember
+  | ArchiveBooleanToEvaluate.$UnknownMember;
+export declare namespace ArchiveBooleanToEvaluate {
+  interface AttributeMember {
+    Attribute: ArchiveBooleanEmailAttribute;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    Attribute?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    Attribute: (value: ArchiveBooleanEmailAttribute) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ArchiveBooleanToEvaluate, visitor: Visitor<T>) => T;
+}
+export declare const ArchiveBooleanOperator: {
+  readonly IS_FALSE: "IS_FALSE";
+  readonly IS_TRUE: "IS_TRUE";
+};
+export type ArchiveBooleanOperator =
+  (typeof ArchiveBooleanOperator)[keyof typeof ArchiveBooleanOperator];
+export interface ArchiveBooleanExpression {
+  Evaluate: ArchiveBooleanToEvaluate | undefined;
+  Operator: ArchiveBooleanOperator | undefined;
+}
+export declare const ArchiveStringEmailAttribute: {
+  readonly CC: "CC";
+  readonly FROM: "FROM";
+  readonly SUBJECT: "SUBJECT";
+  readonly TO: "TO";
+};
+export type ArchiveStringEmailAttribute =
+  (typeof ArchiveStringEmailAttribute)[keyof typeof ArchiveStringEmailAttribute];
+export type ArchiveStringToEvaluate =
+  | ArchiveStringToEvaluate.AttributeMember
+  | ArchiveStringToEvaluate.$UnknownMember;
+export declare namespace ArchiveStringToEvaluate {
+  interface AttributeMember {
+    Attribute: ArchiveStringEmailAttribute;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    Attribute?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    Attribute: (value: ArchiveStringEmailAttribute) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ArchiveStringToEvaluate, visitor: Visitor<T>) => T;
+}
+export declare const ArchiveStringOperator: {
+  readonly CONTAINS: "CONTAINS";
+};
+export type ArchiveStringOperator =
+  (typeof ArchiveStringOperator)[keyof typeof ArchiveStringOperator];
+export interface ArchiveStringExpression {
+  Evaluate: ArchiveStringToEvaluate | undefined;
+  Operator: ArchiveStringOperator | undefined;
+  Values: string[] | undefined;
+}
+export type ArchiveFilterCondition =
+  | ArchiveFilterCondition.BooleanExpressionMember
+  | ArchiveFilterCondition.StringExpressionMember
+  | ArchiveFilterCondition.$UnknownMember;
+export declare namespace ArchiveFilterCondition {
+  interface StringExpressionMember {
+    StringExpression: ArchiveStringExpression;
+    BooleanExpression?: never;
+    $unknown?: never;
+  }
+  interface BooleanExpressionMember {
+    StringExpression?: never;
+    BooleanExpression: ArchiveBooleanExpression;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    StringExpression?: never;
+    BooleanExpression?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    StringExpression: (value: ArchiveStringExpression) => T;
+    BooleanExpression: (value: ArchiveBooleanExpression) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ArchiveFilterCondition, visitor: Visitor<T>) => T;
+}
+export interface ArchiveFilters {
+  Include?: ArchiveFilterCondition[];
+  Unless?: ArchiveFilterCondition[];
+}
+export declare const RetentionPeriod: {
+  readonly EIGHTEEN_MONTHS: "EIGHTEEN_MONTHS";
+  readonly EIGHT_YEARS: "EIGHT_YEARS";
+  readonly FIVE_YEARS: "FIVE_YEARS";
+  readonly FOUR_YEARS: "FOUR_YEARS";
+  readonly NINE_MONTHS: "NINE_MONTHS";
+  readonly NINE_YEARS: "NINE_YEARS";
+  readonly ONE_YEAR: "ONE_YEAR";
+  readonly PERMANENT: "PERMANENT";
+  readonly SEVEN_YEARS: "SEVEN_YEARS";
+  readonly SIX_MONTHS: "SIX_MONTHS";
+  readonly SIX_YEARS: "SIX_YEARS";
+  readonly TEN_YEARS: "TEN_YEARS";
+  readonly THIRTY_MONTHS: "THIRTY_MONTHS";
+  readonly THREE_MONTHS: "THREE_MONTHS";
+  readonly THREE_YEARS: "THREE_YEARS";
+  readonly TWO_YEARS: "TWO_YEARS";
+};
+export type RetentionPeriod =
+  (typeof RetentionPeriod)[keyof typeof RetentionPeriod];
+export type ArchiveRetention =
+  | ArchiveRetention.RetentionPeriodMember
+  | ArchiveRetention.$UnknownMember;
+export declare namespace ArchiveRetention {
+  interface RetentionPeriodMember {
+    RetentionPeriod: RetentionPeriod;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    RetentionPeriod?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    RetentionPeriod: (value: RetentionPeriod) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: ArchiveRetention, visitor: Visitor<T>) => T;
+}
+export interface CreateArchiveRequest {
+  ClientToken?: string;
+  ArchiveName: string | undefined;
+  Retention?: ArchiveRetention;
+  KmsKeyArn?: string;
+  Tags?: Tag[];
+}
+export interface CreateArchiveResponse {
+  ArchiveId: string | undefined;
+}
+export declare class ThrottlingException extends __BaseException {
+  readonly name: "ThrottlingException";
+  readonly $fault: "client";
+  Message?: string;
+  constructor(
+    opts: __ExceptionOptionType<ThrottlingException, __BaseException>
+  );
+}
+export interface DeleteArchiveRequest {
+  ArchiveId: string | undefined;
+}
+export interface DeleteArchiveResponse {}
+export interface GetArchiveRequest {
+  ArchiveId: string | undefined;
+}
+export interface GetArchiveResponse {
+  ArchiveId: string | undefined;
+  ArchiveName: string | undefined;
+  ArchiveArn: string | undefined;
+  ArchiveState: ArchiveState | undefined;
+  Retention: ArchiveRetention | undefined;
+  CreatedTimestamp?: Date;
+  LastUpdatedTimestamp?: Date;
+  KmsKeyArn?: string;
+}
+export interface ListArchivesRequest {
+  NextToken?: string;
+  PageSize?: number;
+}
+export interface ListArchivesResponse {
+  Archives: Archive[] | undefined;
+  NextToken?: string;
+}
+export interface UpdateArchiveRequest {
+  ArchiveId: string | undefined;
+  ArchiveName?: string;
+  Retention?: ArchiveRetention;
+}
+export interface UpdateArchiveResponse {}
+export type IngressPointConfiguration =
+  | IngressPointConfiguration.SecretArnMember
+  | IngressPointConfiguration.SmtpPasswordMember
+  | IngressPointConfiguration.$UnknownMember;
+export declare namespace IngressPointConfiguration {
+  interface SmtpPasswordMember {
+    SmtpPassword: string;
+    SecretArn?: never;
+    $unknown?: never;
+  }
+  interface SecretArnMember {
+    SmtpPassword?: never;
+    SecretArn: string;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    SmtpPassword?: never;
+    SecretArn?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    SmtpPassword: (value: string) => T;
+    SecretArn: (value: string) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: IngressPointConfiguration, visitor: Visitor<T>) => T;
+}
+export declare const IngressPointType: {
+  readonly AUTH: "AUTH";
+  readonly OPEN: "OPEN";
+};
+export type IngressPointType =
+  (typeof IngressPointType)[keyof typeof IngressPointType];
+export interface CreateIngressPointRequest {
+  ClientToken?: string;
+  IngressPointName: string | undefined;
+  Type: IngressPointType | undefined;
+  RuleSetId: string | undefined;
+  TrafficPolicyId: string | undefined;
+  IngressPointConfiguration?: IngressPointConfiguration;
+  Tags?: Tag[];
+}
+export interface CreateIngressPointResponse {
+  IngressPointId: string | undefined;
+}
+export interface NoAuthentication {}
+export type RelayAuthentication =
+  | RelayAuthentication.NoAuthenticationMember
+  | RelayAuthentication.SecretArnMember
+  | RelayAuthentication.$UnknownMember;
+export declare namespace RelayAuthentication {
+  interface SecretArnMember {
+    SecretArn: string;
+    NoAuthentication?: never;
+    $unknown?: never;
+  }
+  interface NoAuthenticationMember {
+    SecretArn?: never;
+    NoAuthentication: NoAuthentication;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    SecretArn?: never;
+    NoAuthentication?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    SecretArn: (value: string) => T;
+    NoAuthentication: (value: NoAuthentication) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: RelayAuthentication, visitor: Visitor<T>) => T;
+}
+export interface CreateRelayRequest {
+  ClientToken?: string;
+  RelayName: string | undefined;
+  ServerName: string | undefined;
+  ServerPort: number | undefined;
+  Authentication: RelayAuthentication | undefined;
+  Tags?: Tag[];
+}
+export interface CreateRelayResponse {
+  RelayId: string | undefined;
+}
+export interface DeliverToMailboxAction {
+  ActionFailurePolicy?: ActionFailurePolicy;
+  MailboxArn: string | undefined;
+  RoleArn: string | undefined;
+}
+export interface DropAction {}
+export declare const MailFrom: {
+  readonly PRESERVE: "PRESERVE";
+  readonly REPLACE: "REPLACE";
+};
+export type MailFrom = (typeof MailFrom)[keyof typeof MailFrom];
+export interface RelayAction {
+  ActionFailurePolicy?: ActionFailurePolicy;
+  Relay: string | undefined;
+  MailFrom?: MailFrom;
+}
+export interface ReplaceRecipientAction {
+  ReplaceWith?: string[];
+}
+export interface SendAction {
+  ActionFailurePolicy?: ActionFailurePolicy;
+  RoleArn: string | undefined;
+}
+export interface S3Action {
+  ActionFailurePolicy?: ActionFailurePolicy;
+  RoleArn: string | undefined;
+  S3Bucket: string | undefined;
+  S3Prefix?: string;
+  S3SseKmsKeyId?: string;
+}
+export type RuleAction =
+  | RuleAction.AddHeaderMember
+  | RuleAction.ArchiveMember
+  | RuleAction.DeliverToMailboxMember
+  | RuleAction.DropMember
+  | RuleAction.RelayMember
+  | RuleAction.ReplaceRecipientMember
+  | RuleAction.SendMember
+  | RuleAction.WriteToS3Member
+  | RuleAction.$UnknownMember;
+export declare namespace RuleAction {
+  interface DropMember {
+    Drop: DropAction;
+    Relay?: never;
+    Archive?: never;
+    WriteToS3?: never;
+    Send?: never;
+    AddHeader?: never;
+    ReplaceRecipient?: never;
+    DeliverToMailbox?: never;
+    $unknown?: never;
+  }
+  interface RelayMember {
+    Drop?: never;
+    Relay: RelayAction;
+    Archive?: never;
+    WriteToS3?: never;
+    Send?: never;
+    AddHeader?: never;
+    ReplaceRecipient?: never;
+    DeliverToMailbox?: never;
+    $unknown?: never;
+  }
+  interface ArchiveMember {
+    Drop?: never;
+    Relay?: never;
+    Archive: ArchiveAction;
+    WriteToS3?: never;
+    Send?: never;
+    AddHeader?: never;
+    ReplaceRecipient?: never;
+    DeliverToMailbox?: never;
+    $unknown?: never;
+  }
+  interface WriteToS3Member {
+    Drop?: never;
+    Relay?: never;
+    Archive?: never;
+    WriteToS3: S3Action;
+    Send?: never;
+    AddHeader?: never;
+    ReplaceRecipient?: never;
+    DeliverToMailbox?: never;
+    $unknown?: never;
+  }
+  interface SendMember {
+    Drop?: never;
+    Relay?: never;
+    Archive?: never;
+    WriteToS3?: never;
+    Send: SendAction;
+    AddHeader?: never;
+    ReplaceRecipient?: never;
+    DeliverToMailbox?: never;
+    $unknown?: never;
+  }
+  interface AddHeaderMember {
+    Drop?: never;
+    Relay?: never;
+    Archive?: never;
+    WriteToS3?: never;
+    Send?: never;
+    AddHeader: AddHeaderAction;
+    ReplaceRecipient?: never;
+    DeliverToMailbox?: never;
+    $unknown?: never;
+  }
+  interface ReplaceRecipientMember {
+    Drop?: never;
+    Relay?: never;
+    Archive?: never;
+    WriteToS3?: never;
+    Send?: never;
+    AddHeader?: never;
+    ReplaceRecipient: ReplaceRecipientAction;
+    DeliverToMailbox?: never;
+    $unknown?: never;
+  }
+  interface DeliverToMailboxMember {
+    Drop?: never;
+    Relay?: never;
+    Archive?: never;
+    WriteToS3?: never;
+    Send?: never;
+    AddHeader?: never;
+    ReplaceRecipient?: never;
+    DeliverToMailbox: DeliverToMailboxAction;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    Drop?: never;
+    Relay?: never;
+    Archive?: never;
+    WriteToS3?: never;
+    Send?: never;
+    AddHeader?: never;
+    ReplaceRecipient?: never;
+    DeliverToMailbox?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    Drop: (value: DropAction) => T;
+    Relay: (value: RelayAction) => T;
+    Archive: (value: ArchiveAction) => T;
+    WriteToS3: (value: S3Action) => T;
+    Send: (value: SendAction) => T;
+    AddHeader: (value: AddHeaderAction) => T;
+    ReplaceRecipient: (value: ReplaceRecipientAction) => T;
+    DeliverToMailbox: (value: DeliverToMailboxAction) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: RuleAction, visitor: Visitor<T>) => T;
+}
+export declare const RuleBooleanEmailAttribute: {
+  readonly READ_RECEIPT_REQUESTED: "READ_RECEIPT_REQUESTED";
+  readonly TLS: "TLS";
+  readonly TLS_WRAPPED: "TLS_WRAPPED";
+};
+export type RuleBooleanEmailAttribute =
+  (typeof RuleBooleanEmailAttribute)[keyof typeof RuleBooleanEmailAttribute];
+export type RuleBooleanToEvaluate =
+  | RuleBooleanToEvaluate.AttributeMember
+  | RuleBooleanToEvaluate.$UnknownMember;
+export declare namespace RuleBooleanToEvaluate {
+  interface AttributeMember {
+    Attribute: RuleBooleanEmailAttribute;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    Attribute?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    Attribute: (value: RuleBooleanEmailAttribute) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: RuleBooleanToEvaluate, visitor: Visitor<T>) => T;
+}
+export declare const RuleBooleanOperator: {
+  readonly IS_FALSE: "IS_FALSE";
+  readonly IS_TRUE: "IS_TRUE";
+};
+export type RuleBooleanOperator =
+  (typeof RuleBooleanOperator)[keyof typeof RuleBooleanOperator];
+export interface RuleBooleanExpression {
+  Evaluate: RuleBooleanToEvaluate | undefined;
+  Operator: RuleBooleanOperator | undefined;
+}
+export declare const RuleDmarcOperator: {
+  readonly EQUALS: "EQUALS";
+  readonly NOT_EQUALS: "NOT_EQUALS";
+};
+export type RuleDmarcOperator =
+  (typeof RuleDmarcOperator)[keyof typeof RuleDmarcOperator];
+export declare const RuleDmarcPolicy: {
+  readonly NONE: "NONE";
+  readonly QUARANTINE: "QUARANTINE";
+  readonly REJECT: "REJECT";
+};
+export type RuleDmarcPolicy =
+  (typeof RuleDmarcPolicy)[keyof typeof RuleDmarcPolicy];
+export interface RuleDmarcExpression {
+  Operator: RuleDmarcOperator | undefined;
+  Values: RuleDmarcPolicy[] | undefined;
+}
+export declare const RuleIpEmailAttribute: {
+  readonly SOURCE_IP: "SOURCE_IP";
+};
+export type RuleIpEmailAttribute =
+  (typeof RuleIpEmailAttribute)[keyof typeof RuleIpEmailAttribute];
+export type RuleIpToEvaluate =
+  | RuleIpToEvaluate.AttributeMember
+  | RuleIpToEvaluate.$UnknownMember;
+export declare namespace RuleIpToEvaluate {
+  interface AttributeMember {
+    Attribute: RuleIpEmailAttribute;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    Attribute?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    Attribute: (value: RuleIpEmailAttribute) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: RuleIpToEvaluate, visitor: Visitor<T>) => T;
+}
+export declare const RuleIpOperator: {
+  readonly CIDR_MATCHES: "CIDR_MATCHES";
+  readonly NOT_CIDR_MATCHES: "NOT_CIDR_MATCHES";
+};
+export type RuleIpOperator =
+  (typeof RuleIpOperator)[keyof typeof RuleIpOperator];
+export interface RuleIpExpression {
+  Evaluate: RuleIpToEvaluate | undefined;
+  Operator: RuleIpOperator | undefined;
+  Values: string[] | undefined;
+}
+export declare const RuleNumberEmailAttribute: {
+  readonly MESSAGE_SIZE: "MESSAGE_SIZE";
+};
+export type RuleNumberEmailAttribute =
+  (typeof RuleNumberEmailAttribute)[keyof typeof RuleNumberEmailAttribute];
+export type RuleNumberToEvaluate =
+  | RuleNumberToEvaluate.AttributeMember
+  | RuleNumberToEvaluate.$UnknownMember;
+export declare namespace RuleNumberToEvaluate {
+  interface AttributeMember {
+    Attribute: RuleNumberEmailAttribute;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    Attribute?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    Attribute: (value: RuleNumberEmailAttribute) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: RuleNumberToEvaluate, visitor: Visitor<T>) => T;
+}
+export declare const RuleNumberOperator: {
+  readonly EQUALS: "EQUALS";
+  readonly GREATER_THAN: "GREATER_THAN";
+  readonly GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+  readonly LESS_THAN: "LESS_THAN";
+  readonly LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+  readonly NOT_EQUALS: "NOT_EQUALS";
+};
+export type RuleNumberOperator =
+  (typeof RuleNumberOperator)[keyof typeof RuleNumberOperator];
+export interface RuleNumberExpression {
+  Evaluate: RuleNumberToEvaluate | undefined;
+  Operator: RuleNumberOperator | undefined;
+  Value: number | undefined;
+}
+export declare const RuleStringEmailAttribute: {
+  readonly CC: "CC";
+  readonly FROM: "FROM";
+  readonly HELO: "HELO";
+  readonly MAIL_FROM: "MAIL_FROM";
+  readonly RECIPIENT: "RECIPIENT";
+  readonly SENDER: "SENDER";
+  readonly SUBJECT: "SUBJECT";
+  readonly TO: "TO";
+};
+export type RuleStringEmailAttribute =
+  (typeof RuleStringEmailAttribute)[keyof typeof RuleStringEmailAttribute];
+export type RuleStringToEvaluate =
+  | RuleStringToEvaluate.AttributeMember
+  | RuleStringToEvaluate.$UnknownMember;
+export declare namespace RuleStringToEvaluate {
+  interface AttributeMember {
+    Attribute: RuleStringEmailAttribute;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    Attribute?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    Attribute: (value: RuleStringEmailAttribute) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: RuleStringToEvaluate, visitor: Visitor<T>) => T;
+}
+export declare const RuleStringOperator: {
+  readonly CONTAINS: "CONTAINS";
+  readonly ENDS_WITH: "ENDS_WITH";
+  readonly EQUALS: "EQUALS";
+  readonly NOT_EQUALS: "NOT_EQUALS";
+  readonly STARTS_WITH: "STARTS_WITH";
+};
+export type RuleStringOperator =
+  (typeof RuleStringOperator)[keyof typeof RuleStringOperator];
+export interface RuleStringExpression {
+  Evaluate: RuleStringToEvaluate | undefined;
+  Operator: RuleStringOperator | undefined;
+  Values: string[] | undefined;
+}
+export declare const RuleVerdictAttribute: {
+  readonly DKIM: "DKIM";
+  readonly SPF: "SPF";
+};
+export type RuleVerdictAttribute =
+  (typeof RuleVerdictAttribute)[keyof typeof RuleVerdictAttribute];
+export type RuleVerdictToEvaluate =
+  | RuleVerdictToEvaluate.AnalysisMember
+  | RuleVerdictToEvaluate.AttributeMember
+  | RuleVerdictToEvaluate.$UnknownMember;
+export declare namespace RuleVerdictToEvaluate {
+  interface AttributeMember {
+    Attribute: RuleVerdictAttribute;
+    Analysis?: never;
+    $unknown?: never;
+  }
+  interface AnalysisMember {
+    Attribute?: never;
+    Analysis: Analysis;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    Attribute?: never;
+    Analysis?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    Attribute: (value: RuleVerdictAttribute) => T;
+    Analysis: (value: Analysis) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: RuleVerdictToEvaluate, visitor: Visitor<T>) => T;
+}
+export declare const RuleVerdictOperator: {
+  readonly EQUALS: "EQUALS";
+  readonly NOT_EQUALS: "NOT_EQUALS";
+};
+export type RuleVerdictOperator =
+  (typeof RuleVerdictOperator)[keyof typeof RuleVerdictOperator];
+export declare const RuleVerdict: {
+  readonly FAIL: "FAIL";
+  readonly GRAY: "GRAY";
+  readonly PASS: "PASS";
+  readonly PROCESSING_FAILED: "PROCESSING_FAILED";
+};
+export type RuleVerdict = (typeof RuleVerdict)[keyof typeof RuleVerdict];
+export interface RuleVerdictExpression {
+  Evaluate: RuleVerdictToEvaluate | undefined;
+  Operator: RuleVerdictOperator | undefined;
+  Values: RuleVerdict[] | undefined;
+}
+export type RuleCondition =
+  | RuleCondition.BooleanExpressionMember
+  | RuleCondition.DmarcExpressionMember
+  | RuleCondition.IpExpressionMember
+  | RuleCondition.NumberExpressionMember
+  | RuleCondition.StringExpressionMember
+  | RuleCondition.VerdictExpressionMember
+  | RuleCondition.$UnknownMember;
+export declare namespace RuleCondition {
+  interface BooleanExpressionMember {
+    BooleanExpression: RuleBooleanExpression;
+    StringExpression?: never;
+    NumberExpression?: never;
+    IpExpression?: never;
+    VerdictExpression?: never;
+    DmarcExpression?: never;
+    $unknown?: never;
+  }
+  interface StringExpressionMember {
+    BooleanExpression?: never;
+    StringExpression: RuleStringExpression;
+    NumberExpression?: never;
+    IpExpression?: never;
+    VerdictExpression?: never;
+    DmarcExpression?: never;
+    $unknown?: never;
+  }
+  interface NumberExpressionMember {
+    BooleanExpression?: never;
+    StringExpression?: never;
+    NumberExpression: RuleNumberExpression;
+    IpExpression?: never;
+    VerdictExpression?: never;
+    DmarcExpression?: never;
+    $unknown?: never;
+  }
+  interface IpExpressionMember {
+    BooleanExpression?: never;
+    StringExpression?: never;
+    NumberExpression?: never;
+    IpExpression: RuleIpExpression;
+    VerdictExpression?: never;
+    DmarcExpression?: never;
+    $unknown?: never;
+  }
+  interface VerdictExpressionMember {
+    BooleanExpression?: never;
+    StringExpression?: never;
+    NumberExpression?: never;
+    IpExpression?: never;
+    VerdictExpression: RuleVerdictExpression;
+    DmarcExpression?: never;
+    $unknown?: never;
+  }
+  interface DmarcExpressionMember {
+    BooleanExpression?: never;
+    StringExpression?: never;
+    NumberExpression?: never;
+    IpExpression?: never;
+    VerdictExpression?: never;
+    DmarcExpression: RuleDmarcExpression;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    BooleanExpression?: never;
+    StringExpression?: never;
+    NumberExpression?: never;
+    IpExpression?: never;
+    VerdictExpression?: never;
+    DmarcExpression?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    BooleanExpression: (value: RuleBooleanExpression) => T;
+    StringExpression: (value: RuleStringExpression) => T;
+    NumberExpression: (value: RuleNumberExpression) => T;
+    IpExpression: (value: RuleIpExpression) => T;
+    VerdictExpression: (value: RuleVerdictExpression) => T;
+    DmarcExpression: (value: RuleDmarcExpression) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: RuleCondition, visitor: Visitor<T>) => T;
+}
+export interface Rule {
+  Name?: string;
+  Conditions?: RuleCondition[];
+  Unless?: RuleCondition[];
+  Actions: RuleAction[] | undefined;
+}
+export interface CreateRuleSetRequest {
+  ClientToken?: string;
+  RuleSetName: string | undefined;
+  Rules: Rule[] | undefined;
+  Tags?: Tag[];
+}
+export interface CreateRuleSetResponse {
+  RuleSetId: string | undefined;
+}
+export interface IngressAnalysis {
+  Analyzer: string | undefined;
+  ResultField: string | undefined;
+}
+export type IngressBooleanToEvaluate =
+  | IngressBooleanToEvaluate.AnalysisMember
+  | IngressBooleanToEvaluate.$UnknownMember;
+export declare namespace IngressBooleanToEvaluate {
+  interface AnalysisMember {
+    Analysis: IngressAnalysis;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    Analysis?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    Analysis: (value: IngressAnalysis) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: IngressBooleanToEvaluate, visitor: Visitor<T>) => T;
+}
+export declare const IngressBooleanOperator: {
+  readonly IS_FALSE: "IS_FALSE";
+  readonly IS_TRUE: "IS_TRUE";
+};
+export type IngressBooleanOperator =
+  (typeof IngressBooleanOperator)[keyof typeof IngressBooleanOperator];
+export interface IngressBooleanExpression {
+  Evaluate: IngressBooleanToEvaluate | undefined;
+  Operator: IngressBooleanOperator | undefined;
+}
+export declare const IngressIpv4Attribute: {
+  readonly SENDER_IP: "SENDER_IP";
+};
+export type IngressIpv4Attribute =
+  (typeof IngressIpv4Attribute)[keyof typeof IngressIpv4Attribute];
+export type IngressIpToEvaluate =
+  | IngressIpToEvaluate.AttributeMember
+  | IngressIpToEvaluate.$UnknownMember;
+export declare namespace IngressIpToEvaluate {
+  interface AttributeMember {
+    Attribute: IngressIpv4Attribute;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    Attribute?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    Attribute: (value: IngressIpv4Attribute) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: IngressIpToEvaluate, visitor: Visitor<T>) => T;
+}
+export declare const IngressIpOperator: {
+  readonly CIDR_MATCHES: "CIDR_MATCHES";
+  readonly NOT_CIDR_MATCHES: "NOT_CIDR_MATCHES";
+};
+export type IngressIpOperator =
+  (typeof IngressIpOperator)[keyof typeof IngressIpOperator];
+export interface IngressIpv4Expression {
+  Evaluate: IngressIpToEvaluate | undefined;
+  Operator: IngressIpOperator | undefined;
+  Values: string[] | undefined;
+}
+export declare const IngressStringEmailAttribute: {
+  readonly RECIPIENT: "RECIPIENT";
+};
+export type IngressStringEmailAttribute =
+  (typeof IngressStringEmailAttribute)[keyof typeof IngressStringEmailAttribute];
+export type IngressStringToEvaluate =
+  | IngressStringToEvaluate.AttributeMember
+  | IngressStringToEvaluate.$UnknownMember;
+export declare namespace IngressStringToEvaluate {
+  interface AttributeMember {
+    Attribute: IngressStringEmailAttribute;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    Attribute?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    Attribute: (value: IngressStringEmailAttribute) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: IngressStringToEvaluate, visitor: Visitor<T>) => T;
+}
+export declare const IngressStringOperator: {
+  readonly CONTAINS: "CONTAINS";
+  readonly ENDS_WITH: "ENDS_WITH";
+  readonly EQUALS: "EQUALS";
+  readonly NOT_EQUALS: "NOT_EQUALS";
+  readonly STARTS_WITH: "STARTS_WITH";
+};
+export type IngressStringOperator =
+  (typeof IngressStringOperator)[keyof typeof IngressStringOperator];
+export interface IngressStringExpression {
+  Evaluate: IngressStringToEvaluate | undefined;
+  Operator: IngressStringOperator | undefined;
+  Values: string[] | undefined;
+}
+export declare const IngressTlsAttribute: {
+  readonly TLS_PROTOCOL: "TLS_PROTOCOL";
+};
+export type IngressTlsAttribute =
+  (typeof IngressTlsAttribute)[keyof typeof IngressTlsAttribute];
+export type IngressTlsProtocolToEvaluate =
+  | IngressTlsProtocolToEvaluate.AttributeMember
+  | IngressTlsProtocolToEvaluate.$UnknownMember;
+export declare namespace IngressTlsProtocolToEvaluate {
+  interface AttributeMember {
+    Attribute: IngressTlsAttribute;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    Attribute?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    Attribute: (value: IngressTlsAttribute) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(
+    value: IngressTlsProtocolToEvaluate,
+    visitor: Visitor<T>
+  ) => T;
+}
+export declare const IngressTlsProtocolOperator: {
+  readonly IS: "IS";
+  readonly MINIMUM_TLS_VERSION: "MINIMUM_TLS_VERSION";
+};
+export type IngressTlsProtocolOperator =
+  (typeof IngressTlsProtocolOperator)[keyof typeof IngressTlsProtocolOperator];
+export declare const IngressTlsProtocolAttribute: {
+  readonly TLS1_2: "TLS1_2";
+  readonly TLS1_3: "TLS1_3";
+};
+export type IngressTlsProtocolAttribute =
+  (typeof IngressTlsProtocolAttribute)[keyof typeof IngressTlsProtocolAttribute];
+export interface IngressTlsProtocolExpression {
+  Evaluate: IngressTlsProtocolToEvaluate | undefined;
+  Operator: IngressTlsProtocolOperator | undefined;
+  Value: IngressTlsProtocolAttribute | undefined;
+}
+export type PolicyCondition =
+  | PolicyCondition.BooleanExpressionMember
+  | PolicyCondition.IpExpressionMember
+  | PolicyCondition.StringExpressionMember
+  | PolicyCondition.TlsExpressionMember
+  | PolicyCondition.$UnknownMember;
+export declare namespace PolicyCondition {
+  interface StringExpressionMember {
+    StringExpression: IngressStringExpression;
+    IpExpression?: never;
+    TlsExpression?: never;
+    BooleanExpression?: never;
+    $unknown?: never;
+  }
+  interface IpExpressionMember {
+    StringExpression?: never;
+    IpExpression: IngressIpv4Expression;
+    TlsExpression?: never;
+    BooleanExpression?: never;
+    $unknown?: never;
+  }
+  interface TlsExpressionMember {
+    StringExpression?: never;
+    IpExpression?: never;
+    TlsExpression: IngressTlsProtocolExpression;
+    BooleanExpression?: never;
+    $unknown?: never;
+  }
+  interface BooleanExpressionMember {
+    StringExpression?: never;
+    IpExpression?: never;
+    TlsExpression?: never;
+    BooleanExpression: IngressBooleanExpression;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    StringExpression?: never;
+    IpExpression?: never;
+    TlsExpression?: never;
+    BooleanExpression?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    StringExpression: (value: IngressStringExpression) => T;
+    IpExpression: (value: IngressIpv4Expression) => T;
+    TlsExpression: (value: IngressTlsProtocolExpression) => T;
+    BooleanExpression: (value: IngressBooleanExpression) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: PolicyCondition, visitor: Visitor<T>) => T;
+}
+export interface PolicyStatement {
+  Conditions: PolicyCondition[] | undefined;
+  Action: AcceptAction | undefined;
+}
+export interface CreateTrafficPolicyRequest {
+  ClientToken?: string;
+  TrafficPolicyName: string | undefined;
+  PolicyStatements: PolicyStatement[] | undefined;
+  DefaultAction: AcceptAction | undefined;
+  MaxMessageSizeBytes?: number;
+  Tags?: Tag[];
+}
+export interface CreateTrafficPolicyResponse {
+  TrafficPolicyId: string | undefined;
+}
+export interface DeleteIngressPointRequest {
+  IngressPointId: string | undefined;
+}
+export interface DeleteIngressPointResponse {}
+export interface DeleteRelayRequest {
+  RelayId: string | undefined;
+}
+export interface DeleteRelayResponse {}
+export interface DeleteRuleSetRequest {
+  RuleSetId: string | undefined;
+}
+export interface DeleteRuleSetResponse {}
+export interface DeleteTrafficPolicyRequest {
+  TrafficPolicyId: string | undefined;
+}
+export interface DeleteTrafficPolicyResponse {}
+export interface S3ExportDestinationConfiguration {
+  S3Location?: string;
+}
+export type ExportDestinationConfiguration =
+  | ExportDestinationConfiguration.S3Member
+  | ExportDestinationConfiguration.$UnknownMember;
+export declare namespace ExportDestinationConfiguration {
+  interface S3Member {
+    S3: S3ExportDestinationConfiguration;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    S3?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    S3: (value: S3ExportDestinationConfiguration) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(
+    value: ExportDestinationConfiguration,
+    visitor: Visitor<T>
+  ) => T;
+}
+export declare const ExportState: {
+  readonly CANCELLED: "CANCELLED";
+  readonly COMPLETED: "COMPLETED";
+  readonly FAILED: "FAILED";
+  readonly PREPROCESSING: "PREPROCESSING";
+  readonly PROCESSING: "PROCESSING";
+  readonly QUEUED: "QUEUED";
+};
+export type ExportState = (typeof ExportState)[keyof typeof ExportState];
+export interface ExportStatus {
+  SubmissionTimestamp?: Date;
+  CompletionTimestamp?: Date;
+  State?: ExportState;
+  ErrorMessage?: string;
+}
+export interface ExportSummary {
+  ExportId?: string;
+  Status?: ExportStatus;
+}
+export interface GetArchiveExportRequest {
+  ExportId: string | undefined;
+}
+export interface GetArchiveExportResponse {
+  ArchiveId?: string;
+  Filters?: ArchiveFilters;
+  FromTimestamp?: Date;
+  ToTimestamp?: Date;
+  MaxResults?: number;
+  ExportDestinationConfiguration?: ExportDestinationConfiguration;
+  Status?: ExportStatus;
+}
+export interface GetArchiveMessageRequest {
+  ArchivedMessageId: string | undefined;
+}
+export interface GetArchiveMessageResponse {
+  MessageDownloadLink?: string;
+}
+export interface GetArchiveMessageContentRequest {
+  ArchivedMessageId: string | undefined;
+}
+export interface MessageBody {
+  Text?: string;
+  Html?: string;
+  MessageMalformed?: boolean;
+}
+export interface GetArchiveMessageContentResponse {
+  Body?: MessageBody;
+}
+export interface GetArchiveSearchRequest {
+  SearchId: string | undefined;
+}
+export declare const SearchState: {
+  readonly CANCELLED: "CANCELLED";
+  readonly COMPLETED: "COMPLETED";
+  readonly FAILED: "FAILED";
+  readonly QUEUED: "QUEUED";
+  readonly RUNNING: "RUNNING";
+};
+export type SearchState = (typeof SearchState)[keyof typeof SearchState];
+export interface SearchStatus {
+  SubmissionTimestamp?: Date;
+  CompletionTimestamp?: Date;
+  State?: SearchState;
+  ErrorMessage?: string;
+}
+export interface GetArchiveSearchResponse {
+  ArchiveId?: string;
+  Filters?: ArchiveFilters;
+  FromTimestamp?: Date;
+  ToTimestamp?: Date;
+  MaxResults?: number;
+  Status?: SearchStatus;
+}
+export interface GetArchiveSearchResultsRequest {
+  SearchId: string | undefined;
+}
+export interface Row {
+  ArchivedMessageId?: string;
+  ReceivedTimestamp?: Date;
+  Date?: string;
+  To?: string;
+  From?: string;
+  Cc?: string;
+  Subject?: string;
+  MessageId?: string;
+  HasAttachments?: boolean;
+  ReceivedHeaders?: string[];
+  InReplyTo?: string;
+  XMailer?: string;
+  XOriginalMailer?: string;
+  XPriority?: string;
+}
+export interface GetArchiveSearchResultsResponse {
+  Rows?: Row[];
+}
+export interface GetIngressPointRequest {
+  IngressPointId: string | undefined;
+}
+export interface IngressPointPasswordConfiguration {
+  SmtpPasswordVersion?: string;
+  PreviousSmtpPasswordVersion?: string;
+  PreviousSmtpPasswordExpiryTimestamp?: Date;
+}
+export interface IngressPointAuthConfiguration {
+  IngressPointPasswordConfiguration?: IngressPointPasswordConfiguration;
+  SecretArn?: string;
+}
+export declare const IngressPointStatus: {
+  readonly ACTIVE: "ACTIVE";
+  readonly CLOSED: "CLOSED";
+  readonly DEPROVISIONING: "DEPROVISIONING";
+  readonly FAILED: "FAILED";
+  readonly PROVISIONING: "PROVISIONING";
+  readonly UPDATING: "UPDATING";
+};
+export type IngressPointStatus =
+  (typeof IngressPointStatus)[keyof typeof IngressPointStatus];
+export interface GetIngressPointResponse {
+  IngressPointId: string | undefined;
+  IngressPointName: string | undefined;
+  IngressPointArn?: string;
+  Status?: IngressPointStatus;
+  Type?: IngressPointType;
+  ARecord?: string;
+  RuleSetId?: string;
+  TrafficPolicyId?: string;
+  IngressPointAuthConfiguration?: IngressPointAuthConfiguration;
+  CreatedTimestamp?: Date;
+  LastUpdatedTimestamp?: Date;
+}
+export interface GetRelayRequest {
+  RelayId: string | undefined;
+}
+export interface GetRelayResponse {
+  RelayId: string | undefined;
+  RelayArn?: string;
+  RelayName?: string;
+  ServerName?: string;
+  ServerPort?: number;
+  Authentication?: RelayAuthentication;
+  CreatedTimestamp?: Date;
+  LastModifiedTimestamp?: Date;
+}
+export interface GetRuleSetRequest {
+  RuleSetId: string | undefined;
+}
+export interface GetRuleSetResponse {
+  RuleSetId: string | undefined;
+  RuleSetArn: string | undefined;
+  RuleSetName: string | undefined;
+  CreatedDate: Date | undefined;
+  LastModificationDate: Date | undefined;
+  Rules: Rule[] | undefined;
+}
+export interface GetTrafficPolicyRequest {
+  TrafficPolicyId: string | undefined;
+}
+export interface GetTrafficPolicyResponse {
+  TrafficPolicyName: string | undefined;
+  TrafficPolicyId: string | undefined;
+  TrafficPolicyArn?: string;
+  PolicyStatements?: PolicyStatement[];
+  MaxMessageSizeBytes?: number;
+  DefaultAction?: AcceptAction;
+  CreatedTimestamp?: Date;
+  LastUpdatedTimestamp?: Date;
+}
+export interface IngressPoint {
+  IngressPointName: string | undefined;
+  IngressPointId: string | undefined;
+  Status: IngressPointStatus | undefined;
+  Type: IngressPointType | undefined;
+  ARecord?: string;
+}
+export interface ListIngressPointsRequest {
+  PageSize?: number;
+  NextToken?: string;
+}
+export interface ListIngressPointsResponse {
+  IngressPoints?: IngressPoint[];
+  NextToken?: string;
+}
+export declare const IngressPointStatusToUpdate: {
+  readonly ACTIVE: "ACTIVE";
+  readonly CLOSED: "CLOSED";
+};
+export type IngressPointStatusToUpdate =
+  (typeof IngressPointStatusToUpdate)[keyof typeof IngressPointStatusToUpdate];
+export interface UpdateIngressPointRequest {
+  IngressPointId: string | undefined;
+  IngressPointName?: string;
+  StatusToUpdate?: IngressPointStatusToUpdate;
+  RuleSetId?: string;
+  TrafficPolicyId?: string;
+  IngressPointConfiguration?: IngressPointConfiguration;
+}
+export interface UpdateIngressPointResponse {}
+export interface ListArchiveExportsRequest {
+  ArchiveId: string | undefined;
+  NextToken?: string;
+  PageSize?: number;
+}
+export interface ListArchiveExportsResponse {
+  Exports?: ExportSummary[];
+  NextToken?: string;
+}
+export interface ListArchiveSearchesRequest {
+  ArchiveId: string | undefined;
+  NextToken?: string;
+  PageSize?: number;
+}
+export interface SearchSummary {
+  SearchId?: string;
+  Status?: SearchStatus;
+}
+export interface ListArchiveSearchesResponse {
+  Searches?: SearchSummary[];
+  NextToken?: string;
+}
+export interface ListRelaysRequest {
+  PageSize?: number;
+  NextToken?: string;
+}
+export interface Relay {
+  RelayId?: string;
+  RelayName?: string;
+  LastModifiedTimestamp?: Date;
+}
+export interface ListRelaysResponse {
+  Relays: Relay[] | undefined;
+  NextToken?: string;
+}
+export interface ListRuleSetsRequest {
+  NextToken?: string;
+  PageSize?: number;
+}
+export interface RuleSet {
+  RuleSetId?: string;
+  RuleSetName?: string;
+  LastModificationDate?: Date;
+}
+export interface ListRuleSetsResponse {
+  RuleSets: RuleSet[] | undefined;
+  NextToken?: string;
+}
+export interface ListTagsForResourceRequest {
+  ResourceArn: string | undefined;
+}
+export interface ListTagsForResourceResponse {
+  Tags: Tag[] | undefined;
+}
+export interface ListTrafficPoliciesRequest {
+  PageSize?: number;
+  NextToken?: string;
+}
+export interface TrafficPolicy {
+  TrafficPolicyName: string | undefined;
+  TrafficPolicyId: string | undefined;
+  DefaultAction: AcceptAction | undefined;
+}
+export interface ListTrafficPoliciesResponse {
+  TrafficPolicies?: TrafficPolicy[];
+  NextToken?: string;
+}
+export interface UpdateRelayRequest {
+  RelayId: string | undefined;
+  RelayName?: string;
+  ServerName?: string;
+  ServerPort?: number;
+  Authentication?: RelayAuthentication;
+}
+export interface UpdateRelayResponse {}
+export interface UpdateRuleSetRequest {
+  RuleSetId: string | undefined;
+  RuleSetName?: string;
+  Rules?: Rule[];
+}
+export interface UpdateRuleSetResponse {}
+export interface StartArchiveExportRequest {
+  ArchiveId: string | undefined;
+  Filters?: ArchiveFilters;
+  FromTimestamp: Date | undefined;
+  ToTimestamp: Date | undefined;
+  MaxResults?: number;
+  ExportDestinationConfiguration: ExportDestinationConfiguration | undefined;
+}
+export interface StartArchiveExportResponse {
+  ExportId?: string;
+}
+export interface StartArchiveSearchRequest {
+  ArchiveId: string | undefined;
+  Filters?: ArchiveFilters;
+  FromTimestamp: Date | undefined;
+  ToTimestamp: Date | undefined;
+  MaxResults: number | undefined;
+}
+export interface StartArchiveSearchResponse {
+  SearchId?: string;
+}
+export interface StopArchiveExportRequest {
+  ExportId: string | undefined;
+}
+export interface StopArchiveExportResponse {}
+export interface StopArchiveSearchRequest {
+  SearchId: string | undefined;
+}
+export interface StopArchiveSearchResponse {}
+export interface TagResourceRequest {
+  ResourceArn: string | undefined;
+  Tags: Tag[] | undefined;
+}
+export interface TagResourceResponse {}
+export interface UpdateTrafficPolicyRequest {
+  TrafficPolicyId: string | undefined;
+  TrafficPolicyName?: string;
+  PolicyStatements?: PolicyStatement[];
+  DefaultAction?: AcceptAction;
+  MaxMessageSizeBytes?: number;
+}
+export interface UpdateTrafficPolicyResponse {}
+export interface UntagResourceRequest {
+  ResourceArn: string | undefined;
+  TagKeys: string[] | undefined;
+}
+export interface UntagResourceResponse {}
+export declare const TagFilterSensitiveLog: (obj: Tag) => any;
+export declare const CreateAddonInstanceRequestFilterSensitiveLog: (
+  obj: CreateAddonInstanceRequest
+) => any;
+export declare const CreateAddonSubscriptionRequestFilterSensitiveLog: (
+  obj: CreateAddonSubscriptionRequest
+) => any;
+export declare const CreateArchiveRequestFilterSensitiveLog: (
+  obj: CreateArchiveRequest
+) => any;
+export declare const IngressPointConfigurationFilterSensitiveLog: (
+  obj: IngressPointConfiguration
+) => any;
+export declare const CreateIngressPointRequestFilterSensitiveLog: (
+  obj: CreateIngressPointRequest
+) => any;
+export declare const CreateRelayRequestFilterSensitiveLog: (
+  obj: CreateRelayRequest
+) => any;
+export declare const ReplaceRecipientActionFilterSensitiveLog: (
+  obj: ReplaceRecipientAction
+) => any;
+export declare const RuleActionFilterSensitiveLog: (obj: RuleAction) => any;
+export declare const RuleFilterSensitiveLog: (obj: Rule) => any;
+export declare const CreateRuleSetRequestFilterSensitiveLog: (
+  obj: CreateRuleSetRequest
+) => any;
+export declare const CreateTrafficPolicyRequestFilterSensitiveLog: (
+  obj: CreateTrafficPolicyRequest
+) => any;
+export declare const GetRuleSetResponseFilterSensitiveLog: (
+  obj: GetRuleSetResponse
+) => any;
+export declare const UpdateIngressPointRequestFilterSensitiveLog: (
+  obj: UpdateIngressPointRequest
+) => any;
+export declare const ListTagsForResourceResponseFilterSensitiveLog: (
+  obj: ListTagsForResourceResponse
+) => any;
+export declare const UpdateRuleSetRequestFilterSensitiveLog: (
+  obj: UpdateRuleSetRequest
+) => any;
+export declare const TagResourceRequestFilterSensitiveLog: (
+  obj: TagResourceRequest
+) => any;
+export declare const UntagResourceRequestFilterSensitiveLog: (
+  obj: UntagResourceRequest
+) => any;