@aws-sdk/client-mailmanager 3.581.0

package/dist-es/models/models_0.js

@@ -0,0 +1,554 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { MailManagerServiceException as __BaseException } from "./MailManagerServiceException";
+export const AcceptAction = {
+    ALLOW: "ALLOW",
+    DENY: "DENY",
+};
+export class AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "AccessDeniedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export const ActionFailurePolicy = {
+    CONTINUE: "CONTINUE",
+    DROP: "DROP",
+};
+export class ConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class ServiceQuotaExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class ValidationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export const ArchiveState = {
+    ACTIVE: "ACTIVE",
+    PENDING_DELETION: "PENDING_DELETION",
+};
+export const ArchiveBooleanEmailAttribute = {
+    HAS_ATTACHMENTS: "HAS_ATTACHMENTS",
+};
+export var ArchiveBooleanToEvaluate;
+(function (ArchiveBooleanToEvaluate) {
+    ArchiveBooleanToEvaluate.visit = (value, visitor) => {
+        if (value.Attribute !== undefined)
+            return visitor.Attribute(value.Attribute);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ArchiveBooleanToEvaluate || (ArchiveBooleanToEvaluate = {}));
+export const ArchiveBooleanOperator = {
+    IS_FALSE: "IS_FALSE",
+    IS_TRUE: "IS_TRUE",
+};
+export const ArchiveStringEmailAttribute = {
+    CC: "CC",
+    FROM: "FROM",
+    SUBJECT: "SUBJECT",
+    TO: "TO",
+};
+export var ArchiveStringToEvaluate;
+(function (ArchiveStringToEvaluate) {
+    ArchiveStringToEvaluate.visit = (value, visitor) => {
+        if (value.Attribute !== undefined)
+            return visitor.Attribute(value.Attribute);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ArchiveStringToEvaluate || (ArchiveStringToEvaluate = {}));
+export const ArchiveStringOperator = {
+    CONTAINS: "CONTAINS",
+};
+export var ArchiveFilterCondition;
+(function (ArchiveFilterCondition) {
+    ArchiveFilterCondition.visit = (value, visitor) => {
+        if (value.StringExpression !== undefined)
+            return visitor.StringExpression(value.StringExpression);
+        if (value.BooleanExpression !== undefined)
+            return visitor.BooleanExpression(value.BooleanExpression);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ArchiveFilterCondition || (ArchiveFilterCondition = {}));
+export const RetentionPeriod = {
+    EIGHTEEN_MONTHS: "EIGHTEEN_MONTHS",
+    EIGHT_YEARS: "EIGHT_YEARS",
+    FIVE_YEARS: "FIVE_YEARS",
+    FOUR_YEARS: "FOUR_YEARS",
+    NINE_MONTHS: "NINE_MONTHS",
+    NINE_YEARS: "NINE_YEARS",
+    ONE_YEAR: "ONE_YEAR",
+    PERMANENT: "PERMANENT",
+    SEVEN_YEARS: "SEVEN_YEARS",
+    SIX_MONTHS: "SIX_MONTHS",
+    SIX_YEARS: "SIX_YEARS",
+    TEN_YEARS: "TEN_YEARS",
+    THIRTY_MONTHS: "THIRTY_MONTHS",
+    THREE_MONTHS: "THREE_MONTHS",
+    THREE_YEARS: "THREE_YEARS",
+    TWO_YEARS: "TWO_YEARS",
+};
+export var ArchiveRetention;
+(function (ArchiveRetention) {
+    ArchiveRetention.visit = (value, visitor) => {
+        if (value.RetentionPeriod !== undefined)
+            return visitor.RetentionPeriod(value.RetentionPeriod);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ArchiveRetention || (ArchiveRetention = {}));
+export class ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export var IngressPointConfiguration;
+(function (IngressPointConfiguration) {
+    IngressPointConfiguration.visit = (value, visitor) => {
+        if (value.SmtpPassword !== undefined)
+            return visitor.SmtpPassword(value.SmtpPassword);
+        if (value.SecretArn !== undefined)
+            return visitor.SecretArn(value.SecretArn);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(IngressPointConfiguration || (IngressPointConfiguration = {}));
+export const IngressPointType = {
+    AUTH: "AUTH",
+    OPEN: "OPEN",
+};
+export var RelayAuthentication;
+(function (RelayAuthentication) {
+    RelayAuthentication.visit = (value, visitor) => {
+        if (value.SecretArn !== undefined)
+            return visitor.SecretArn(value.SecretArn);
+        if (value.NoAuthentication !== undefined)
+            return visitor.NoAuthentication(value.NoAuthentication);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RelayAuthentication || (RelayAuthentication = {}));
+export const MailFrom = {
+    PRESERVE: "PRESERVE",
+    REPLACE: "REPLACE",
+};
+export var RuleAction;
+(function (RuleAction) {
+    RuleAction.visit = (value, visitor) => {
+        if (value.Drop !== undefined)
+            return visitor.Drop(value.Drop);
+        if (value.Relay !== undefined)
+            return visitor.Relay(value.Relay);
+        if (value.Archive !== undefined)
+            return visitor.Archive(value.Archive);
+        if (value.WriteToS3 !== undefined)
+            return visitor.WriteToS3(value.WriteToS3);
+        if (value.Send !== undefined)
+            return visitor.Send(value.Send);
+        if (value.AddHeader !== undefined)
+            return visitor.AddHeader(value.AddHeader);
+        if (value.ReplaceRecipient !== undefined)
+            return visitor.ReplaceRecipient(value.ReplaceRecipient);
+        if (value.DeliverToMailbox !== undefined)
+            return visitor.DeliverToMailbox(value.DeliverToMailbox);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RuleAction || (RuleAction = {}));
+export const RuleBooleanEmailAttribute = {
+    READ_RECEIPT_REQUESTED: "READ_RECEIPT_REQUESTED",
+    TLS: "TLS",
+    TLS_WRAPPED: "TLS_WRAPPED",
+};
+export var RuleBooleanToEvaluate;
+(function (RuleBooleanToEvaluate) {
+    RuleBooleanToEvaluate.visit = (value, visitor) => {
+        if (value.Attribute !== undefined)
+            return visitor.Attribute(value.Attribute);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RuleBooleanToEvaluate || (RuleBooleanToEvaluate = {}));
+export const RuleBooleanOperator = {
+    IS_FALSE: "IS_FALSE",
+    IS_TRUE: "IS_TRUE",
+};
+export const RuleDmarcOperator = {
+    EQUALS: "EQUALS",
+    NOT_EQUALS: "NOT_EQUALS",
+};
+export const RuleDmarcPolicy = {
+    NONE: "NONE",
+    QUARANTINE: "QUARANTINE",
+    REJECT: "REJECT",
+};
+export const RuleIpEmailAttribute = {
+    SOURCE_IP: "SOURCE_IP",
+};
+export var RuleIpToEvaluate;
+(function (RuleIpToEvaluate) {
+    RuleIpToEvaluate.visit = (value, visitor) => {
+        if (value.Attribute !== undefined)
+            return visitor.Attribute(value.Attribute);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RuleIpToEvaluate || (RuleIpToEvaluate = {}));
+export const RuleIpOperator = {
+    CIDR_MATCHES: "CIDR_MATCHES",
+    NOT_CIDR_MATCHES: "NOT_CIDR_MATCHES",
+};
+export const RuleNumberEmailAttribute = {
+    MESSAGE_SIZE: "MESSAGE_SIZE",
+};
+export var RuleNumberToEvaluate;
+(function (RuleNumberToEvaluate) {
+    RuleNumberToEvaluate.visit = (value, visitor) => {
+        if (value.Attribute !== undefined)
+            return visitor.Attribute(value.Attribute);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RuleNumberToEvaluate || (RuleNumberToEvaluate = {}));
+export const RuleNumberOperator = {
+    EQUALS: "EQUALS",
+    GREATER_THAN: "GREATER_THAN",
+    GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL",
+    LESS_THAN: "LESS_THAN",
+    LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL",
+    NOT_EQUALS: "NOT_EQUALS",
+};
+export const RuleStringEmailAttribute = {
+    CC: "CC",
+    FROM: "FROM",
+    HELO: "HELO",
+    MAIL_FROM: "MAIL_FROM",
+    RECIPIENT: "RECIPIENT",
+    SENDER: "SENDER",
+    SUBJECT: "SUBJECT",
+    TO: "TO",
+};
+export var RuleStringToEvaluate;
+(function (RuleStringToEvaluate) {
+    RuleStringToEvaluate.visit = (value, visitor) => {
+        if (value.Attribute !== undefined)
+            return visitor.Attribute(value.Attribute);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RuleStringToEvaluate || (RuleStringToEvaluate = {}));
+export const RuleStringOperator = {
+    CONTAINS: "CONTAINS",
+    ENDS_WITH: "ENDS_WITH",
+    EQUALS: "EQUALS",
+    NOT_EQUALS: "NOT_EQUALS",
+    STARTS_WITH: "STARTS_WITH",
+};
+export const RuleVerdictAttribute = {
+    DKIM: "DKIM",
+    SPF: "SPF",
+};
+export var RuleVerdictToEvaluate;
+(function (RuleVerdictToEvaluate) {
+    RuleVerdictToEvaluate.visit = (value, visitor) => {
+        if (value.Attribute !== undefined)
+            return visitor.Attribute(value.Attribute);
+        if (value.Analysis !== undefined)
+            return visitor.Analysis(value.Analysis);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RuleVerdictToEvaluate || (RuleVerdictToEvaluate = {}));
+export const RuleVerdictOperator = {
+    EQUALS: "EQUALS",
+    NOT_EQUALS: "NOT_EQUALS",
+};
+export const RuleVerdict = {
+    FAIL: "FAIL",
+    GRAY: "GRAY",
+    PASS: "PASS",
+    PROCESSING_FAILED: "PROCESSING_FAILED",
+};
+export var RuleCondition;
+(function (RuleCondition) {
+    RuleCondition.visit = (value, visitor) => {
+        if (value.BooleanExpression !== undefined)
+            return visitor.BooleanExpression(value.BooleanExpression);
+        if (value.StringExpression !== undefined)
+            return visitor.StringExpression(value.StringExpression);
+        if (value.NumberExpression !== undefined)
+            return visitor.NumberExpression(value.NumberExpression);
+        if (value.IpExpression !== undefined)
+            return visitor.IpExpression(value.IpExpression);
+        if (value.VerdictExpression !== undefined)
+            return visitor.VerdictExpression(value.VerdictExpression);
+        if (value.DmarcExpression !== undefined)
+            return visitor.DmarcExpression(value.DmarcExpression);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RuleCondition || (RuleCondition = {}));
+export var IngressBooleanToEvaluate;
+(function (IngressBooleanToEvaluate) {
+    IngressBooleanToEvaluate.visit = (value, visitor) => {
+        if (value.Analysis !== undefined)
+            return visitor.Analysis(value.Analysis);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(IngressBooleanToEvaluate || (IngressBooleanToEvaluate = {}));
+export const IngressBooleanOperator = {
+    IS_FALSE: "IS_FALSE",
+    IS_TRUE: "IS_TRUE",
+};
+export const IngressIpv4Attribute = {
+    SENDER_IP: "SENDER_IP",
+};
+export var IngressIpToEvaluate;
+(function (IngressIpToEvaluate) {
+    IngressIpToEvaluate.visit = (value, visitor) => {
+        if (value.Attribute !== undefined)
+            return visitor.Attribute(value.Attribute);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(IngressIpToEvaluate || (IngressIpToEvaluate = {}));
+export const IngressIpOperator = {
+    CIDR_MATCHES: "CIDR_MATCHES",
+    NOT_CIDR_MATCHES: "NOT_CIDR_MATCHES",
+};
+export const IngressStringEmailAttribute = {
+    RECIPIENT: "RECIPIENT",
+};
+export var IngressStringToEvaluate;
+(function (IngressStringToEvaluate) {
+    IngressStringToEvaluate.visit = (value, visitor) => {
+        if (value.Attribute !== undefined)
+            return visitor.Attribute(value.Attribute);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(IngressStringToEvaluate || (IngressStringToEvaluate = {}));
+export const IngressStringOperator = {
+    CONTAINS: "CONTAINS",
+    ENDS_WITH: "ENDS_WITH",
+    EQUALS: "EQUALS",
+    NOT_EQUALS: "NOT_EQUALS",
+    STARTS_WITH: "STARTS_WITH",
+};
+export const IngressTlsAttribute = {
+    TLS_PROTOCOL: "TLS_PROTOCOL",
+};
+export var IngressTlsProtocolToEvaluate;
+(function (IngressTlsProtocolToEvaluate) {
+    IngressTlsProtocolToEvaluate.visit = (value, visitor) => {
+        if (value.Attribute !== undefined)
+            return visitor.Attribute(value.Attribute);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(IngressTlsProtocolToEvaluate || (IngressTlsProtocolToEvaluate = {}));
+export const IngressTlsProtocolOperator = {
+    IS: "IS",
+    MINIMUM_TLS_VERSION: "MINIMUM_TLS_VERSION",
+};
+export const IngressTlsProtocolAttribute = {
+    TLS1_2: "TLS1_2",
+    TLS1_3: "TLS1_3",
+};
+export var PolicyCondition;
+(function (PolicyCondition) {
+    PolicyCondition.visit = (value, visitor) => {
+        if (value.StringExpression !== undefined)
+            return visitor.StringExpression(value.StringExpression);
+        if (value.IpExpression !== undefined)
+            return visitor.IpExpression(value.IpExpression);
+        if (value.TlsExpression !== undefined)
+            return visitor.TlsExpression(value.TlsExpression);
+        if (value.BooleanExpression !== undefined)
+            return visitor.BooleanExpression(value.BooleanExpression);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PolicyCondition || (PolicyCondition = {}));
+export var ExportDestinationConfiguration;
+(function (ExportDestinationConfiguration) {
+    ExportDestinationConfiguration.visit = (value, visitor) => {
+        if (value.S3 !== undefined)
+            return visitor.S3(value.S3);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ExportDestinationConfiguration || (ExportDestinationConfiguration = {}));
+export const ExportState = {
+    CANCELLED: "CANCELLED",
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+    PREPROCESSING: "PREPROCESSING",
+    PROCESSING: "PROCESSING",
+    QUEUED: "QUEUED",
+};
+export const SearchState = {
+    CANCELLED: "CANCELLED",
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+    QUEUED: "QUEUED",
+    RUNNING: "RUNNING",
+};
+export const IngressPointStatus = {
+    ACTIVE: "ACTIVE",
+    CLOSED: "CLOSED",
+    DEPROVISIONING: "DEPROVISIONING",
+    FAILED: "FAILED",
+    PROVISIONING: "PROVISIONING",
+    UPDATING: "UPDATING",
+};
+export const IngressPointStatusToUpdate = {
+    ACTIVE: "ACTIVE",
+    CLOSED: "CLOSED",
+};
+export const TagFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Key && { Key: SENSITIVE_STRING }),
+    ...(obj.Value && { Value: SENSITIVE_STRING }),
+});
+export const CreateAddonInstanceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }),
+});
+export const CreateAddonSubscriptionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }),
+});
+export const CreateArchiveRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Retention && { Retention: obj.Retention }),
+    ...(obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }),
+});
+export const IngressPointConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.SmtpPassword !== undefined)
+        return { SmtpPassword: SENSITIVE_STRING };
+    if (obj.SecretArn !== undefined)
+        return { SecretArn: obj.SecretArn };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateIngressPointRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.IngressPointConfiguration && {
+        IngressPointConfiguration: IngressPointConfigurationFilterSensitiveLog(obj.IngressPointConfiguration),
+    }),
+    ...(obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }),
+});
+export const CreateRelayRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Authentication && { Authentication: obj.Authentication }),
+    ...(obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }),
+});
+export const ReplaceRecipientActionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ReplaceWith && { ReplaceWith: SENSITIVE_STRING }),
+});
+export const RuleActionFilterSensitiveLog = (obj) => {
+    if (obj.Drop !== undefined)
+        return { Drop: obj.Drop };
+    if (obj.Relay !== undefined)
+        return { Relay: obj.Relay };
+    if (obj.Archive !== undefined)
+        return { Archive: obj.Archive };
+    if (obj.WriteToS3 !== undefined)
+        return { WriteToS3: obj.WriteToS3 };
+    if (obj.Send !== undefined)
+        return { Send: obj.Send };
+    if (obj.AddHeader !== undefined)
+        return { AddHeader: obj.AddHeader };
+    if (obj.ReplaceRecipient !== undefined)
+        return { ReplaceRecipient: ReplaceRecipientActionFilterSensitiveLog(obj.ReplaceRecipient) };
+    if (obj.DeliverToMailbox !== undefined)
+        return { DeliverToMailbox: obj.DeliverToMailbox };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const RuleFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Conditions && { Conditions: obj.Conditions.map((item) => item) }),
+    ...(obj.Unless && { Unless: obj.Unless.map((item) => item) }),
+    ...(obj.Actions && { Actions: obj.Actions.map((item) => RuleActionFilterSensitiveLog(item)) }),
+});
+export const CreateRuleSetRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Rules && { Rules: obj.Rules.map((item) => RuleFilterSensitiveLog(item)) }),
+    ...(obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }),
+});
+export const CreateTrafficPolicyRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PolicyStatements && { PolicyStatements: obj.PolicyStatements.map((item) => item) }),
+    ...(obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }),
+});
+export const GetRuleSetResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Rules && { Rules: obj.Rules.map((item) => RuleFilterSensitiveLog(item)) }),
+});
+export const UpdateIngressPointRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.IngressPointConfiguration && {
+        IngressPointConfiguration: IngressPointConfigurationFilterSensitiveLog(obj.IngressPointConfiguration),
+    }),
+});
+export const ListTagsForResourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }),
+});
+export const UpdateRuleSetRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Rules && { Rules: obj.Rules.map((item) => RuleFilterSensitiveLog(item)) }),
+});
+export const TagResourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }),
+});
+export const UntagResourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.TagKeys && { TagKeys: SENSITIVE_STRING }),
+});

package/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist-es/pagination/ListAddonInstancesPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { ListAddonInstancesCommand, } from "../commands/ListAddonInstancesCommand";
+import { MailManagerClient } from "../MailManagerClient";
+export const paginateListAddonInstances = createPaginator(MailManagerClient, ListAddonInstancesCommand, "NextToken", "NextToken", "PageSize");

package/dist-es/pagination/ListAddonSubscriptionsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { ListAddonSubscriptionsCommand, } from "../commands/ListAddonSubscriptionsCommand";
+import { MailManagerClient } from "../MailManagerClient";
+export const paginateListAddonSubscriptions = createPaginator(MailManagerClient, ListAddonSubscriptionsCommand, "NextToken", "NextToken", "PageSize");

package/dist-es/pagination/ListArchiveExportsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { ListArchiveExportsCommand, } from "../commands/ListArchiveExportsCommand";
+import { MailManagerClient } from "../MailManagerClient";
+export const paginateListArchiveExports = createPaginator(MailManagerClient, ListArchiveExportsCommand, "NextToken", "NextToken", "PageSize");

package/dist-es/pagination/ListArchiveSearchesPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { ListArchiveSearchesCommand, } from "../commands/ListArchiveSearchesCommand";
+import { MailManagerClient } from "../MailManagerClient";
+export const paginateListArchiveSearches = createPaginator(MailManagerClient, ListArchiveSearchesCommand, "NextToken", "NextToken", "PageSize");

package/dist-es/pagination/ListArchivesPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { ListArchivesCommand, } from "../commands/ListArchivesCommand";
+import { MailManagerClient } from "../MailManagerClient";
+export const paginateListArchives = createPaginator(MailManagerClient, ListArchivesCommand, "NextToken", "NextToken", "PageSize");

package/dist-es/pagination/ListIngressPointsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { ListIngressPointsCommand, } from "../commands/ListIngressPointsCommand";
+import { MailManagerClient } from "../MailManagerClient";
+export const paginateListIngressPoints = createPaginator(MailManagerClient, ListIngressPointsCommand, "NextToken", "NextToken", "PageSize");

package/dist-es/pagination/ListRelaysPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { ListRelaysCommand } from "../commands/ListRelaysCommand";
+import { MailManagerClient } from "../MailManagerClient";
+export const paginateListRelays = createPaginator(MailManagerClient, ListRelaysCommand, "NextToken", "NextToken", "PageSize");

package/dist-es/pagination/ListRuleSetsPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { ListRuleSetsCommand, } from "../commands/ListRuleSetsCommand";
+import { MailManagerClient } from "../MailManagerClient";
+export const paginateListRuleSets = createPaginator(MailManagerClient, ListRuleSetsCommand, "NextToken", "NextToken", "PageSize");

package/dist-es/pagination/ListTrafficPoliciesPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { ListTrafficPoliciesCommand, } from "../commands/ListTrafficPoliciesCommand";
+import { MailManagerClient } from "../MailManagerClient";
+export const paginateListTrafficPolicies = createPaginator(MailManagerClient, ListTrafficPoliciesCommand, "NextToken", "NextToken", "PageSize");

package/dist-es/pagination/index.js

@@ -0,0 +1,10 @@
+export * from "./Interfaces";
+export * from "./ListAddonInstancesPaginator";
+export * from "./ListAddonSubscriptionsPaginator";
+export * from "./ListArchiveExportsPaginator";
+export * from "./ListArchiveSearchesPaginator";
+export * from "./ListArchivesPaginator";
+export * from "./ListIngressPointsPaginator";
+export * from "./ListRelaysPaginator";
+export * from "./ListRuleSetsPaginator";
+export * from "./ListTrafficPoliciesPaginator";