import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import * as C from "../category.js";
const svc = T.AwsApiService({
    sdkId: "Pinpoint Email",
    serviceShapeName: "AmazonPinpointEmailService",
});
const auth = T.AwsAuthSigv4({ name: "ses" });
const ver = T.ServiceVersion("2018-07-26");
const proto = T.AwsProtocolsRestJson1();
const rules = T.EndpointResolver((p, _) => {
    const { Region, UseDualStack = false, UseFIPS = false, Endpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        if (UseDualStack === true) {
            return err("Invalid Configuration: Dualstack and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true && UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsFIPS") &&
                        true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://email-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("FIPS and DualStack are enabled, but this partition does not support one or both");
                }
                if (UseFIPS === true) {
                    if (_.getAttr(PartitionResult, "supportsFIPS") === true) {
                        return e(`https://email-fips.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
                    }
                    return err("FIPS is enabled but this partition does not support FIPS");
                }
                if (UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://email.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                return e(`https://email.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const TrackingOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ CustomRedirectDomain: S.String })).annotate({
    identifier: "TrackingOptions",
});
export const TlsPolicy = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DeliveryOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    TlsPolicy: S.optional(TlsPolicy),
    SendingPoolName: S.optional(S.String),
})).annotate({
    identifier: "DeliveryOptions",
});
export const ReputationOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReputationMetricsEnabled: S.optional(S.Boolean),
    LastFreshStart: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({
    identifier: "ReputationOptions",
});
export const SendingOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ SendingEnabled: S.optional(S.Boolean) })).annotate({ identifier: "SendingOptions" });
export const Tag = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Key: S.String, Value: S.String })).annotate({ identifier: "Tag" });
export const TagList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Tag);
export const CreateConfigurationSetRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSetName: S.String,
    TrackingOptions: S.optional(TrackingOptions),
    DeliveryOptions: S.optional(DeliveryOptions),
    ReputationOptions: S.optional(ReputationOptions),
    SendingOptions: S.optional(SendingOptions),
    Tags: S.optional(TagList),
}).pipe(T.all(T.Http({ method: "POST", uri: "/v1/email/configuration-sets" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateConfigurationSetRequest",
});
export const CreateConfigurationSetResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "CreateConfigurationSetResponse",
});
export const EventType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const EventTypes = /*@__PURE__*/ /*#__PURE__*/ S.Array(EventType);
export const KinesisFirehoseDestination = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ IamRoleArn: S.String, DeliveryStreamArn: S.String })).annotate({
    identifier: "KinesisFirehoseDestination",
});
export const DimensionValueSource = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CloudWatchDimensionConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DimensionName: S.String,
    DimensionValueSource: DimensionValueSource,
    DefaultDimensionValue: S.String,
})).annotate({
    identifier: "CloudWatchDimensionConfiguration",
});
export const CloudWatchDimensionConfigurations = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(CloudWatchDimensionConfiguration);
export const CloudWatchDestination = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DimensionConfigurations: CloudWatchDimensionConfigurations })).annotate({
    identifier: "CloudWatchDestination",
});
export const SnsDestination = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ TopicArn: S.String })).annotate({ identifier: "SnsDestination" });
export const PinpointDestination = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ApplicationArn: S.optional(S.String) })).annotate({
    identifier: "PinpointDestination",
});
export const EventDestinationDefinition = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Enabled: S.optional(S.Boolean),
    MatchingEventTypes: S.optional(EventTypes),
    KinesisFirehoseDestination: S.optional(KinesisFirehoseDestination),
    CloudWatchDestination: S.optional(CloudWatchDestination),
    SnsDestination: S.optional(SnsDestination),
    PinpointDestination: S.optional(PinpointDestination),
})).annotate({
    identifier: "EventDestinationDefinition",
});
export const CreateConfigurationSetEventDestinationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSetName: S.String.pipe(T.HttpLabel("ConfigurationSetName")),
    EventDestinationName: S.String,
    EventDestination: EventDestinationDefinition,
}).pipe(T.all(T.Http({
    method: "POST",
    uri: "/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateConfigurationSetEventDestinationRequest",
});
export const CreateConfigurationSetEventDestinationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "CreateConfigurationSetEventDestinationResponse",
});
export const CreateDedicatedIpPoolRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ PoolName: S.String, Tags: S.optional(TagList) }).pipe(T.all(T.Http({ method: "POST", uri: "/v1/email/dedicated-ip-pools" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateDedicatedIpPoolRequest",
});
export const CreateDedicatedIpPoolResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "CreateDedicatedIpPoolResponse",
});
export const Content = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Data: S.String, Charset: S.optional(S.String) })).annotate({ identifier: "Content" });
export const Body = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Text: S.optional(Content), Html: S.optional(Content) })).annotate({ identifier: "Body" });
export const Message = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Subject: Content, Body: Body })).annotate({ identifier: "Message" });
export const RawMessage = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Data: T.Blob })).annotate({ identifier: "RawMessage" });
export const Template = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    TemplateArn: S.optional(S.String),
    TemplateData: S.optional(S.String),
})).annotate({ identifier: "Template" });
export const EmailContent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Simple: S.optional(Message),
    Raw: S.optional(RawMessage),
    Template: S.optional(Template),
})).annotate({ identifier: "EmailContent" });
export const CreateDeliverabilityTestReportRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReportName: S.optional(S.String),
    FromEmailAddress: S.String,
    Content: EmailContent,
    Tags: S.optional(TagList),
}).pipe(T.all(T.Http({
    method: "POST",
    uri: "/v1/email/deliverability-dashboard/test",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateDeliverabilityTestReportRequest",
});
export const DeliverabilityTestStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CreateDeliverabilityTestReportResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReportId: S.String,
    DeliverabilityTestStatus: DeliverabilityTestStatus,
})).annotate({
    identifier: "CreateDeliverabilityTestReportResponse",
});
export const CreateEmailIdentityRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EmailIdentity: S.String, Tags: S.optional(TagList) }).pipe(T.all(T.Http({ method: "POST", uri: "/v1/email/identities" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateEmailIdentityRequest",
});
export const IdentityType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DkimStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DnsTokenList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const DkimAttributes = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SigningEnabled: S.optional(S.Boolean),
    Status: S.optional(DkimStatus),
    Tokens: S.optional(DnsTokenList),
})).annotate({ identifier: "DkimAttributes" });
export const CreateEmailIdentityResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    IdentityType: S.optional(IdentityType),
    VerifiedForSendingStatus: S.optional(S.Boolean),
    DkimAttributes: S.optional(DkimAttributes),
})).annotate({
    identifier: "CreateEmailIdentityResponse",
});
export const DeleteConfigurationSetRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSetName: S.String.pipe(T.HttpLabel("ConfigurationSetName")),
}).pipe(T.all(T.Http({
    method: "DELETE",
    uri: "/v1/email/configuration-sets/{ConfigurationSetName}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteConfigurationSetRequest",
});
export const DeleteConfigurationSetResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteConfigurationSetResponse",
});
export const DeleteConfigurationSetEventDestinationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSetName: S.String.pipe(T.HttpLabel("ConfigurationSetName")),
    EventDestinationName: S.String.pipe(T.HttpLabel("EventDestinationName")),
}).pipe(T.all(T.Http({
    method: "DELETE",
    uri: "/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteConfigurationSetEventDestinationRequest",
});
export const DeleteConfigurationSetEventDestinationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteConfigurationSetEventDestinationResponse",
});
export const DeleteDedicatedIpPoolRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ PoolName: S.String.pipe(T.HttpLabel("PoolName")) }).pipe(T.all(T.Http({
    method: "DELETE",
    uri: "/v1/email/dedicated-ip-pools/{PoolName}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteDedicatedIpPoolRequest",
});
export const DeleteDedicatedIpPoolResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteDedicatedIpPoolResponse",
});
export const DeleteEmailIdentityRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EmailIdentity: S.String.pipe(T.HttpLabel("EmailIdentity")),
}).pipe(T.all(T.Http({
    method: "DELETE",
    uri: "/v1/email/identities/{EmailIdentity}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteEmailIdentityRequest",
});
export const DeleteEmailIdentityResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteEmailIdentityResponse",
});
export const GetAccountRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(T.all(T.Http({ method: "GET", uri: "/v1/email/account" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetAccountRequest",
});
export const SendQuota = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Max24HourSend: S.optional(S.Number),
    MaxSendRate: S.optional(S.Number),
    SentLast24Hours: S.optional(S.Number),
})).annotate({ identifier: "SendQuota" });
export const GetAccountResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SendQuota: S.optional(SendQuota),
    SendingEnabled: S.optional(S.Boolean),
    DedicatedIpAutoWarmupEnabled: S.optional(S.Boolean),
    EnforcementStatus: S.optional(S.String),
    ProductionAccessEnabled: S.optional(S.Boolean),
})).annotate({
    identifier: "GetAccountResponse",
});
export const BlacklistItemNames = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const GetBlacklistReportsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BlacklistItemNames: BlacklistItemNames.pipe(T.HttpQuery("BlacklistItemNames")),
}).pipe(T.all(T.Http({
    method: "GET",
    uri: "/v1/email/deliverability-dashboard/blacklist-report",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetBlacklistReportsRequest",
});
export const BlacklistEntry = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    RblName: S.optional(S.String),
    ListingTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Description: S.optional(S.String),
})).annotate({ identifier: "BlacklistEntry" });
export const BlacklistEntries = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(BlacklistEntry);
export const BlacklistReport = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, BlacklistEntries.pipe(S.optional));
export const GetBlacklistReportsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ BlacklistReport: BlacklistReport })).annotate({
    identifier: "GetBlacklistReportsResponse",
});
export const GetConfigurationSetRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSetName: S.String.pipe(T.HttpLabel("ConfigurationSetName")),
}).pipe(T.all(T.Http({
    method: "GET",
    uri: "/v1/email/configuration-sets/{ConfigurationSetName}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetConfigurationSetRequest",
});
export const GetConfigurationSetResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSetName: S.optional(S.String),
    TrackingOptions: S.optional(TrackingOptions),
    DeliveryOptions: S.optional(DeliveryOptions),
    ReputationOptions: S.optional(ReputationOptions),
    SendingOptions: S.optional(SendingOptions),
    Tags: S.optional(TagList),
})).annotate({
    identifier: "GetConfigurationSetResponse",
});
export const GetConfigurationSetEventDestinationsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSetName: S.String.pipe(T.HttpLabel("ConfigurationSetName")),
}).pipe(T.all(T.Http({
    method: "GET",
    uri: "/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetConfigurationSetEventDestinationsRequest",
});
export const EventDestination = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String,
    Enabled: S.optional(S.Boolean),
    MatchingEventTypes: EventTypes,
    KinesisFirehoseDestination: S.optional(KinesisFirehoseDestination),
    CloudWatchDestination: S.optional(CloudWatchDestination),
    SnsDestination: S.optional(SnsDestination),
    PinpointDestination: S.optional(PinpointDestination),
})).annotate({
    identifier: "EventDestination",
});
export const EventDestinations = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(EventDestination);
export const GetConfigurationSetEventDestinationsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EventDestinations: S.optional(EventDestinations) })).annotate({
    identifier: "GetConfigurationSetEventDestinationsResponse",
});
export const GetDedicatedIpRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Ip: S.String.pipe(T.HttpLabel("Ip")) }).pipe(T.all(T.Http({ method: "GET", uri: "/v1/email/dedicated-ips/{Ip}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetDedicatedIpRequest",
});
export const WarmupStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DedicatedIp = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Ip: S.String,
    WarmupStatus: WarmupStatus,
    WarmupPercentage: S.Number,
    PoolName: S.optional(S.String),
})).annotate({ identifier: "DedicatedIp" });
export const GetDedicatedIpResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DedicatedIp: S.optional(DedicatedIp) })).annotate({
    identifier: "GetDedicatedIpResponse",
});
export const GetDedicatedIpsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PoolName: S.optional(S.String).pipe(T.HttpQuery("PoolName")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("NextToken")),
    PageSize: S.optional(S.Number).pipe(T.HttpQuery("PageSize")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/v1/email/dedicated-ips" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetDedicatedIpsRequest",
});
export const DedicatedIpList = /*@__PURE__*/ /*#__PURE__*/ S.Array(DedicatedIp);
export const GetDedicatedIpsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DedicatedIps: S.optional(DedicatedIpList),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "GetDedicatedIpsResponse",
});
export const GetDeliverabilityDashboardOptionsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(T.all(T.Http({ method: "GET", uri: "/v1/email/deliverability-dashboard" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetDeliverabilityDashboardOptionsRequest",
});
export const DeliverabilityDashboardAccountStatus = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const IspNameList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const InboxPlacementTrackingOption = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Global: S.optional(S.Boolean),
    TrackedIsps: S.optional(IspNameList),
})).annotate({
    identifier: "InboxPlacementTrackingOption",
});
export const DomainDeliverabilityTrackingOption = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Domain: S.optional(S.String),
    SubscriptionStartDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    InboxPlacementTrackingOption: S.optional(InboxPlacementTrackingOption),
})).annotate({
    identifier: "DomainDeliverabilityTrackingOption",
});
export const DomainDeliverabilityTrackingOptions = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(DomainDeliverabilityTrackingOption);
export const GetDeliverabilityDashboardOptionsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DashboardEnabled: S.Boolean,
    SubscriptionExpiryDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    AccountStatus: S.optional(DeliverabilityDashboardAccountStatus),
    ActiveSubscribedDomains: S.optional(DomainDeliverabilityTrackingOptions),
    PendingExpirationSubscribedDomains: S.optional(DomainDeliverabilityTrackingOptions),
})).annotate({
    identifier: "GetDeliverabilityDashboardOptionsResponse",
});
export const GetDeliverabilityTestReportRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ReportId: S.String.pipe(T.HttpLabel("ReportId")) }).pipe(T.all(T.Http({
    method: "GET",
    uri: "/v1/email/deliverability-dashboard/test-reports/{ReportId}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetDeliverabilityTestReportRequest",
});
export const DeliverabilityTestReport = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReportId: S.optional(S.String),
    ReportName: S.optional(S.String),
    Subject: S.optional(S.String),
    FromEmailAddress: S.optional(S.String),
    CreateDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    DeliverabilityTestStatus: S.optional(DeliverabilityTestStatus),
})).annotate({
    identifier: "DeliverabilityTestReport",
});
export const PlacementStatistics = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    InboxPercentage: S.optional(S.Number),
    SpamPercentage: S.optional(S.Number),
    MissingPercentage: S.optional(S.Number),
    SpfPercentage: S.optional(S.Number),
    DkimPercentage: S.optional(S.Number),
})).annotate({
    identifier: "PlacementStatistics",
});
export const IspPlacement = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    IspName: S.optional(S.String),
    PlacementStatistics: S.optional(PlacementStatistics),
})).annotate({ identifier: "IspPlacement" });
export const IspPlacements = /*@__PURE__*/ /*#__PURE__*/ S.Array(IspPlacement);
export const GetDeliverabilityTestReportResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DeliverabilityTestReport: DeliverabilityTestReport,
    OverallPlacement: PlacementStatistics,
    IspPlacements: IspPlacements,
    Message: S.optional(S.String),
    Tags: S.optional(TagList),
})).annotate({
    identifier: "GetDeliverabilityTestReportResponse",
});
export const GetDomainDeliverabilityCampaignRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ CampaignId: S.String.pipe(T.HttpLabel("CampaignId")) }).pipe(T.all(T.Http({
    method: "GET",
    uri: "/v1/email/deliverability-dashboard/campaigns/{CampaignId}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetDomainDeliverabilityCampaignRequest",
});
export const IpList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const Esps = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const DomainDeliverabilityCampaign = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CampaignId: S.optional(S.String),
    ImageUrl: S.optional(S.String),
    Subject: S.optional(S.String),
    FromAddress: S.optional(S.String),
    SendingIps: S.optional(IpList),
    FirstSeenDateTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastSeenDateTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    InboxCount: S.optional(S.Number),
    SpamCount: S.optional(S.Number),
    ReadRate: S.optional(S.Number),
    DeleteRate: S.optional(S.Number),
    ReadDeleteRate: S.optional(S.Number),
    ProjectedVolume: S.optional(S.Number),
    Esps: S.optional(Esps),
})).annotate({
    identifier: "DomainDeliverabilityCampaign",
});
export const GetDomainDeliverabilityCampaignResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainDeliverabilityCampaign: DomainDeliverabilityCampaign })).annotate({
    identifier: "GetDomainDeliverabilityCampaignResponse",
});
export const GetDomainStatisticsReportRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Domain: S.String.pipe(T.HttpLabel("Domain")),
    StartDate: S.Date.pipe(T.TimestampFormat("epoch-seconds")).pipe(T.HttpQuery("StartDate")),
    EndDate: S.Date.pipe(T.TimestampFormat("epoch-seconds")).pipe(T.HttpQuery("EndDate")),
}).pipe(T.all(T.Http({
    method: "GET",
    uri: "/v1/email/deliverability-dashboard/statistics-report/{Domain}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetDomainStatisticsReportRequest",
});
export const VolumeStatistics = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    InboxRawCount: S.optional(S.Number),
    SpamRawCount: S.optional(S.Number),
    ProjectedInbox: S.optional(S.Number),
    ProjectedSpam: S.optional(S.Number),
})).annotate({
    identifier: "VolumeStatistics",
});
export const DomainIspPlacement = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    IspName: S.optional(S.String),
    InboxRawCount: S.optional(S.Number),
    SpamRawCount: S.optional(S.Number),
    InboxPercentage: S.optional(S.Number),
    SpamPercentage: S.optional(S.Number),
})).annotate({
    identifier: "DomainIspPlacement",
});
export const DomainIspPlacements = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(DomainIspPlacement);
export const OverallVolume = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    VolumeStatistics: S.optional(VolumeStatistics),
    ReadRatePercent: S.optional(S.Number),
    DomainIspPlacements: S.optional(DomainIspPlacements),
})).annotate({ identifier: "OverallVolume" });
export const DailyVolume = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    StartDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    VolumeStatistics: S.optional(VolumeStatistics),
    DomainIspPlacements: S.optional(DomainIspPlacements),
})).annotate({ identifier: "DailyVolume" });
export const DailyVolumes = /*@__PURE__*/ /*#__PURE__*/ S.Array(DailyVolume);
export const GetDomainStatisticsReportResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ OverallVolume: OverallVolume, DailyVolumes: DailyVolumes })).annotate({
    identifier: "GetDomainStatisticsReportResponse",
});
export const GetEmailIdentityRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EmailIdentity: S.String.pipe(T.HttpLabel("EmailIdentity")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/v1/email/identities/{EmailIdentity}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetEmailIdentityRequest",
});
export const MailFromDomainStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const BehaviorOnMxFailure = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const MailFromAttributes = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MailFromDomain: S.String,
    MailFromDomainStatus: MailFromDomainStatus,
    BehaviorOnMxFailure: BehaviorOnMxFailure,
})).annotate({
    identifier: "MailFromAttributes",
});
export const GetEmailIdentityResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    IdentityType: S.optional(IdentityType),
    FeedbackForwardingStatus: S.optional(S.Boolean),
    VerifiedForSendingStatus: S.optional(S.Boolean),
    DkimAttributes: S.optional(DkimAttributes),
    MailFromAttributes: S.optional(MailFromAttributes),
    Tags: S.optional(TagList),
})).annotate({
    identifier: "GetEmailIdentityResponse",
});
export const ListConfigurationSetsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String).pipe(T.HttpQuery("NextToken")),
    PageSize: S.optional(S.Number).pipe(T.HttpQuery("PageSize")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/v1/email/configuration-sets" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListConfigurationSetsRequest",
});
export const ConfigurationSetNameList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const ListConfigurationSetsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSets: S.optional(ConfigurationSetNameList),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListConfigurationSetsResponse",
});
export const ListDedicatedIpPoolsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String).pipe(T.HttpQuery("NextToken")),
    PageSize: S.optional(S.Number).pipe(T.HttpQuery("PageSize")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/v1/email/dedicated-ip-pools" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListDedicatedIpPoolsRequest",
});
export const ListOfDedicatedIpPools = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const ListDedicatedIpPoolsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DedicatedIpPools: S.optional(ListOfDedicatedIpPools),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListDedicatedIpPoolsResponse",
});
export const ListDeliverabilityTestReportsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String).pipe(T.HttpQuery("NextToken")),
    PageSize: S.optional(S.Number).pipe(T.HttpQuery("PageSize")),
}).pipe(T.all(T.Http({
    method: "GET",
    uri: "/v1/email/deliverability-dashboard/test-reports",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListDeliverabilityTestReportsRequest",
});
export const DeliverabilityTestReports = /*@__PURE__*/ /*#__PURE__*/ S.Array(DeliverabilityTestReport);
export const ListDeliverabilityTestReportsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DeliverabilityTestReports: DeliverabilityTestReports,
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListDeliverabilityTestReportsResponse",
});
export const ListDomainDeliverabilityCampaignsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    StartDate: S.Date.pipe(T.TimestampFormat("epoch-seconds")).pipe(T.HttpQuery("StartDate")),
    EndDate: S.Date.pipe(T.TimestampFormat("epoch-seconds")).pipe(T.HttpQuery("EndDate")),
    SubscribedDomain: S.String.pipe(T.HttpLabel("SubscribedDomain")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("NextToken")),
    PageSize: S.optional(S.Number).pipe(T.HttpQuery("PageSize")),
}).pipe(T.all(T.Http({
    method: "GET",
    uri: "/v1/email/deliverability-dashboard/domains/{SubscribedDomain}/campaigns",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListDomainDeliverabilityCampaignsRequest",
});
export const DomainDeliverabilityCampaignList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(DomainDeliverabilityCampaign);
export const ListDomainDeliverabilityCampaignsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainDeliverabilityCampaigns: DomainDeliverabilityCampaignList,
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListDomainDeliverabilityCampaignsResponse",
});
export const ListEmailIdentitiesRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String).pipe(T.HttpQuery("NextToken")),
    PageSize: S.optional(S.Number).pipe(T.HttpQuery("PageSize")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/v1/email/identities" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListEmailIdentitiesRequest",
});
export const IdentityInfo = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    IdentityType: S.optional(IdentityType),
    IdentityName: S.optional(S.String),
    SendingEnabled: S.optional(S.Boolean),
})).annotate({ identifier: "IdentityInfo" });
export const IdentityInfoList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(IdentityInfo);
export const ListEmailIdentitiesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EmailIdentities: S.optional(IdentityInfoList),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListEmailIdentitiesResponse",
});
export const ListTagsForResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ResourceArn: S.String.pipe(T.HttpQuery("ResourceArn")) }).pipe(T.all(T.Http({ method: "GET", uri: "/v1/email/tags" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListTagsForResourceRequest",
});
export const ListTagsForResourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Tags: TagList })).annotate({
    identifier: "ListTagsForResourceResponse",
});
export const PutAccountDedicatedIpWarmupAttributesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AutoWarmupEnabled: S.optional(S.Boolean) }).pipe(T.all(T.Http({
    method: "PUT",
    uri: "/v1/email/account/dedicated-ips/warmup",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutAccountDedicatedIpWarmupAttributesRequest",
});
export const PutAccountDedicatedIpWarmupAttributesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "PutAccountDedicatedIpWarmupAttributesResponse",
});
export const PutAccountSendingAttributesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ SendingEnabled: S.optional(S.Boolean) }).pipe(T.all(T.Http({ method: "PUT", uri: "/v1/email/account/sending" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutAccountSendingAttributesRequest",
});
export const PutAccountSendingAttributesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "PutAccountSendingAttributesResponse",
});
export const PutConfigurationSetDeliveryOptionsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSetName: S.String.pipe(T.HttpLabel("ConfigurationSetName")),
    TlsPolicy: S.optional(TlsPolicy),
    SendingPoolName: S.optional(S.String),
}).pipe(T.all(T.Http({
    method: "PUT",
    uri: "/v1/email/configuration-sets/{ConfigurationSetName}/delivery-options",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutConfigurationSetDeliveryOptionsRequest",
});
export const PutConfigurationSetDeliveryOptionsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "PutConfigurationSetDeliveryOptionsResponse",
});
export const PutConfigurationSetReputationOptionsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSetName: S.String.pipe(T.HttpLabel("ConfigurationSetName")),
    ReputationMetricsEnabled: S.optional(S.Boolean),
}).pipe(T.all(T.Http({
    method: "PUT",
    uri: "/v1/email/configuration-sets/{ConfigurationSetName}/reputation-options",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutConfigurationSetReputationOptionsRequest",
});
export const PutConfigurationSetReputationOptionsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "PutConfigurationSetReputationOptionsResponse",
});
export const PutConfigurationSetSendingOptionsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSetName: S.String.pipe(T.HttpLabel("ConfigurationSetName")),
    SendingEnabled: S.optional(S.Boolean),
}).pipe(T.all(T.Http({
    method: "PUT",
    uri: "/v1/email/configuration-sets/{ConfigurationSetName}/sending",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutConfigurationSetSendingOptionsRequest",
});
export const PutConfigurationSetSendingOptionsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "PutConfigurationSetSendingOptionsResponse",
});
export const PutConfigurationSetTrackingOptionsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSetName: S.String.pipe(T.HttpLabel("ConfigurationSetName")),
    CustomRedirectDomain: S.optional(S.String),
}).pipe(T.all(T.Http({
    method: "PUT",
    uri: "/v1/email/configuration-sets/{ConfigurationSetName}/tracking-options",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutConfigurationSetTrackingOptionsRequest",
});
export const PutConfigurationSetTrackingOptionsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "PutConfigurationSetTrackingOptionsResponse",
});
export const PutDedicatedIpInPoolRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Ip: S.String.pipe(T.HttpLabel("Ip")),
    DestinationPoolName: S.String,
}).pipe(T.all(T.Http({ method: "PUT", uri: "/v1/email/dedicated-ips/{Ip}/pool" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutDedicatedIpInPoolRequest",
});
export const PutDedicatedIpInPoolResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "PutDedicatedIpInPoolResponse",
});
export const PutDedicatedIpWarmupAttributesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Ip: S.String.pipe(T.HttpLabel("Ip")),
    WarmupPercentage: S.Number,
}).pipe(T.all(T.Http({ method: "PUT", uri: "/v1/email/dedicated-ips/{Ip}/warmup" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutDedicatedIpWarmupAttributesRequest",
});
export const PutDedicatedIpWarmupAttributesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "PutDedicatedIpWarmupAttributesResponse",
});
export const PutDeliverabilityDashboardOptionRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DashboardEnabled: S.Boolean,
    SubscribedDomains: S.optional(DomainDeliverabilityTrackingOptions),
}).pipe(T.all(T.Http({ method: "PUT", uri: "/v1/email/deliverability-dashboard" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutDeliverabilityDashboardOptionRequest",
});
export const PutDeliverabilityDashboardOptionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "PutDeliverabilityDashboardOptionResponse",
});
export const PutEmailIdentityDkimAttributesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EmailIdentity: S.String.pipe(T.HttpLabel("EmailIdentity")),
    SigningEnabled: S.optional(S.Boolean),
}).pipe(T.all(T.Http({
    method: "PUT",
    uri: "/v1/email/identities/{EmailIdentity}/dkim",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutEmailIdentityDkimAttributesRequest",
});
export const PutEmailIdentityDkimAttributesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "PutEmailIdentityDkimAttributesResponse",
});
export const PutEmailIdentityFeedbackAttributesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EmailIdentity: S.String.pipe(T.HttpLabel("EmailIdentity")),
    EmailForwardingEnabled: S.optional(S.Boolean),
}).pipe(T.all(T.Http({
    method: "PUT",
    uri: "/v1/email/identities/{EmailIdentity}/feedback",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutEmailIdentityFeedbackAttributesRequest",
});
export const PutEmailIdentityFeedbackAttributesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "PutEmailIdentityFeedbackAttributesResponse",
});
export const PutEmailIdentityMailFromAttributesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EmailIdentity: S.String.pipe(T.HttpLabel("EmailIdentity")),
    MailFromDomain: S.optional(S.String),
    BehaviorOnMxFailure: S.optional(BehaviorOnMxFailure),
}).pipe(T.all(T.Http({
    method: "PUT",
    uri: "/v1/email/identities/{EmailIdentity}/mail-from",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "PutEmailIdentityMailFromAttributesRequest",
});
export const PutEmailIdentityMailFromAttributesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "PutEmailIdentityMailFromAttributesResponse",
});
export const EmailAddressList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const Destination = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ToAddresses: S.optional(EmailAddressList),
    CcAddresses: S.optional(EmailAddressList),
    BccAddresses: S.optional(EmailAddressList),
})).annotate({ identifier: "Destination" });
export const MessageTag = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String, Value: S.String })).annotate({ identifier: "MessageTag" });
export const MessageTagList = /*@__PURE__*/ /*#__PURE__*/ S.Array(MessageTag);
export const SendEmailRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FromEmailAddress: S.optional(S.String),
    Destination: Destination,
    ReplyToAddresses: S.optional(EmailAddressList),
    FeedbackForwardingEmailAddress: S.optional(S.String),
    Content: EmailContent,
    EmailTags: S.optional(MessageTagList),
    ConfigurationSetName: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/v1/email/outbound-emails" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "SendEmailRequest",
});
export const SendEmailResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ MessageId: S.optional(S.String) })).annotate({
    identifier: "SendEmailResponse",
});
export const TagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ResourceArn: S.String, Tags: TagList }).pipe(T.all(T.Http({ method: "POST", uri: "/v1/email/tags" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "TagResourceRequest",
});
export const TagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "TagResourceResponse",
});
export const TagKeyList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const UntagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ResourceArn: S.String.pipe(T.HttpQuery("ResourceArn")),
    TagKeys: TagKeyList.pipe(T.HttpQuery("TagKeys")),
}).pipe(T.all(T.Http({ method: "DELETE", uri: "/v1/email/tags" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UntagResourceRequest",
});
export const UntagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "UntagResourceResponse",
});
export const UpdateConfigurationSetEventDestinationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ConfigurationSetName: S.String.pipe(T.HttpLabel("ConfigurationSetName")),
    EventDestinationName: S.String.pipe(T.HttpLabel("EventDestinationName")),
    EventDestination: EventDestinationDefinition,
}).pipe(T.all(T.Http({
    method: "PUT",
    uri: "/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateConfigurationSetEventDestinationRequest",
});
export const UpdateConfigurationSetEventDestinationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "UpdateConfigurationSetEventDestinationResponse",
});
//# Errors
export class AlreadyExistsException extends S.TaggedErrorClass()("AlreadyExistsException", { message: S.optional(S.String) }).pipe(C.withBadRequestError, C.withAlreadyExistsError) {
}
export class BadRequestException extends S.TaggedErrorClass()("BadRequestException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class ConcurrentModificationException extends S.TaggedErrorClass()("ConcurrentModificationException", { message: S.optional(S.String) }).pipe(C.withServerError) {
}
export class LimitExceededException extends S.TaggedErrorClass()("LimitExceededException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class NotFoundException extends S.TaggedErrorClass()("NotFoundException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class TooManyRequestsException extends S.TaggedErrorClass()("TooManyRequestsException", { message: S.optional(S.String) }).pipe(C.withThrottlingError) {
}
export class AccountSuspendedException extends S.TaggedErrorClass()("AccountSuspendedException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class MailFromDomainNotVerifiedException extends S.TaggedErrorClass()("MailFromDomainNotVerifiedException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class MessageRejected extends S.TaggedErrorClass()("MessageRejected", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class SendingPausedException extends S.TaggedErrorClass()("SendingPausedException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
/**
 * Create a configuration set. *Configuration sets* are groups of
 * rules that you can apply to the emails you send using Amazon Pinpoint. You apply a configuration
 * set to an email by including a reference to the configuration set in the headers of the
 * email. When you apply a configuration set to an email, all of the rules in that
 * configuration set are applied to the email.
 */
export const createConfigurationSet = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateConfigurationSetRequest,
    output: CreateConfigurationSetResponse,
    errors: [
        AlreadyExistsException,
        BadRequestException,
        ConcurrentModificationException,
        LimitExceededException,
        NotFoundException,
        TooManyRequestsException,
    ],
}));
/**
 * Create an event destination. In Amazon Pinpoint, *events* include message
 * sends, deliveries, opens, clicks, bounces, and complaints. Event
 * destinations are places that you can send information about these events
 * to. For example, you can send event data to Amazon SNS to receive notifications when you
 * receive bounces or complaints, or you can use Amazon Kinesis Data Firehose to stream data to Amazon S3 for long-term
 * storage.
 *
 * A single configuration set can include more than one event destination.
 */
export const createConfigurationSetEventDestination = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateConfigurationSetEventDestinationRequest,
    output: CreateConfigurationSetEventDestinationResponse,
    errors: [
        AlreadyExistsException,
        BadRequestException,
        LimitExceededException,
        NotFoundException,
        TooManyRequestsException,
    ],
}));
/**
 * Create a new pool of dedicated IP addresses. A pool can include one or more dedicated
 * IP addresses that are associated with your Amazon Pinpoint account. You can associate a pool with
 * a configuration set. When you send an email that uses that configuration set, Amazon Pinpoint
 * sends it using only the IP addresses in the associated pool.
 */
export const createDedicatedIpPool = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateDedicatedIpPoolRequest,
    output: CreateDedicatedIpPoolResponse,
    errors: [
        AlreadyExistsException,
        BadRequestException,
        ConcurrentModificationException,
        LimitExceededException,
        TooManyRequestsException,
    ],
}));
/**
 * Create a new predictive inbox placement test. Predictive inbox placement tests can help you predict how your messages will be handled
 * by various email providers around the world. When you perform a predictive inbox placement test, you provide a
 * sample message that contains the content that you plan to send to your customers. Amazon Pinpoint
 * then sends that message to special email addresses spread across several major email
 * providers. After about 24 hours, the test is complete, and you can use the
 * `GetDeliverabilityTestReport` operation to view the results of the
 * test.
 */
export const createDeliverabilityTestReport = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateDeliverabilityTestReportRequest,
    output: CreateDeliverabilityTestReportResponse,
    errors: [
        AccountSuspendedException,
        BadRequestException,
        ConcurrentModificationException,
        LimitExceededException,
        MailFromDomainNotVerifiedException,
        MessageRejected,
        NotFoundException,
        SendingPausedException,
        TooManyRequestsException,
    ],
}));
/**
 * Verifies an email identity for use with Amazon Pinpoint. In Amazon Pinpoint, an identity is an email
 * address or domain that you use when you send email. Before you can use an identity to
 * send email with Amazon Pinpoint, you first have to verify it. By verifying an address, you
 * demonstrate that you're the owner of the address, and that you've given Amazon Pinpoint permission
 * to send email from the address.
 *
 * When you verify an email address, Amazon Pinpoint sends an email to the address. Your email
 * address is verified as soon as you follow the link in the verification email.
 *
 * When you verify a domain, this operation provides a set of DKIM tokens, which you can
 * convert into CNAME tokens. You add these CNAME tokens to the DNS configuration for your
 * domain. Your domain is verified when Amazon Pinpoint detects these records in the DNS
 * configuration for your domain. It usually takes around 72 hours to complete the domain
 * verification process.
 */
export const createEmailIdentity = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateEmailIdentityRequest,
    output: CreateEmailIdentityResponse,
    errors: [
        BadRequestException,
        ConcurrentModificationException,
        LimitExceededException,
        TooManyRequestsException,
    ],
}));
/**
 * Delete an existing configuration set.
 *
 * In Amazon Pinpoint, *configuration sets* are groups of rules that you can
 * apply to the emails you send. You apply a configuration set to an email by including a
 * reference to the configuration set in the headers of the email. When you apply a
 * configuration set to an email, all of the rules in that configuration set are applied to
 * the email.
 */
export const deleteConfigurationSet = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteConfigurationSetRequest,
    output: DeleteConfigurationSetResponse,
    errors: [
        BadRequestException,
        ConcurrentModificationException,
        NotFoundException,
        TooManyRequestsException,
    ],
}));
/**
 * Delete an event destination.
 *
 * In Amazon Pinpoint, *events* include message sends, deliveries, opens,
 * clicks, bounces, and complaints. *Event destinations* are places that
 * you can send information about these events to. For example, you can send event data to
 * Amazon SNS to receive notifications when you receive bounces or complaints, or you can use
 * Amazon Kinesis Data Firehose to stream data to Amazon S3 for long-term storage.
 */
export const deleteConfigurationSetEventDestination = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteConfigurationSetEventDestinationRequest,
    output: DeleteConfigurationSetEventDestinationResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Delete a dedicated IP pool.
 */
export const deleteDedicatedIpPool = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteDedicatedIpPoolRequest,
    output: DeleteDedicatedIpPoolResponse,
    errors: [
        BadRequestException,
        ConcurrentModificationException,
        NotFoundException,
        TooManyRequestsException,
    ],
}));
/**
 * Deletes an email identity that you previously verified for use with Amazon Pinpoint. An identity
 * can be either an email address or a domain name.
 */
export const deleteEmailIdentity = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteEmailIdentityRequest,
    output: DeleteEmailIdentityResponse,
    errors: [
        BadRequestException,
        ConcurrentModificationException,
        NotFoundException,
        TooManyRequestsException,
    ],
}));
/**
 * Obtain information about the email-sending status and capabilities of your Amazon Pinpoint
 * account in the current AWS Region.
 */
export const getAccount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetAccountRequest,
    output: GetAccountResponse,
    errors: [BadRequestException, TooManyRequestsException],
}));
/**
 * Retrieve a list of the blacklists that your dedicated IP addresses appear on.
 */
export const getBlacklistReports = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetBlacklistReportsRequest,
    output: GetBlacklistReportsResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Get information about an existing configuration set, including the dedicated IP pool
 * that it's associated with, whether or not it's enabled for sending email, and
 * more.
 *
 * In Amazon Pinpoint, *configuration sets* are groups of rules that you can
 * apply to the emails you send. You apply a configuration set to an email by including a
 * reference to the configuration set in the headers of the email. When you apply a
 * configuration set to an email, all of the rules in that configuration set are applied to
 * the email.
 */
export const getConfigurationSet = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetConfigurationSetRequest,
    output: GetConfigurationSetResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Retrieve a list of event destinations that are associated with a configuration
 * set.
 *
 * In Amazon Pinpoint, *events* include message sends, deliveries, opens,
 * clicks, bounces, and complaints. *Event destinations* are places that
 * you can send information about these events to. For example, you can send event data to
 * Amazon SNS to receive notifications when you receive bounces or complaints, or you can use
 * Amazon Kinesis Data Firehose to stream data to Amazon S3 for long-term storage.
 */
export const getConfigurationSetEventDestinations = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetConfigurationSetEventDestinationsRequest,
    output: GetConfigurationSetEventDestinationsResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Get information about a dedicated IP address, including the name of the dedicated IP
 * pool that it's associated with, as well information about the automatic warm-up process
 * for the address.
 */
export const getDedicatedIp = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetDedicatedIpRequest,
    output: GetDedicatedIpResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * List the dedicated IP addresses that are associated with your Amazon Pinpoint
 * account.
 */
export const getDedicatedIps = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: GetDedicatedIpsRequest,
    output: GetDedicatedIpsResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "PageSize",
    },
}));
/**
 * Retrieve information about the status of the Deliverability dashboard for your Amazon Pinpoint account.
 * When the Deliverability dashboard is enabled, you gain access to reputation, deliverability, and
 * other metrics for the domains that you use to send email using Amazon Pinpoint. You also gain the
 * ability to perform predictive inbox placement tests.
 *
 * When you use the Deliverability dashboard, you pay a monthly subscription charge, in addition
 * to any other fees that you accrue by using Amazon Pinpoint. For more information about the
 * features and cost of a Deliverability dashboard subscription, see Amazon Pinpoint Pricing.
 */
export const getDeliverabilityDashboardOptions = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetDeliverabilityDashboardOptionsRequest,
    output: GetDeliverabilityDashboardOptionsResponse,
    errors: [
        BadRequestException,
        LimitExceededException,
        TooManyRequestsException,
    ],
}));
/**
 * Retrieve the results of a predictive inbox placement test.
 */
export const getDeliverabilityTestReport = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetDeliverabilityTestReportRequest,
    output: GetDeliverabilityTestReportResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Retrieve all the deliverability data for a specific campaign. This data is available
 * for a campaign only if the campaign sent email by using a domain that the
 * Deliverability dashboard is enabled for (`PutDeliverabilityDashboardOption`
 * operation).
 */
export const getDomainDeliverabilityCampaign = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetDomainDeliverabilityCampaignRequest,
    output: GetDomainDeliverabilityCampaignResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Retrieve inbox placement and engagement rates for the domains that you use to send
 * email.
 */
export const getDomainStatisticsReport = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetDomainStatisticsReportRequest,
    output: GetDomainStatisticsReportResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Provides information about a specific identity associated with your Amazon Pinpoint account,
 * including the identity's verification status, its DKIM authentication status, and its
 * custom Mail-From settings.
 */
export const getEmailIdentity = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetEmailIdentityRequest,
    output: GetEmailIdentityResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * List all of the configuration sets associated with your Amazon Pinpoint account in the current
 * region.
 *
 * In Amazon Pinpoint, *configuration sets* are groups of rules that you can
 * apply to the emails you send. You apply a configuration set to an email by including a
 * reference to the configuration set in the headers of the email. When you apply a
 * configuration set to an email, all of the rules in that configuration set are applied to
 * the email.
 */
export const listConfigurationSets = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListConfigurationSetsRequest,
    output: ListConfigurationSetsResponse,
    errors: [BadRequestException, TooManyRequestsException],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "PageSize",
    },
}));
/**
 * List all of the dedicated IP pools that exist in your Amazon Pinpoint account in the current
 * AWS Region.
 */
export const listDedicatedIpPools = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListDedicatedIpPoolsRequest,
    output: ListDedicatedIpPoolsResponse,
    errors: [BadRequestException, TooManyRequestsException],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "PageSize",
    },
}));
/**
 * Show a list of the predictive inbox placement tests that you've performed, regardless of their statuses. For
 * predictive inbox placement tests that are complete, you can use the `GetDeliverabilityTestReport`
 * operation to view the results.
 */
export const listDeliverabilityTestReports = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListDeliverabilityTestReportsRequest,
    output: ListDeliverabilityTestReportsResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "PageSize",
    },
}));
/**
 * Retrieve deliverability data for all the campaigns that used a specific domain to send
 * email during a specified time range. This data is available for a domain only if you
 * enabled the Deliverability dashboard (`PutDeliverabilityDashboardOption` operation)
 * for the domain.
 */
export const listDomainDeliverabilityCampaigns = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListDomainDeliverabilityCampaignsRequest,
    output: ListDomainDeliverabilityCampaignsResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "PageSize",
    },
}));
/**
 * Returns a list of all of the email identities that are associated with your Amazon Pinpoint
 * account. An identity can be either an email address or a domain. This operation returns
 * identities that are verified as well as those that aren't.
 */
export const listEmailIdentities = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListEmailIdentitiesRequest,
    output: ListEmailIdentitiesResponse,
    errors: [BadRequestException, TooManyRequestsException],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "PageSize",
    },
}));
/**
 * Retrieve a list of the tags (keys and values) that are associated with a specified
 * resource. A *tag* is a label that you optionally define and associate
 * with a resource in Amazon Pinpoint. Each tag consists of a required tag
 * key and an optional associated *tag value*. A tag key
 * is a general label that acts as a category for more specific tag values. A tag value
 * acts as a descriptor within a tag key.
 */
export const listTagsForResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListTagsForResourceRequest,
    output: ListTagsForResourceResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Enable or disable the automatic warm-up feature for dedicated IP addresses.
 */
export const putAccountDedicatedIpWarmupAttributes = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutAccountDedicatedIpWarmupAttributesRequest,
    output: PutAccountDedicatedIpWarmupAttributesResponse,
    errors: [BadRequestException, TooManyRequestsException],
}));
/**
 * Enable or disable the ability of your account to send email.
 */
export const putAccountSendingAttributes = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutAccountSendingAttributesRequest,
    output: PutAccountSendingAttributesResponse,
    errors: [BadRequestException, TooManyRequestsException],
}));
/**
 * Associate a configuration set with a dedicated IP pool. You can use dedicated IP pools
 * to create groups of dedicated IP addresses for sending specific types of email.
 */
export const putConfigurationSetDeliveryOptions = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutConfigurationSetDeliveryOptionsRequest,
    output: PutConfigurationSetDeliveryOptionsResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Enable or disable collection of reputation metrics for emails that you send using a
 * particular configuration set in a specific AWS Region.
 */
export const putConfigurationSetReputationOptions = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutConfigurationSetReputationOptionsRequest,
    output: PutConfigurationSetReputationOptionsResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Enable or disable email sending for messages that use a particular configuration set
 * in a specific AWS Region.
 */
export const putConfigurationSetSendingOptions = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutConfigurationSetSendingOptionsRequest,
    output: PutConfigurationSetSendingOptionsResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Specify a custom domain to use for open and click tracking elements in email that you
 * send using Amazon Pinpoint.
 */
export const putConfigurationSetTrackingOptions = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutConfigurationSetTrackingOptionsRequest,
    output: PutConfigurationSetTrackingOptionsResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Move a dedicated IP address to an existing dedicated IP pool.
 *
 * The dedicated IP address that you specify must already exist, and must be
 * associated with your Amazon Pinpoint account.
 *
 * The dedicated IP pool you specify must already exist. You can create a new pool by
 * using the `CreateDedicatedIpPool` operation.
 */
export const putDedicatedIpInPool = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutDedicatedIpInPoolRequest,
    output: PutDedicatedIpInPoolResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 *
 */
export const putDedicatedIpWarmupAttributes = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutDedicatedIpWarmupAttributesRequest,
    output: PutDedicatedIpWarmupAttributesResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Enable or disable the Deliverability dashboard for your Amazon Pinpoint account. When you enable the
 * Deliverability dashboard, you gain access to reputation, deliverability, and other metrics for
 * the domains that you use to send email using Amazon Pinpoint. You also gain the ability to perform
 * predictive inbox placement tests.
 *
 * When you use the Deliverability dashboard, you pay a monthly subscription charge, in addition
 * to any other fees that you accrue by using Amazon Pinpoint. For more information about the
 * features and cost of a Deliverability dashboard subscription, see Amazon Pinpoint Pricing.
 */
export const putDeliverabilityDashboardOption = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutDeliverabilityDashboardOptionRequest,
    output: PutDeliverabilityDashboardOptionResponse,
    errors: [
        AlreadyExistsException,
        BadRequestException,
        LimitExceededException,
        NotFoundException,
        TooManyRequestsException,
    ],
}));
/**
 * Used to enable or disable DKIM authentication for an email identity.
 */
export const putEmailIdentityDkimAttributes = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutEmailIdentityDkimAttributesRequest,
    output: PutEmailIdentityDkimAttributesResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Used to enable or disable feedback forwarding for an identity. This setting determines
 * what happens when an identity is used to send an email that results in a bounce or
 * complaint event.
 *
 * When you enable feedback forwarding, Amazon Pinpoint sends you email notifications when bounce
 * or complaint events occur. Amazon Pinpoint sends this notification to the address that you
 * specified in the Return-Path header of the original email.
 *
 * When you disable feedback forwarding, Amazon Pinpoint sends notifications through other
 * mechanisms, such as by notifying an Amazon SNS topic. You're required to have a method of
 * tracking bounces and complaints. If you haven't set up another mechanism for receiving
 * bounce or complaint notifications, Amazon Pinpoint sends an email notification when these events
 * occur (even if this setting is disabled).
 */
export const putEmailIdentityFeedbackAttributes = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutEmailIdentityFeedbackAttributesRequest,
    output: PutEmailIdentityFeedbackAttributesResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Used to enable or disable the custom Mail-From domain configuration for an email
 * identity.
 */
export const putEmailIdentityMailFromAttributes = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PutEmailIdentityMailFromAttributesRequest,
    output: PutEmailIdentityMailFromAttributesResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
/**
 * Sends an email message. You can use the Amazon Pinpoint Email API to send two types of
 * messages:
 *
 * - **Simple** – A standard email message. When
 * you create this type of message, you specify the sender, the recipient, and the
 * message body, and Amazon Pinpoint assembles the message for you.
 *
 * - **Raw** – A raw, MIME-formatted email
 * message. When you send this type of email, you have to specify all of the
 * message headers, as well as the message body. You can use this message type to
 * send messages that contain attachments. The message that you specify has to be a
 * valid MIME message.
 */
export const sendEmail = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: SendEmailRequest,
    output: SendEmailResponse,
    errors: [
        AccountSuspendedException,
        BadRequestException,
        LimitExceededException,
        MailFromDomainNotVerifiedException,
        MessageRejected,
        NotFoundException,
        SendingPausedException,
        TooManyRequestsException,
    ],
}));
/**
 * Add one or more tags (keys and values) to a specified resource. A
 * *tag* is a label that you optionally define and associate with a
 * resource in Amazon Pinpoint. Tags can help you categorize and manage resources in different ways,
 * such as by purpose, owner, environment, or other criteria. A resource can have as many
 * as 50 tags.
 *
 * Each tag consists of a required *tag key* and an
 * associated *tag value*, both of which you define. A tag key is a
 * general label that acts as a category for more specific tag values. A tag value acts as
 * a descriptor within a tag key.
 */
export const tagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: TagResourceRequest,
    output: TagResourceResponse,
    errors: [
        BadRequestException,
        ConcurrentModificationException,
        NotFoundException,
        TooManyRequestsException,
    ],
}));
/**
 * Remove one or more tags (keys and values) from a specified resource.
 */
export const untagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UntagResourceRequest,
    output: UntagResourceResponse,
    errors: [
        BadRequestException,
        ConcurrentModificationException,
        NotFoundException,
        TooManyRequestsException,
    ],
}));
/**
 * Update the configuration of an event destination for a configuration set.
 *
 * In Amazon Pinpoint, *events* include message sends, deliveries, opens,
 * clicks, bounces, and complaints. *Event destinations* are places that
 * you can send information about these events to. For example, you can send event data to
 * Amazon SNS to receive notifications when you receive bounces or complaints, or you can use
 * Amazon Kinesis Data Firehose to stream data to Amazon S3 for long-term storage.
 */
export const updateConfigurationSetEventDestination = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateConfigurationSetEventDestinationRequest,
    output: UpdateConfigurationSetEventDestinationResponse,
    errors: [BadRequestException, NotFoundException, TooManyRequestsException],
}));
//# sourceMappingURL=pinpoint-email.js.map