@aws-sdk/client-pinpoint 3.50.0 → 3.53.0

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

@@ -0,0 +1,4272 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { PinpointServiceException as __BaseException } from "./PinpointServiceException";
+export declare enum __EndpointTypesElement {
+    ADM = "ADM",
+    APNS = "APNS",
+    APNS_SANDBOX = "APNS_SANDBOX",
+    APNS_VOIP = "APNS_VOIP",
+    APNS_VOIP_SANDBOX = "APNS_VOIP_SANDBOX",
+    BAIDU = "BAIDU",
+    CUSTOM = "CUSTOM",
+    EMAIL = "EMAIL",
+    GCM = "GCM",
+    IN_APP = "IN_APP",
+    PUSH = "PUSH",
+    SMS = "SMS",
+    VOICE = "VOICE"
+}
+export declare enum Action {
+    DEEP_LINK = "DEEP_LINK",
+    OPEN_APP = "OPEN_APP",
+    URL = "URL"
+}
+
+export interface ActivityResponse {
+    
+    ApplicationId: string | undefined;
+    
+    CampaignId: string | undefined;
+    
+    End?: string;
+    
+    Id: string | undefined;
+    
+    Result?: string;
+    
+    ScheduledStart?: string;
+    
+    Start?: string;
+    
+    State?: string;
+    
+    SuccessfulEndpointCount?: number;
+    
+    TimezonesCompletedCount?: number;
+    
+    TimezonesTotalCount?: number;
+    
+    TotalEndpointCount?: number;
+    
+    TreatmentId?: string;
+}
+export declare namespace ActivityResponse {
+    
+    const filterSensitiveLog: (obj: ActivityResponse) => any;
+}
+
+export interface ActivitiesResponse {
+    
+    Item: ActivityResponse[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ActivitiesResponse {
+    
+    const filterSensitiveLog: (obj: ActivitiesResponse) => any;
+}
+export declare enum AttributeType {
+    AFTER = "AFTER",
+    BEFORE = "BEFORE",
+    BETWEEN = "BETWEEN",
+    CONTAINS = "CONTAINS",
+    EXCLUSIVE = "EXCLUSIVE",
+    INCLUSIVE = "INCLUSIVE",
+    ON = "ON"
+}
+
+export interface AttributeDimension {
+    
+    AttributeType?: AttributeType | string;
+    
+    Values: string[] | undefined;
+}
+export declare namespace AttributeDimension {
+    
+    const filterSensitiveLog: (obj: AttributeDimension) => any;
+}
+export declare enum DimensionType {
+    EXCLUSIVE = "EXCLUSIVE",
+    INCLUSIVE = "INCLUSIVE"
+}
+
+export interface SetDimension {
+    
+    DimensionType?: DimensionType | string;
+    
+    Values: string[] | undefined;
+}
+export declare namespace SetDimension {
+    
+    const filterSensitiveLog: (obj: SetDimension) => any;
+}
+
+export interface MetricDimension {
+    
+    ComparisonOperator: string | undefined;
+    
+    Value: number | undefined;
+}
+export declare namespace MetricDimension {
+    
+    const filterSensitiveLog: (obj: MetricDimension) => any;
+}
+
+export interface EventDimensions {
+    
+    Attributes?: {
+        [key: string]: AttributeDimension;
+    };
+    
+    EventType?: SetDimension;
+    
+    Metrics?: {
+        [key: string]: MetricDimension;
+    };
+}
+export declare namespace EventDimensions {
+    
+    const filterSensitiveLog: (obj: EventDimensions) => any;
+}
+
+export interface EventCondition {
+    
+    Dimensions?: EventDimensions;
+    
+    MessageActivity?: string;
+}
+export declare namespace EventCondition {
+    
+    const filterSensitiveLog: (obj: EventCondition) => any;
+}
+
+export interface SegmentCondition {
+    
+    SegmentId: string | undefined;
+}
+export declare namespace SegmentCondition {
+    
+    const filterSensitiveLog: (obj: SegmentCondition) => any;
+}
+export declare enum Duration {
+    DAY_14 = "DAY_14",
+    DAY_30 = "DAY_30",
+    DAY_7 = "DAY_7",
+    HR_24 = "HR_24"
+}
+export declare enum RecencyType {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+
+export interface RecencyDimension {
+    
+    Duration: Duration | string | undefined;
+    
+    RecencyType: RecencyType | string | undefined;
+}
+export declare namespace RecencyDimension {
+    
+    const filterSensitiveLog: (obj: RecencyDimension) => any;
+}
+
+export interface SegmentBehaviors {
+    
+    Recency?: RecencyDimension;
+}
+export declare namespace SegmentBehaviors {
+    
+    const filterSensitiveLog: (obj: SegmentBehaviors) => any;
+}
+
+export interface SegmentDemographics {
+    
+    AppVersion?: SetDimension;
+    
+    Channel?: SetDimension;
+    
+    DeviceType?: SetDimension;
+    
+    Make?: SetDimension;
+    
+    Model?: SetDimension;
+    
+    Platform?: SetDimension;
+}
+export declare namespace SegmentDemographics {
+    
+    const filterSensitiveLog: (obj: SegmentDemographics) => any;
+}
+
+export interface GPSCoordinates {
+    
+    Latitude: number | undefined;
+    
+    Longitude: number | undefined;
+}
+export declare namespace GPSCoordinates {
+    
+    const filterSensitiveLog: (obj: GPSCoordinates) => any;
+}
+
+export interface GPSPointDimension {
+    
+    Coordinates: GPSCoordinates | undefined;
+    
+    RangeInKilometers?: number;
+}
+export declare namespace GPSPointDimension {
+    
+    const filterSensitiveLog: (obj: GPSPointDimension) => any;
+}
+
+export interface SegmentLocation {
+    
+    Country?: SetDimension;
+    
+    GPSPoint?: GPSPointDimension;
+}
+export declare namespace SegmentLocation {
+    
+    const filterSensitiveLog: (obj: SegmentLocation) => any;
+}
+
+export interface SegmentDimensions {
+    
+    Attributes?: {
+        [key: string]: AttributeDimension;
+    };
+    
+    Behavior?: SegmentBehaviors;
+    
+    Demographic?: SegmentDemographics;
+    
+    Location?: SegmentLocation;
+    
+    Metrics?: {
+        [key: string]: MetricDimension;
+    };
+    
+    UserAttributes?: {
+        [key: string]: AttributeDimension;
+    };
+}
+export declare namespace SegmentDimensions {
+    
+    const filterSensitiveLog: (obj: SegmentDimensions) => any;
+}
+
+export interface SimpleCondition {
+    
+    EventCondition?: EventCondition;
+    
+    SegmentCondition?: SegmentCondition;
+    
+    SegmentDimensions?: SegmentDimensions;
+}
+export declare namespace SimpleCondition {
+    
+    const filterSensitiveLog: (obj: SimpleCondition) => any;
+}
+export declare enum Operator {
+    ALL = "ALL",
+    ANY = "ANY"
+}
+
+export interface Condition {
+    
+    Conditions?: SimpleCondition[];
+    
+    Operator?: Operator | string;
+}
+export declare namespace Condition {
+    
+    const filterSensitiveLog: (obj: Condition) => any;
+}
+
+export interface WaitTime {
+    
+    WaitFor?: string;
+    
+    WaitUntil?: string;
+}
+export declare namespace WaitTime {
+    
+    const filterSensitiveLog: (obj: WaitTime) => any;
+}
+
+export interface ConditionalSplitActivity {
+    
+    Condition?: Condition;
+    
+    EvaluationWaitTime?: WaitTime;
+    
+    FalseActivity?: string;
+    
+    TrueActivity?: string;
+}
+export declare namespace ConditionalSplitActivity {
+    
+    const filterSensitiveLog: (obj: ConditionalSplitActivity) => any;
+}
+export interface ContactCenterActivity {
+    
+    NextActivity?: string;
+}
+export declare namespace ContactCenterActivity {
+    
+    const filterSensitiveLog: (obj: ContactCenterActivity) => any;
+}
+
+export interface JourneyCustomMessage {
+    
+    Data?: string;
+}
+export declare namespace JourneyCustomMessage {
+    
+    const filterSensitiveLog: (obj: JourneyCustomMessage) => any;
+}
+
+export interface CustomMessageActivity {
+    
+    DeliveryUri?: string;
+    
+    EndpointTypes?: (__EndpointTypesElement | string)[];
+    
+    MessageConfig?: JourneyCustomMessage;
+    
+    NextActivity?: string;
+    
+    TemplateName?: string;
+    
+    TemplateVersion?: string;
+}
+export declare namespace CustomMessageActivity {
+    
+    const filterSensitiveLog: (obj: CustomMessageActivity) => any;
+}
+
+export interface JourneyEmailMessage {
+    
+    FromAddress?: string;
+}
+export declare namespace JourneyEmailMessage {
+    
+    const filterSensitiveLog: (obj: JourneyEmailMessage) => any;
+}
+
+export interface EmailMessageActivity {
+    
+    MessageConfig?: JourneyEmailMessage;
+    
+    NextActivity?: string;
+    
+    TemplateName?: string;
+    
+    TemplateVersion?: string;
+}
+export declare namespace EmailMessageActivity {
+    
+    const filterSensitiveLog: (obj: EmailMessageActivity) => any;
+}
+
+export interface HoldoutActivity {
+    
+    NextActivity?: string;
+    
+    Percentage: number | undefined;
+}
+export declare namespace HoldoutActivity {
+    
+    const filterSensitiveLog: (obj: HoldoutActivity) => any;
+}
+
+export interface MultiConditionalBranch {
+    
+    Condition?: SimpleCondition;
+    
+    NextActivity?: string;
+}
+export declare namespace MultiConditionalBranch {
+    
+    const filterSensitiveLog: (obj: MultiConditionalBranch) => any;
+}
+
+export interface MultiConditionalSplitActivity {
+    
+    Branches?: MultiConditionalBranch[];
+    
+    DefaultActivity?: string;
+    
+    EvaluationWaitTime?: WaitTime;
+}
+export declare namespace MultiConditionalSplitActivity {
+    
+    const filterSensitiveLog: (obj: MultiConditionalSplitActivity) => any;
+}
+
+export interface JourneyPushMessage {
+    
+    TimeToLive?: string;
+}
+export declare namespace JourneyPushMessage {
+    
+    const filterSensitiveLog: (obj: JourneyPushMessage) => any;
+}
+
+export interface PushMessageActivity {
+    
+    MessageConfig?: JourneyPushMessage;
+    
+    NextActivity?: string;
+    
+    TemplateName?: string;
+    
+    TemplateVersion?: string;
+}
+export declare namespace PushMessageActivity {
+    
+    const filterSensitiveLog: (obj: PushMessageActivity) => any;
+}
+
+export interface RandomSplitEntry {
+    
+    NextActivity?: string;
+    
+    Percentage?: number;
+}
+export declare namespace RandomSplitEntry {
+    
+    const filterSensitiveLog: (obj: RandomSplitEntry) => any;
+}
+
+export interface RandomSplitActivity {
+    
+    Branches?: RandomSplitEntry[];
+}
+export declare namespace RandomSplitActivity {
+    
+    const filterSensitiveLog: (obj: RandomSplitActivity) => any;
+}
+export declare enum MessageType {
+    PROMOTIONAL = "PROMOTIONAL",
+    TRANSACTIONAL = "TRANSACTIONAL"
+}
+
+export interface JourneySMSMessage {
+    
+    MessageType?: MessageType | string;
+    
+    OriginationNumber?: string;
+    
+    SenderId?: string;
+    
+    EntityId?: string;
+    
+    TemplateId?: string;
+}
+export declare namespace JourneySMSMessage {
+    
+    const filterSensitiveLog: (obj: JourneySMSMessage) => any;
+}
+
+export interface SMSMessageActivity {
+    
+    MessageConfig?: JourneySMSMessage;
+    
+    NextActivity?: string;
+    
+    TemplateName?: string;
+    
+    TemplateVersion?: string;
+}
+export declare namespace SMSMessageActivity {
+    
+    const filterSensitiveLog: (obj: SMSMessageActivity) => any;
+}
+
+export interface WaitActivity {
+    
+    NextActivity?: string;
+    
+    WaitTime?: WaitTime;
+}
+export declare namespace WaitActivity {
+    
+    const filterSensitiveLog: (obj: WaitActivity) => any;
+}
+
+export interface Activity {
+    
+    CUSTOM?: CustomMessageActivity;
+    
+    ConditionalSplit?: ConditionalSplitActivity;
+    
+    Description?: string;
+    
+    EMAIL?: EmailMessageActivity;
+    
+    Holdout?: HoldoutActivity;
+    
+    MultiCondition?: MultiConditionalSplitActivity;
+    
+    PUSH?: PushMessageActivity;
+    
+    RandomSplit?: RandomSplitActivity;
+    
+    SMS?: SMSMessageActivity;
+    
+    Wait?: WaitActivity;
+    
+    ContactCenter?: ContactCenterActivity;
+}
+export declare namespace Activity {
+    
+    const filterSensitiveLog: (obj: Activity) => any;
+}
+export declare enum ChannelType {
+    ADM = "ADM",
+    APNS = "APNS",
+    APNS_SANDBOX = "APNS_SANDBOX",
+    APNS_VOIP = "APNS_VOIP",
+    APNS_VOIP_SANDBOX = "APNS_VOIP_SANDBOX",
+    BAIDU = "BAIDU",
+    CUSTOM = "CUSTOM",
+    EMAIL = "EMAIL",
+    GCM = "GCM",
+    IN_APP = "IN_APP",
+    PUSH = "PUSH",
+    SMS = "SMS",
+    VOICE = "VOICE"
+}
+
+export interface AddressConfiguration {
+    
+    BodyOverride?: string;
+    
+    ChannelType?: ChannelType | string;
+    
+    Context?: {
+        [key: string]: string;
+    };
+    
+    RawContent?: string;
+    
+    Substitutions?: {
+        [key: string]: string[];
+    };
+    
+    TitleOverride?: string;
+}
+export declare namespace AddressConfiguration {
+    
+    const filterSensitiveLog: (obj: AddressConfiguration) => any;
+}
+
+export interface ADMChannelRequest {
+    
+    ClientId: string | undefined;
+    
+    ClientSecret: string | undefined;
+    
+    Enabled?: boolean;
+}
+export declare namespace ADMChannelRequest {
+    
+    const filterSensitiveLog: (obj: ADMChannelRequest) => any;
+}
+
+export interface ADMChannelResponse {
+    
+    ApplicationId?: string;
+    
+    CreationDate?: string;
+    
+    Enabled?: boolean;
+    
+    HasCredential?: boolean;
+    
+    Id?: string;
+    
+    IsArchived?: boolean;
+    
+    LastModifiedBy?: string;
+    
+    LastModifiedDate?: string;
+    
+    Platform: string | undefined;
+    
+    Version?: number;
+}
+export declare namespace ADMChannelResponse {
+    
+    const filterSensitiveLog: (obj: ADMChannelResponse) => any;
+}
+
+export interface ADMMessage {
+    
+    Action?: Action | string;
+    
+    Body?: string;
+    
+    ConsolidationKey?: string;
+    
+    Data?: {
+        [key: string]: string;
+    };
+    
+    ExpiresAfter?: string;
+    
+    IconReference?: string;
+    
+    ImageIconUrl?: string;
+    
+    ImageUrl?: string;
+    
+    MD5?: string;
+    
+    RawContent?: string;
+    
+    SilentPush?: boolean;
+    
+    SmallImageIconUrl?: string;
+    
+    Sound?: string;
+    
+    Substitutions?: {
+        [key: string]: string[];
+    };
+    
+    Title?: string;
+    
+    Url?: string;
+}
+export declare namespace ADMMessage {
+    
+    const filterSensitiveLog: (obj: ADMMessage) => any;
+}
+export declare enum Alignment {
+    CENTER = "CENTER",
+    LEFT = "LEFT",
+    RIGHT = "RIGHT"
+}
+
+export interface AndroidPushNotificationTemplate {
+    
+    Action?: Action | string;
+    
+    Body?: string;
+    
+    ImageIconUrl?: string;
+    
+    ImageUrl?: string;
+    
+    RawContent?: string;
+    
+    SmallImageIconUrl?: string;
+    
+    Sound?: string;
+    
+    Title?: string;
+    
+    Url?: string;
+}
+export declare namespace AndroidPushNotificationTemplate {
+    
+    const filterSensitiveLog: (obj: AndroidPushNotificationTemplate) => any;
+}
+
+export interface APNSChannelRequest {
+    
+    BundleId?: string;
+    
+    Certificate?: string;
+    
+    DefaultAuthenticationMethod?: string;
+    
+    Enabled?: boolean;
+    
+    PrivateKey?: string;
+    
+    TeamId?: string;
+    
+    TokenKey?: string;
+    
+    TokenKeyId?: string;
+}
+export declare namespace APNSChannelRequest {
+    
+    const filterSensitiveLog: (obj: APNSChannelRequest) => any;
+}
+
+export interface APNSChannelResponse {
+    
+    ApplicationId?: string;
+    
+    CreationDate?: string;
+    
+    DefaultAuthenticationMethod?: string;
+    
+    Enabled?: boolean;
+    
+    HasCredential?: boolean;
+    
+    HasTokenKey?: boolean;
+    
+    Id?: string;
+    
+    IsArchived?: boolean;
+    
+    LastModifiedBy?: string;
+    
+    LastModifiedDate?: string;
+    
+    Platform: string | undefined;
+    
+    Version?: number;
+}
+export declare namespace APNSChannelResponse {
+    
+    const filterSensitiveLog: (obj: APNSChannelResponse) => any;
+}
+
+export interface APNSMessage {
+    
+    APNSPushType?: string;
+    
+    Action?: Action | string;
+    
+    Badge?: number;
+    
+    Body?: string;
+    
+    Category?: string;
+    
+    CollapseId?: string;
+    
+    Data?: {
+        [key: string]: string;
+    };
+    
+    MediaUrl?: string;
+    
+    PreferredAuthenticationMethod?: string;
+    
+    Priority?: string;
+    
+    RawContent?: string;
+    
+    SilentPush?: boolean;
+    
+    Sound?: string;
+    
+    Substitutions?: {
+        [key: string]: string[];
+    };
+    
+    ThreadId?: string;
+    
+    TimeToLive?: number;
+    
+    Title?: string;
+    
+    Url?: string;
+}
+export declare namespace APNSMessage {
+    
+    const filterSensitiveLog: (obj: APNSMessage) => any;
+}
+
+export interface APNSPushNotificationTemplate {
+    
+    Action?: Action | string;
+    
+    Body?: string;
+    
+    MediaUrl?: string;
+    
+    RawContent?: string;
+    
+    Sound?: string;
+    
+    Title?: string;
+    
+    Url?: string;
+}
+export declare namespace APNSPushNotificationTemplate {
+    
+    const filterSensitiveLog: (obj: APNSPushNotificationTemplate) => any;
+}
+
+export interface APNSSandboxChannelRequest {
+    
+    BundleId?: string;
+    
+    Certificate?: string;
+    
+    DefaultAuthenticationMethod?: string;
+    
+    Enabled?: boolean;
+    
+    PrivateKey?: string;
+    
+    TeamId?: string;
+    
+    TokenKey?: string;
+    
+    TokenKeyId?: string;
+}
+export declare namespace APNSSandboxChannelRequest {
+    
+    const filterSensitiveLog: (obj: APNSSandboxChannelRequest) => any;
+}
+
+export interface APNSSandboxChannelResponse {
+    
+    ApplicationId?: string;
+    
+    CreationDate?: string;
+    
+    DefaultAuthenticationMethod?: string;
+    
+    Enabled?: boolean;
+    
+    HasCredential?: boolean;
+    
+    HasTokenKey?: boolean;
+    
+    Id?: string;
+    
+    IsArchived?: boolean;
+    
+    LastModifiedBy?: string;
+    
+    LastModifiedDate?: string;
+    
+    Platform: string | undefined;
+    
+    Version?: number;
+}
+export declare namespace APNSSandboxChannelResponse {
+    
+    const filterSensitiveLog: (obj: APNSSandboxChannelResponse) => any;
+}
+
+export interface APNSVoipChannelRequest {
+    
+    BundleId?: string;
+    
+    Certificate?: string;
+    
+    DefaultAuthenticationMethod?: string;
+    
+    Enabled?: boolean;
+    
+    PrivateKey?: string;
+    
+    TeamId?: string;
+    
+    TokenKey?: string;
+    
+    TokenKeyId?: string;
+}
+export declare namespace APNSVoipChannelRequest {
+    
+    const filterSensitiveLog: (obj: APNSVoipChannelRequest) => any;
+}
+
+export interface APNSVoipChannelResponse {
+    
+    ApplicationId?: string;
+    
+    CreationDate?: string;
+    
+    DefaultAuthenticationMethod?: string;
+    
+    Enabled?: boolean;
+    
+    HasCredential?: boolean;
+    
+    HasTokenKey?: boolean;
+    
+    Id?: string;
+    
+    IsArchived?: boolean;
+    
+    LastModifiedBy?: string;
+    
+    LastModifiedDate?: string;
+    
+    Platform: string | undefined;
+    
+    Version?: number;
+}
+export declare namespace APNSVoipChannelResponse {
+    
+    const filterSensitiveLog: (obj: APNSVoipChannelResponse) => any;
+}
+
+export interface APNSVoipSandboxChannelRequest {
+    
+    BundleId?: string;
+    
+    Certificate?: string;
+    
+    DefaultAuthenticationMethod?: string;
+    
+    Enabled?: boolean;
+    
+    PrivateKey?: string;
+    
+    TeamId?: string;
+    
+    TokenKey?: string;
+    
+    TokenKeyId?: string;
+}
+export declare namespace APNSVoipSandboxChannelRequest {
+    
+    const filterSensitiveLog: (obj: APNSVoipSandboxChannelRequest) => any;
+}
+
+export interface APNSVoipSandboxChannelResponse {
+    
+    ApplicationId?: string;
+    
+    CreationDate?: string;
+    
+    DefaultAuthenticationMethod?: string;
+    
+    Enabled?: boolean;
+    
+    HasCredential?: boolean;
+    
+    HasTokenKey?: boolean;
+    
+    Id?: string;
+    
+    IsArchived?: boolean;
+    
+    LastModifiedBy?: string;
+    
+    LastModifiedDate?: string;
+    
+    Platform: string | undefined;
+    
+    Version?: number;
+}
+export declare namespace APNSVoipSandboxChannelResponse {
+    
+    const filterSensitiveLog: (obj: APNSVoipSandboxChannelResponse) => any;
+}
+
+export interface ResultRowValue {
+    
+    Key: string | undefined;
+    
+    Type: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace ResultRowValue {
+    
+    const filterSensitiveLog: (obj: ResultRowValue) => any;
+}
+
+export interface ResultRow {
+    
+    GroupedBys: ResultRowValue[] | undefined;
+    
+    Values: ResultRowValue[] | undefined;
+}
+export declare namespace ResultRow {
+    
+    const filterSensitiveLog: (obj: ResultRow) => any;
+}
+
+export interface BaseKpiResult {
+    
+    Rows: ResultRow[] | undefined;
+}
+export declare namespace BaseKpiResult {
+    
+    const filterSensitiveLog: (obj: BaseKpiResult) => any;
+}
+
+export interface ApplicationDateRangeKpiResponse {
+    
+    ApplicationId: string | undefined;
+    
+    EndTime: Date | undefined;
+    
+    KpiName: string | undefined;
+    
+    KpiResult: BaseKpiResult | undefined;
+    
+    NextToken?: string;
+    
+    StartTime: Date | undefined;
+}
+export declare namespace ApplicationDateRangeKpiResponse {
+    
+    const filterSensitiveLog: (obj: ApplicationDateRangeKpiResponse) => any;
+}
+
+export interface ApplicationResponse {
+    
+    Arn: string | undefined;
+    
+    Id: string | undefined;
+    
+    Name: string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    CreationDate?: string;
+}
+export declare namespace ApplicationResponse {
+    
+    const filterSensitiveLog: (obj: ApplicationResponse) => any;
+}
+export declare enum Mode {
+    DELIVERY = "DELIVERY",
+    FILTER = "FILTER"
+}
+
+export interface CampaignHook {
+    
+    LambdaFunctionName?: string;
+    
+    Mode?: Mode | string;
+    
+    WebUrl?: string;
+}
+export declare namespace CampaignHook {
+    
+    const filterSensitiveLog: (obj: CampaignHook) => any;
+}
+
+export interface CampaignLimits {
+    
+    Daily?: number;
+    
+    MaximumDuration?: number;
+    
+    MessagesPerSecond?: number;
+    
+    Total?: number;
+    
+    Session?: number;
+}
+export declare namespace CampaignLimits {
+    
+    const filterSensitiveLog: (obj: CampaignLimits) => any;
+}
+
+export interface QuietTime {
+    
+    End?: string;
+    
+    Start?: string;
+}
+export declare namespace QuietTime {
+    
+    const filterSensitiveLog: (obj: QuietTime) => any;
+}
+
+export interface ApplicationSettingsResource {
+    
+    ApplicationId: string | undefined;
+    
+    CampaignHook?: CampaignHook;
+    
+    LastModifiedDate?: string;
+    
+    Limits?: CampaignLimits;
+    
+    QuietTime?: QuietTime;
+}
+export declare namespace ApplicationSettingsResource {
+    
+    const filterSensitiveLog: (obj: ApplicationSettingsResource) => any;
+}
+
+export interface ApplicationsResponse {
+    
+    Item?: ApplicationResponse[];
+    
+    NextToken?: string;
+}
+export declare namespace ApplicationsResponse {
+    
+    const filterSensitiveLog: (obj: ApplicationsResponse) => any;
+}
+
+export interface AttributesResource {
+    
+    ApplicationId: string | undefined;
+    
+    AttributeType: string | undefined;
+    
+    Attributes?: string[];
+}
+export declare namespace AttributesResource {
+    
+    const filterSensitiveLog: (obj: AttributesResource) => any;
+}
+
+export declare class BadRequestException extends __BaseException {
+    readonly name: "BadRequestException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    RequestID?: string;
+    
+    constructor(opts: __ExceptionOptionType<BadRequestException, __BaseException>);
+}
+
+export interface BaiduChannelRequest {
+    
+    ApiKey: string | undefined;
+    
+    Enabled?: boolean;
+    
+    SecretKey: string | undefined;
+}
+export declare namespace BaiduChannelRequest {
+    
+    const filterSensitiveLog: (obj: BaiduChannelRequest) => any;
+}
+
+export interface BaiduChannelResponse {
+    
+    ApplicationId?: string;
+    
+    CreationDate?: string;
+    
+    Credential: string | undefined;
+    
+    Enabled?: boolean;
+    
+    HasCredential?: boolean;
+    
+    Id?: string;
+    
+    IsArchived?: boolean;
+    
+    LastModifiedBy?: string;
+    
+    LastModifiedDate?: string;
+    
+    Platform: string | undefined;
+    
+    Version?: number;
+}
+export declare namespace BaiduChannelResponse {
+    
+    const filterSensitiveLog: (obj: BaiduChannelResponse) => any;
+}
+
+export interface BaiduMessage {
+    
+    Action?: Action | string;
+    
+    Body?: string;
+    
+    Data?: {
+        [key: string]: string;
+    };
+    
+    IconReference?: string;
+    
+    ImageIconUrl?: string;
+    
+    ImageUrl?: string;
+    
+    RawContent?: string;
+    
+    SilentPush?: boolean;
+    
+    SmallImageIconUrl?: string;
+    
+    Sound?: string;
+    
+    Substitutions?: {
+        [key: string]: string[];
+    };
+    
+    TimeToLive?: number;
+    
+    Title?: string;
+    
+    Url?: string;
+}
+export declare namespace BaiduMessage {
+    
+    const filterSensitiveLog: (obj: BaiduMessage) => any;
+}
+export declare enum ButtonAction {
+    CLOSE = "CLOSE",
+    DEEP_LINK = "DEEP_LINK",
+    LINK = "LINK"
+}
+
+export interface CampaignCustomMessage {
+    
+    Data?: string;
+}
+export declare namespace CampaignCustomMessage {
+    
+    const filterSensitiveLog: (obj: CampaignCustomMessage) => any;
+}
+
+export interface CampaignDateRangeKpiResponse {
+    
+    ApplicationId: string | undefined;
+    
+    CampaignId: string | undefined;
+    
+    EndTime: Date | undefined;
+    
+    KpiName: string | undefined;
+    
+    KpiResult: BaseKpiResult | undefined;
+    
+    NextToken?: string;
+    
+    StartTime: Date | undefined;
+}
+export declare namespace CampaignDateRangeKpiResponse {
+    
+    const filterSensitiveLog: (obj: CampaignDateRangeKpiResponse) => any;
+}
+
+export interface CampaignEmailMessage {
+    
+    Body?: string;
+    
+    FromAddress?: string;
+    
+    HtmlBody?: string;
+    
+    Title?: string;
+}
+export declare namespace CampaignEmailMessage {
+    
+    const filterSensitiveLog: (obj: CampaignEmailMessage) => any;
+}
+export declare enum FilterType {
+    ENDPOINT = "ENDPOINT",
+    SYSTEM = "SYSTEM"
+}
+
+export interface CampaignEventFilter {
+    
+    Dimensions: EventDimensions | undefined;
+    
+    FilterType: FilterType | string | undefined;
+}
+export declare namespace CampaignEventFilter {
+    
+    const filterSensitiveLog: (obj: CampaignEventFilter) => any;
+}
+
+export interface InAppMessageBodyConfig {
+    
+    Alignment: Alignment | string | undefined;
+    
+    Body: string | undefined;
+    
+    TextColor: string | undefined;
+}
+export declare namespace InAppMessageBodyConfig {
+    
+    const filterSensitiveLog: (obj: InAppMessageBodyConfig) => any;
+}
+
+export interface InAppMessageHeaderConfig {
+    
+    Alignment: Alignment | string | undefined;
+    
+    Header: string | undefined;
+    
+    TextColor: string | undefined;
+}
+export declare namespace InAppMessageHeaderConfig {
+    
+    const filterSensitiveLog: (obj: InAppMessageHeaderConfig) => any;
+}
+
+export interface OverrideButtonConfiguration {
+    
+    ButtonAction: ButtonAction | string | undefined;
+    
+    Link?: string;
+}
+export declare namespace OverrideButtonConfiguration {
+    
+    const filterSensitiveLog: (obj: OverrideButtonConfiguration) => any;
+}
+
+export interface DefaultButtonConfiguration {
+    
+    BackgroundColor?: string;
+    
+    BorderRadius?: number;
+    
+    ButtonAction: ButtonAction | string | undefined;
+    
+    Link?: string;
+    
+    Text: string | undefined;
+    
+    TextColor?: string;
+}
+export declare namespace DefaultButtonConfiguration {
+    
+    const filterSensitiveLog: (obj: DefaultButtonConfiguration) => any;
+}
+
+export interface InAppMessageButton {
+    
+    Android?: OverrideButtonConfiguration;
+    
+    DefaultConfig?: DefaultButtonConfiguration;
+    
+    IOS?: OverrideButtonConfiguration;
+    
+    Web?: OverrideButtonConfiguration;
+}
+export declare namespace InAppMessageButton {
+    
+    const filterSensitiveLog: (obj: InAppMessageButton) => any;
+}
+
+export interface InAppMessageContent {
+    
+    BackgroundColor?: string;
+    
+    BodyConfig?: InAppMessageBodyConfig;
+    
+    HeaderConfig?: InAppMessageHeaderConfig;
+    
+    ImageUrl?: string;
+    
+    PrimaryBtn?: InAppMessageButton;
+    
+    SecondaryBtn?: InAppMessageButton;
+}
+export declare namespace InAppMessageContent {
+    
+    const filterSensitiveLog: (obj: InAppMessageContent) => any;
+}
+export declare enum Layout {
+    BOTTOM_BANNER = "BOTTOM_BANNER",
+    CAROUSEL = "CAROUSEL",
+    MIDDLE_BANNER = "MIDDLE_BANNER",
+    MOBILE_FEED = "MOBILE_FEED",
+    OVERLAYS = "OVERLAYS",
+    TOP_BANNER = "TOP_BANNER"
+}
+
+export interface CampaignInAppMessage {
+    
+    Body?: string;
+    
+    Content?: InAppMessageContent[];
+    
+    CustomConfig?: {
+        [key: string]: string;
+    };
+    
+    Layout?: Layout | string;
+}
+export declare namespace CampaignInAppMessage {
+    
+    const filterSensitiveLog: (obj: CampaignInAppMessage) => any;
+}
+
+export interface CustomDeliveryConfiguration {
+    
+    DeliveryUri: string | undefined;
+    
+    EndpointTypes?: (__EndpointTypesElement | string)[];
+}
+export declare namespace CustomDeliveryConfiguration {
+    
+    const filterSensitiveLog: (obj: CustomDeliveryConfiguration) => any;
+}
+
+export interface Message {
+    
+    Action?: Action | string;
+    
+    Body?: string;
+    
+    ImageIconUrl?: string;
+    
+    ImageSmallIconUrl?: string;
+    
+    ImageUrl?: string;
+    
+    JsonBody?: string;
+    
+    MediaUrl?: string;
+    
+    RawContent?: string;
+    
+    SilentPush?: boolean;
+    
+    TimeToLive?: number;
+    
+    Title?: string;
+    
+    Url?: string;
+}
+export declare namespace Message {
+    
+    const filterSensitiveLog: (obj: Message) => any;
+}
+
+export interface CampaignSmsMessage {
+    
+    Body?: string;
+    
+    MessageType?: MessageType | string;
+    
+    OriginationNumber?: string;
+    
+    SenderId?: string;
+    
+    EntityId?: string;
+    
+    TemplateId?: string;
+}
+export declare namespace CampaignSmsMessage {
+    
+    const filterSensitiveLog: (obj: CampaignSmsMessage) => any;
+}
+
+export interface MessageConfiguration {
+    
+    ADMMessage?: Message;
+    
+    APNSMessage?: Message;
+    
+    BaiduMessage?: Message;
+    
+    CustomMessage?: CampaignCustomMessage;
+    
+    DefaultMessage?: Message;
+    
+    EmailMessage?: CampaignEmailMessage;
+    
+    GCMMessage?: Message;
+    
+    SMSMessage?: CampaignSmsMessage;
+    
+    InAppMessage?: CampaignInAppMessage;
+}
+export declare namespace MessageConfiguration {
+    
+    const filterSensitiveLog: (obj: MessageConfiguration) => any;
+}
+export declare enum Frequency {
+    DAILY = "DAILY",
+    EVENT = "EVENT",
+    HOURLY = "HOURLY",
+    IN_APP_EVENT = "IN_APP_EVENT",
+    MONTHLY = "MONTHLY",
+    ONCE = "ONCE",
+    WEEKLY = "WEEKLY"
+}
+
+export interface Schedule {
+    
+    EndTime?: string;
+    
+    EventFilter?: CampaignEventFilter;
+    
+    Frequency?: Frequency | string;
+    
+    IsLocalTime?: boolean;
+    
+    QuietTime?: QuietTime;
+    
+    StartTime: string | undefined;
+    
+    Timezone?: string;
+}
+export declare namespace Schedule {
+    
+    const filterSensitiveLog: (obj: Schedule) => any;
+}
+export declare enum CampaignStatus {
+    COMPLETED = "COMPLETED",
+    DELETED = "DELETED",
+    EXECUTING = "EXECUTING",
+    INVALID = "INVALID",
+    PAUSED = "PAUSED",
+    PENDING_NEXT_RUN = "PENDING_NEXT_RUN",
+    SCHEDULED = "SCHEDULED"
+}
+
+export interface CampaignState {
+    
+    CampaignStatus?: CampaignStatus | string;
+}
+export declare namespace CampaignState {
+    
+    const filterSensitiveLog: (obj: CampaignState) => any;
+}
+
+export interface Template {
+    
+    Name?: string;
+    
+    Version?: string;
+}
+export declare namespace Template {
+    
+    const filterSensitiveLog: (obj: Template) => any;
+}
+
+export interface TemplateConfiguration {
+    
+    EmailTemplate?: Template;
+    
+    PushTemplate?: Template;
+    
+    SMSTemplate?: Template;
+    
+    VoiceTemplate?: Template;
+}
+export declare namespace TemplateConfiguration {
+    
+    const filterSensitiveLog: (obj: TemplateConfiguration) => any;
+}
+
+export interface TreatmentResource {
+    
+    CustomDeliveryConfiguration?: CustomDeliveryConfiguration;
+    
+    Id: string | undefined;
+    
+    MessageConfiguration?: MessageConfiguration;
+    
+    Schedule?: Schedule;
+    
+    SizePercent: number | undefined;
+    
+    State?: CampaignState;
+    
+    TemplateConfiguration?: TemplateConfiguration;
+    
+    TreatmentDescription?: string;
+    
+    TreatmentName?: string;
+}
+export declare namespace TreatmentResource {
+    
+    const filterSensitiveLog: (obj: TreatmentResource) => any;
+}
+
+export interface CampaignResponse {
+    
+    AdditionalTreatments?: TreatmentResource[];
+    
+    ApplicationId: string | undefined;
+    
+    Arn: string | undefined;
+    
+    CreationDate: string | undefined;
+    
+    CustomDeliveryConfiguration?: CustomDeliveryConfiguration;
+    
+    DefaultState?: CampaignState;
+    
+    Description?: string;
+    
+    HoldoutPercent?: number;
+    
+    Hook?: CampaignHook;
+    
+    Id: string | undefined;
+    
+    IsPaused?: boolean;
+    
+    LastModifiedDate: string | undefined;
+    
+    Limits?: CampaignLimits;
+    
+    MessageConfiguration?: MessageConfiguration;
+    
+    Name?: string;
+    
+    Schedule?: Schedule;
+    
+    SegmentId: string | undefined;
+    
+    SegmentVersion: number | undefined;
+    
+    State?: CampaignState;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    TemplateConfiguration?: TemplateConfiguration;
+    
+    TreatmentDescription?: string;
+    
+    TreatmentName?: string;
+    
+    Version?: number;
+    
+    Priority?: number;
+}
+export declare namespace CampaignResponse {
+    
+    const filterSensitiveLog: (obj: CampaignResponse) => any;
+}
+
+export interface CampaignsResponse {
+    
+    Item: CampaignResponse[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace CampaignsResponse {
+    
+    const filterSensitiveLog: (obj: CampaignsResponse) => any;
+}
+
+export interface ChannelResponse {
+    
+    ApplicationId?: string;
+    
+    CreationDate?: string;
+    
+    Enabled?: boolean;
+    
+    HasCredential?: boolean;
+    
+    Id?: string;
+    
+    IsArchived?: boolean;
+    
+    LastModifiedBy?: string;
+    
+    LastModifiedDate?: string;
+    
+    Version?: number;
+}
+export declare namespace ChannelResponse {
+    
+    const filterSensitiveLog: (obj: ChannelResponse) => any;
+}
+
+export interface ChannelsResponse {
+    
+    Channels: {
+        [key: string]: ChannelResponse;
+    } | undefined;
+}
+export declare namespace ChannelsResponse {
+    
+    const filterSensitiveLog: (obj: ChannelsResponse) => any;
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    RequestID?: string;
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+
+export interface CreateApplicationRequest {
+    
+    Name: string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateApplicationRequest {
+    
+    const filterSensitiveLog: (obj: CreateApplicationRequest) => any;
+}
+export interface CreateAppRequest {
+    
+    CreateApplicationRequest: CreateApplicationRequest | undefined;
+}
+export declare namespace CreateAppRequest {
+    
+    const filterSensitiveLog: (obj: CreateAppRequest) => any;
+}
+export interface CreateAppResponse {
+    
+    ApplicationResponse: ApplicationResponse | undefined;
+}
+export declare namespace CreateAppResponse {
+    
+    const filterSensitiveLog: (obj: CreateAppResponse) => any;
+}
+
+export declare class ForbiddenException extends __BaseException {
+    readonly name: "ForbiddenException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    RequestID?: string;
+    
+    constructor(opts: __ExceptionOptionType<ForbiddenException, __BaseException>);
+}
+
+export declare class InternalServerErrorException extends __BaseException {
+    readonly name: "InternalServerErrorException";
+    readonly $fault: "server";
+    
+    Message?: string;
+    
+    RequestID?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerErrorException, __BaseException>);
+}
+
+export declare class MethodNotAllowedException extends __BaseException {
+    readonly name: "MethodNotAllowedException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    RequestID?: string;
+    
+    constructor(opts: __ExceptionOptionType<MethodNotAllowedException, __BaseException>);
+}
+
+export declare class NotFoundException extends __BaseException {
+    readonly name: "NotFoundException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    RequestID?: string;
+    
+    constructor(opts: __ExceptionOptionType<NotFoundException, __BaseException>);
+}
+
+export declare class PayloadTooLargeException extends __BaseException {
+    readonly name: "PayloadTooLargeException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    RequestID?: string;
+    
+    constructor(opts: __ExceptionOptionType<PayloadTooLargeException, __BaseException>);
+}
+
+export declare class TooManyRequestsException extends __BaseException {
+    readonly name: "TooManyRequestsException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    RequestID?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyRequestsException, __BaseException>);
+}
+
+export interface WriteTreatmentResource {
+    
+    CustomDeliveryConfiguration?: CustomDeliveryConfiguration;
+    
+    MessageConfiguration?: MessageConfiguration;
+    
+    Schedule?: Schedule;
+    
+    SizePercent: number | undefined;
+    
+    TemplateConfiguration?: TemplateConfiguration;
+    
+    TreatmentDescription?: string;
+    
+    TreatmentName?: string;
+}
+export declare namespace WriteTreatmentResource {
+    
+    const filterSensitiveLog: (obj: WriteTreatmentResource) => any;
+}
+
+export interface WriteCampaignRequest {
+    
+    AdditionalTreatments?: WriteTreatmentResource[];
+    
+    CustomDeliveryConfiguration?: CustomDeliveryConfiguration;
+    
+    Description?: string;
+    
+    HoldoutPercent?: number;
+    
+    Hook?: CampaignHook;
+    
+    IsPaused?: boolean;
+    
+    Limits?: CampaignLimits;
+    
+    MessageConfiguration?: MessageConfiguration;
+    
+    Name?: string;
+    
+    Schedule?: Schedule;
+    
+    SegmentId?: string;
+    
+    SegmentVersion?: number;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    TemplateConfiguration?: TemplateConfiguration;
+    
+    TreatmentDescription?: string;
+    
+    TreatmentName?: string;
+    
+    Priority?: number;
+}
+export declare namespace WriteCampaignRequest {
+    
+    const filterSensitiveLog: (obj: WriteCampaignRequest) => any;
+}
+export interface CreateCampaignRequest {
+    
+    ApplicationId: string | undefined;
+    
+    WriteCampaignRequest: WriteCampaignRequest | undefined;
+}
+export declare namespace CreateCampaignRequest {
+    
+    const filterSensitiveLog: (obj: CreateCampaignRequest) => any;
+}
+export interface CreateCampaignResponse {
+    
+    CampaignResponse: CampaignResponse | undefined;
+}
+export declare namespace CreateCampaignResponse {
+    
+    const filterSensitiveLog: (obj: CreateCampaignResponse) => any;
+}
+
+export interface EmailTemplateRequest {
+    
+    DefaultSubstitutions?: string;
+    
+    HtmlPart?: string;
+    
+    RecommenderId?: string;
+    
+    Subject?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    TemplateDescription?: string;
+    
+    TextPart?: string;
+}
+export declare namespace EmailTemplateRequest {
+    
+    const filterSensitiveLog: (obj: EmailTemplateRequest) => any;
+}
+export interface CreateEmailTemplateRequest {
+    
+    EmailTemplateRequest: EmailTemplateRequest | undefined;
+    
+    TemplateName: string | undefined;
+}
+export declare namespace CreateEmailTemplateRequest {
+    
+    const filterSensitiveLog: (obj: CreateEmailTemplateRequest) => any;
+}
+
+export interface CreateTemplateMessageBody {
+    
+    Arn?: string;
+    
+    Message?: string;
+    
+    RequestID?: string;
+}
+export declare namespace CreateTemplateMessageBody {
+    
+    const filterSensitiveLog: (obj: CreateTemplateMessageBody) => any;
+}
+export interface CreateEmailTemplateResponse {
+    
+    CreateTemplateMessageBody: CreateTemplateMessageBody | undefined;
+}
+export declare namespace CreateEmailTemplateResponse {
+    
+    const filterSensitiveLog: (obj: CreateEmailTemplateResponse) => any;
+}
+
+export interface ExportJobRequest {
+    
+    RoleArn: string | undefined;
+    
+    S3UrlPrefix: string | undefined;
+    
+    SegmentId?: string;
+    
+    SegmentVersion?: number;
+}
+export declare namespace ExportJobRequest {
+    
+    const filterSensitiveLog: (obj: ExportJobRequest) => any;
+}
+export interface CreateExportJobRequest {
+    
+    ApplicationId: string | undefined;
+    
+    ExportJobRequest: ExportJobRequest | undefined;
+}
+export declare namespace CreateExportJobRequest {
+    
+    const filterSensitiveLog: (obj: CreateExportJobRequest) => any;
+}
+
+export interface ExportJobResource {
+    
+    RoleArn: string | undefined;
+    
+    S3UrlPrefix: string | undefined;
+    
+    SegmentId?: string;
+    
+    SegmentVersion?: number;
+}
+export declare namespace ExportJobResource {
+    
+    const filterSensitiveLog: (obj: ExportJobResource) => any;
+}
+export declare enum JobStatus {
+    COMPLETED = "COMPLETED",
+    COMPLETING = "COMPLETING",
+    CREATED = "CREATED",
+    FAILED = "FAILED",
+    FAILING = "FAILING",
+    INITIALIZING = "INITIALIZING",
+    PENDING_JOB = "PENDING_JOB",
+    PREPARING_FOR_INITIALIZATION = "PREPARING_FOR_INITIALIZATION",
+    PROCESSING = "PROCESSING"
+}
+
+export interface ExportJobResponse {
+    
+    ApplicationId: string | undefined;
+    
+    CompletedPieces?: number;
+    
+    CompletionDate?: string;
+    
+    CreationDate: string | undefined;
+    
+    Definition: ExportJobResource | undefined;
+    
+    FailedPieces?: number;
+    
+    Failures?: string[];
+    
+    Id: string | undefined;
+    
+    JobStatus: JobStatus | string | undefined;
+    
+    TotalFailures?: number;
+    
+    TotalPieces?: number;
+    
+    TotalProcessed?: number;
+    
+    Type: string | undefined;
+}
+export declare namespace ExportJobResponse {
+    
+    const filterSensitiveLog: (obj: ExportJobResponse) => any;
+}
+export interface CreateExportJobResponse {
+    
+    ExportJobResponse: ExportJobResponse | undefined;
+}
+export declare namespace CreateExportJobResponse {
+    
+    const filterSensitiveLog: (obj: CreateExportJobResponse) => any;
+}
+export declare enum Format {
+    CSV = "CSV",
+    JSON = "JSON"
+}
+
+export interface ImportJobRequest {
+    
+    DefineSegment?: boolean;
+    
+    ExternalId?: string;
+    
+    Format: Format | string | undefined;
+    
+    RegisterEndpoints?: boolean;
+    
+    RoleArn: string | undefined;
+    
+    S3Url: string | undefined;
+    
+    SegmentId?: string;
+    
+    SegmentName?: string;
+}
+export declare namespace ImportJobRequest {
+    
+    const filterSensitiveLog: (obj: ImportJobRequest) => any;
+}
+export interface CreateImportJobRequest {
+    
+    ApplicationId: string | undefined;
+    
+    ImportJobRequest: ImportJobRequest | undefined;
+}
+export declare namespace CreateImportJobRequest {
+    
+    const filterSensitiveLog: (obj: CreateImportJobRequest) => any;
+}
+
+export interface ImportJobResource {
+    
+    DefineSegment?: boolean;
+    
+    ExternalId?: string;
+    
+    Format: Format | string | undefined;
+    
+    RegisterEndpoints?: boolean;
+    
+    RoleArn: string | undefined;
+    
+    S3Url: string | undefined;
+    
+    SegmentId?: string;
+    
+    SegmentName?: string;
+}
+export declare namespace ImportJobResource {
+    
+    const filterSensitiveLog: (obj: ImportJobResource) => any;
+}
+
+export interface ImportJobResponse {
+    
+    ApplicationId: string | undefined;
+    
+    CompletedPieces?: number;
+    
+    CompletionDate?: string;
+    
+    CreationDate: string | undefined;
+    
+    Definition: ImportJobResource | undefined;
+    
+    FailedPieces?: number;
+    
+    Failures?: string[];
+    
+    Id: string | undefined;
+    
+    JobStatus: JobStatus | string | undefined;
+    
+    TotalFailures?: number;
+    
+    TotalPieces?: number;
+    
+    TotalProcessed?: number;
+    
+    Type: string | undefined;
+}
+export declare namespace ImportJobResponse {
+    
+    const filterSensitiveLog: (obj: ImportJobResponse) => any;
+}
+export interface CreateImportJobResponse {
+    
+    ImportJobResponse: ImportJobResponse | undefined;
+}
+export declare namespace CreateImportJobResponse {
+    
+    const filterSensitiveLog: (obj: CreateImportJobResponse) => any;
+}
+
+export interface InAppTemplateRequest {
+    
+    Content?: InAppMessageContent[];
+    
+    CustomConfig?: {
+        [key: string]: string;
+    };
+    
+    Layout?: Layout | string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    TemplateDescription?: string;
+}
+export declare namespace InAppTemplateRequest {
+    
+    const filterSensitiveLog: (obj: InAppTemplateRequest) => any;
+}
+export interface CreateInAppTemplateRequest {
+    
+    InAppTemplateRequest: InAppTemplateRequest | undefined;
+    
+    TemplateName: string | undefined;
+}
+export declare namespace CreateInAppTemplateRequest {
+    
+    const filterSensitiveLog: (obj: CreateInAppTemplateRequest) => any;
+}
+
+export interface TemplateCreateMessageBody {
+    
+    Arn?: string;
+    
+    Message?: string;
+    
+    RequestID?: string;
+}
+export declare namespace TemplateCreateMessageBody {
+    
+    const filterSensitiveLog: (obj: TemplateCreateMessageBody) => any;
+}
+export interface CreateInAppTemplateResponse {
+    
+    TemplateCreateMessageBody: TemplateCreateMessageBody | undefined;
+}
+export declare namespace CreateInAppTemplateResponse {
+    
+    const filterSensitiveLog: (obj: CreateInAppTemplateResponse) => any;
+}
+
+export interface JourneyChannelSettings {
+    
+    ConnectCampaignArn?: string;
+    
+    ConnectCampaignExecutionRoleArn?: string;
+}
+export declare namespace JourneyChannelSettings {
+    
+    const filterSensitiveLog: (obj: JourneyChannelSettings) => any;
+}
+
+export interface JourneyLimits {
+    
+    DailyCap?: number;
+    
+    EndpointReentryCap?: number;
+    
+    MessagesPerSecond?: number;
+    
+    EndpointReentryInterval?: string;
+}
+export declare namespace JourneyLimits {
+    
+    const filterSensitiveLog: (obj: JourneyLimits) => any;
+}
+
+export interface JourneySchedule {
+    
+    EndTime?: Date;
+    
+    StartTime?: Date;
+    
+    Timezone?: string;
+}
+export declare namespace JourneySchedule {
+    
+    const filterSensitiveLog: (obj: JourneySchedule) => any;
+}
+
+export interface EventFilter {
+    
+    Dimensions: EventDimensions | undefined;
+    
+    FilterType: FilterType | string | undefined;
+}
+export declare namespace EventFilter {
+    
+    const filterSensitiveLog: (obj: EventFilter) => any;
+}
+
+export interface EventStartCondition {
+    
+    EventFilter?: EventFilter;
+    SegmentId?: string;
+}
+export declare namespace EventStartCondition {
+    
+    const filterSensitiveLog: (obj: EventStartCondition) => any;
+}
+
+export interface StartCondition {
+    
+    Description?: string;
+    
+    EventStartCondition?: EventStartCondition;
+    
+    SegmentStartCondition?: SegmentCondition;
+}
+export declare namespace StartCondition {
+    
+    const filterSensitiveLog: (obj: StartCondition) => any;
+}
+export declare enum State {
+    ACTIVE = "ACTIVE",
+    CANCELLED = "CANCELLED",
+    CLOSED = "CLOSED",
+    COMPLETED = "COMPLETED",
+    DRAFT = "DRAFT",
+    PAUSED = "PAUSED"
+}
+
+export interface WriteJourneyRequest {
+    
+    Activities?: {
+        [key: string]: Activity;
+    };
+    
+    CreationDate?: string;
+    
+    LastModifiedDate?: string;
+    
+    Limits?: JourneyLimits;
+    
+    LocalTime?: boolean;
+    
+    Name: string | undefined;
+    
+    QuietTime?: QuietTime;
+    
+    RefreshFrequency?: string;
+    
+    Schedule?: JourneySchedule;
+    
+    StartActivity?: string;
+    
+    StartCondition?: StartCondition;
+    
+    State?: State | string;
+    
+    WaitForQuietTime?: boolean;
+    
+    RefreshOnSegmentUpdate?: boolean;
+    
+    JourneyChannelSettings?: JourneyChannelSettings;
+}
+export declare namespace WriteJourneyRequest {
+    
+    const filterSensitiveLog: (obj: WriteJourneyRequest) => any;
+}
+export interface CreateJourneyRequest {
+    
+    ApplicationId: string | undefined;
+    
+    WriteJourneyRequest: WriteJourneyRequest | undefined;
+}
+export declare namespace CreateJourneyRequest {
+    
+    const filterSensitiveLog: (obj: CreateJourneyRequest) => any;
+}
+
+export interface JourneyResponse {
+    
+    Activities?: {
+        [key: string]: Activity;
+    };
+    
+    ApplicationId: string | undefined;
+    
+    CreationDate?: string;
+    
+    Id: string | undefined;
+    
+    LastModifiedDate?: string;
+    
+    Limits?: JourneyLimits;
+    
+    LocalTime?: boolean;
+    
+    Name: string | undefined;
+    
+    QuietTime?: QuietTime;
+    
+    RefreshFrequency?: string;
+    
+    Schedule?: JourneySchedule;
+    
+    StartActivity?: string;
+    
+    StartCondition?: StartCondition;
+    
+    State?: State | string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    WaitForQuietTime?: boolean;
+    
+    RefreshOnSegmentUpdate?: boolean;
+    
+    JourneyChannelSettings?: JourneyChannelSettings;
+}
+export declare namespace JourneyResponse {
+    
+    const filterSensitiveLog: (obj: JourneyResponse) => any;
+}
+export interface CreateJourneyResponse {
+    
+    JourneyResponse: JourneyResponse | undefined;
+}
+export declare namespace CreateJourneyResponse {
+    
+    const filterSensitiveLog: (obj: CreateJourneyResponse) => any;
+}
+
+export interface DefaultPushNotificationTemplate {
+    
+    Action?: Action | string;
+    
+    Body?: string;
+    
+    Sound?: string;
+    
+    Title?: string;
+    
+    Url?: string;
+}
+export declare namespace DefaultPushNotificationTemplate {
+    
+    const filterSensitiveLog: (obj: DefaultPushNotificationTemplate) => any;
+}
+
+export interface PushNotificationTemplateRequest {
+    
+    ADM?: AndroidPushNotificationTemplate;
+    
+    APNS?: APNSPushNotificationTemplate;
+    
+    Baidu?: AndroidPushNotificationTemplate;
+    
+    Default?: DefaultPushNotificationTemplate;
+    
+    DefaultSubstitutions?: string;
+    
+    GCM?: AndroidPushNotificationTemplate;
+    
+    RecommenderId?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    TemplateDescription?: string;
+}
+export declare namespace PushNotificationTemplateRequest {
+    
+    const filterSensitiveLog: (obj: PushNotificationTemplateRequest) => any;
+}
+export interface CreatePushTemplateRequest {
+    
+    PushNotificationTemplateRequest: PushNotificationTemplateRequest | undefined;
+    
+    TemplateName: string | undefined;
+}
+export declare namespace CreatePushTemplateRequest {
+    
+    const filterSensitiveLog: (obj: CreatePushTemplateRequest) => any;
+}
+export interface CreatePushTemplateResponse {
+    
+    CreateTemplateMessageBody: CreateTemplateMessageBody | undefined;
+}
+export declare namespace CreatePushTemplateResponse {
+    
+    const filterSensitiveLog: (obj: CreatePushTemplateResponse) => any;
+}
+
+export interface CreateRecommenderConfigurationShape {
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+    
+    Description?: string;
+    
+    Name?: string;
+    
+    RecommendationProviderIdType?: string;
+    
+    RecommendationProviderRoleArn: string | undefined;
+    
+    RecommendationProviderUri: string | undefined;
+    
+    RecommendationTransformerUri?: string;
+    
+    RecommendationsDisplayName?: string;
+    
+    RecommendationsPerMessage?: number;
+}
+export declare namespace CreateRecommenderConfigurationShape {
+    
+    const filterSensitiveLog: (obj: CreateRecommenderConfigurationShape) => any;
+}
+export interface CreateRecommenderConfigurationRequest {
+    
+    CreateRecommenderConfiguration: CreateRecommenderConfigurationShape | undefined;
+}
+export declare namespace CreateRecommenderConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: CreateRecommenderConfigurationRequest) => any;
+}
+
+export interface RecommenderConfigurationResponse {
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+    
+    CreationDate: string | undefined;
+    
+    Description?: string;
+    
+    Id: string | undefined;
+    
+    LastModifiedDate: string | undefined;
+    
+    Name?: string;
+    
+    RecommendationProviderIdType?: string;
+    
+    RecommendationProviderRoleArn: string | undefined;
+    
+    RecommendationProviderUri: string | undefined;
+    
+    RecommendationTransformerUri?: string;
+    
+    RecommendationsDisplayName?: string;
+    
+    RecommendationsPerMessage?: number;
+}
+export declare namespace RecommenderConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: RecommenderConfigurationResponse) => any;
+}
+export interface CreateRecommenderConfigurationResponse {
+    
+    RecommenderConfigurationResponse: RecommenderConfigurationResponse | undefined;
+}
+export declare namespace CreateRecommenderConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: CreateRecommenderConfigurationResponse) => any;
+}
+
+export interface SegmentReference {
+    
+    Id: string | undefined;
+    
+    Version?: number;
+}
+export declare namespace SegmentReference {
+    
+    const filterSensitiveLog: (obj: SegmentReference) => any;
+}
+export declare enum SourceType {
+    ALL = "ALL",
+    ANY = "ANY",
+    NONE = "NONE"
+}
+export declare enum Type {
+    ALL = "ALL",
+    ANY = "ANY",
+    NONE = "NONE"
+}
+
+export interface SegmentGroup {
+    
+    Dimensions?: SegmentDimensions[];
+    
+    SourceSegments?: SegmentReference[];
+    
+    SourceType?: SourceType | string;
+    
+    Type?: Type | string;
+}
+export declare namespace SegmentGroup {
+    
+    const filterSensitiveLog: (obj: SegmentGroup) => any;
+}
+export declare enum Include {
+    ALL = "ALL",
+    ANY = "ANY",
+    NONE = "NONE"
+}
+
+export interface SegmentGroupList {
+    
+    Groups?: SegmentGroup[];
+    
+    Include?: Include | string;
+}
+export declare namespace SegmentGroupList {
+    
+    const filterSensitiveLog: (obj: SegmentGroupList) => any;
+}
+
+export interface WriteSegmentRequest {
+    
+    Dimensions?: SegmentDimensions;
+    
+    Name?: string;
+    
+    SegmentGroups?: SegmentGroupList;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace WriteSegmentRequest {
+    
+    const filterSensitiveLog: (obj: WriteSegmentRequest) => any;
+}
+export interface CreateSegmentRequest {
+    
+    ApplicationId: string | undefined;
+    
+    WriteSegmentRequest: WriteSegmentRequest | undefined;
+}
+export declare namespace CreateSegmentRequest {
+    
+    const filterSensitiveLog: (obj: CreateSegmentRequest) => any;
+}
+
+export interface SegmentImportResource {
+    
+    ChannelCounts?: {
+        [key: string]: number;
+    };
+    
+    ExternalId: string | undefined;
+    
+    Format: Format | string | undefined;
+    
+    RoleArn: string | undefined;
+    
+    S3Url: string | undefined;
+    
+    Size: number | undefined;
+}
+export declare namespace SegmentImportResource {
+    
+    const filterSensitiveLog: (obj: SegmentImportResource) => any;
+}
+export declare enum SegmentType {
+    DIMENSIONAL = "DIMENSIONAL",
+    IMPORT = "IMPORT"
+}
+
+export interface SegmentResponse {
+    
+    ApplicationId: string | undefined;
+    
+    Arn: string | undefined;
+    
+    CreationDate: string | undefined;
+    
+    Dimensions?: SegmentDimensions;
+    
+    Id: string | undefined;
+    
+    ImportDefinition?: SegmentImportResource;
+    
+    LastModifiedDate?: string;
+    
+    Name?: string;
+    
+    SegmentGroups?: SegmentGroupList;
+    
+    SegmentType: SegmentType | string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    Version?: number;
+}
+export declare namespace SegmentResponse {
+    
+    const filterSensitiveLog: (obj: SegmentResponse) => any;
+}
+export interface CreateSegmentResponse {
+    
+    SegmentResponse: SegmentResponse | undefined;
+}
+export declare namespace CreateSegmentResponse {
+    
+    const filterSensitiveLog: (obj: CreateSegmentResponse) => any;
+}
+
+export interface SMSTemplateRequest {
+    
+    Body?: string;
+    
+    DefaultSubstitutions?: string;
+    
+    RecommenderId?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    TemplateDescription?: string;
+}
+export declare namespace SMSTemplateRequest {
+    
+    const filterSensitiveLog: (obj: SMSTemplateRequest) => any;
+}
+export interface CreateSmsTemplateRequest {
+    
+    SMSTemplateRequest: SMSTemplateRequest | undefined;
+    
+    TemplateName: string | undefined;
+}
+export declare namespace CreateSmsTemplateRequest {
+    
+    const filterSensitiveLog: (obj: CreateSmsTemplateRequest) => any;
+}
+export interface CreateSmsTemplateResponse {
+    
+    CreateTemplateMessageBody: CreateTemplateMessageBody | undefined;
+}
+export declare namespace CreateSmsTemplateResponse {
+    
+    const filterSensitiveLog: (obj: CreateSmsTemplateResponse) => any;
+}
+
+export interface VoiceTemplateRequest {
+    
+    Body?: string;
+    
+    DefaultSubstitutions?: string;
+    
+    LanguageCode?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    TemplateDescription?: string;
+    
+    VoiceId?: string;
+}
+export declare namespace VoiceTemplateRequest {
+    
+    const filterSensitiveLog: (obj: VoiceTemplateRequest) => any;
+}
+export interface CreateVoiceTemplateRequest {
+    
+    TemplateName: string | undefined;
+    
+    VoiceTemplateRequest: VoiceTemplateRequest | undefined;
+}
+export declare namespace CreateVoiceTemplateRequest {
+    
+    const filterSensitiveLog: (obj: CreateVoiceTemplateRequest) => any;
+}
+export interface CreateVoiceTemplateResponse {
+    
+    CreateTemplateMessageBody: CreateTemplateMessageBody | undefined;
+}
+export declare namespace CreateVoiceTemplateResponse {
+    
+    const filterSensitiveLog: (obj: CreateVoiceTemplateResponse) => any;
+}
+
+export interface DefaultMessage {
+    
+    Body?: string;
+    
+    Substitutions?: {
+        [key: string]: string[];
+    };
+}
+export declare namespace DefaultMessage {
+    
+    const filterSensitiveLog: (obj: DefaultMessage) => any;
+}
+
+export interface DefaultPushNotificationMessage {
+    
+    Action?: Action | string;
+    
+    Body?: string;
+    
+    Data?: {
+        [key: string]: string;
+    };
+    
+    SilentPush?: boolean;
+    
+    Substitutions?: {
+        [key: string]: string[];
+    };
+    
+    Title?: string;
+    
+    Url?: string;
+}
+export declare namespace DefaultPushNotificationMessage {
+    
+    const filterSensitiveLog: (obj: DefaultPushNotificationMessage) => any;
+}
+export interface DeleteAdmChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace DeleteAdmChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAdmChannelRequest) => any;
+}
+export interface DeleteAdmChannelResponse {
+    
+    ADMChannelResponse: ADMChannelResponse | undefined;
+}
+export declare namespace DeleteAdmChannelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteAdmChannelResponse) => any;
+}
+export interface DeleteApnsChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace DeleteApnsChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApnsChannelRequest) => any;
+}
+export interface DeleteApnsChannelResponse {
+    
+    APNSChannelResponse: APNSChannelResponse | undefined;
+}
+export declare namespace DeleteApnsChannelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApnsChannelResponse) => any;
+}
+export interface DeleteApnsSandboxChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace DeleteApnsSandboxChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApnsSandboxChannelRequest) => any;
+}
+export interface DeleteApnsSandboxChannelResponse {
+    
+    APNSSandboxChannelResponse: APNSSandboxChannelResponse | undefined;
+}
+export declare namespace DeleteApnsSandboxChannelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApnsSandboxChannelResponse) => any;
+}
+export interface DeleteApnsVoipChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace DeleteApnsVoipChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApnsVoipChannelRequest) => any;
+}
+export interface DeleteApnsVoipChannelResponse {
+    
+    APNSVoipChannelResponse: APNSVoipChannelResponse | undefined;
+}
+export declare namespace DeleteApnsVoipChannelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApnsVoipChannelResponse) => any;
+}
+export interface DeleteApnsVoipSandboxChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace DeleteApnsVoipSandboxChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteApnsVoipSandboxChannelRequest) => any;
+}
+export interface DeleteApnsVoipSandboxChannelResponse {
+    
+    APNSVoipSandboxChannelResponse: APNSVoipSandboxChannelResponse | undefined;
+}
+export declare namespace DeleteApnsVoipSandboxChannelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteApnsVoipSandboxChannelResponse) => any;
+}
+export interface DeleteAppRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace DeleteAppRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAppRequest) => any;
+}
+export interface DeleteAppResponse {
+    
+    ApplicationResponse: ApplicationResponse | undefined;
+}
+export declare namespace DeleteAppResponse {
+    
+    const filterSensitiveLog: (obj: DeleteAppResponse) => any;
+}
+export interface DeleteBaiduChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace DeleteBaiduChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteBaiduChannelRequest) => any;
+}
+export interface DeleteBaiduChannelResponse {
+    
+    BaiduChannelResponse: BaiduChannelResponse | undefined;
+}
+export declare namespace DeleteBaiduChannelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteBaiduChannelResponse) => any;
+}
+export interface DeleteCampaignRequest {
+    
+    ApplicationId: string | undefined;
+    
+    CampaignId: string | undefined;
+}
+export declare namespace DeleteCampaignRequest {
+    
+    const filterSensitiveLog: (obj: DeleteCampaignRequest) => any;
+}
+export interface DeleteCampaignResponse {
+    
+    CampaignResponse: CampaignResponse | undefined;
+}
+export declare namespace DeleteCampaignResponse {
+    
+    const filterSensitiveLog: (obj: DeleteCampaignResponse) => any;
+}
+export interface DeleteEmailChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace DeleteEmailChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEmailChannelRequest) => any;
+}
+
+export interface EmailChannelResponse {
+    
+    ApplicationId?: string;
+    
+    ConfigurationSet?: string;
+    
+    CreationDate?: string;
+    
+    Enabled?: boolean;
+    
+    FromAddress?: string;
+    
+    HasCredential?: boolean;
+    
+    Id?: string;
+    
+    Identity?: string;
+    
+    IsArchived?: boolean;
+    
+    LastModifiedBy?: string;
+    
+    LastModifiedDate?: string;
+    
+    MessagesPerSecond?: number;
+    
+    Platform: string | undefined;
+    
+    RoleArn?: string;
+    
+    Version?: number;
+}
+export declare namespace EmailChannelResponse {
+    
+    const filterSensitiveLog: (obj: EmailChannelResponse) => any;
+}
+export interface DeleteEmailChannelResponse {
+    
+    EmailChannelResponse: EmailChannelResponse | undefined;
+}
+export declare namespace DeleteEmailChannelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteEmailChannelResponse) => any;
+}
+export interface DeleteEmailTemplateRequest {
+    
+    TemplateName: string | undefined;
+    
+    Version?: string;
+}
+export declare namespace DeleteEmailTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEmailTemplateRequest) => any;
+}
+
+export interface MessageBody {
+    
+    Message?: string;
+    
+    RequestID?: string;
+}
+export declare namespace MessageBody {
+    
+    const filterSensitiveLog: (obj: MessageBody) => any;
+}
+export interface DeleteEmailTemplateResponse {
+    
+    MessageBody: MessageBody | undefined;
+}
+export declare namespace DeleteEmailTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DeleteEmailTemplateResponse) => any;
+}
+export interface DeleteEndpointRequest {
+    
+    ApplicationId: string | undefined;
+    
+    EndpointId: string | undefined;
+}
+export declare namespace DeleteEndpointRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEndpointRequest) => any;
+}
+
+export interface EndpointDemographic {
+    
+    AppVersion?: string;
+    
+    Locale?: string;
+    
+    Make?: string;
+    
+    Model?: string;
+    
+    ModelVersion?: string;
+    
+    Platform?: string;
+    
+    PlatformVersion?: string;
+    
+    Timezone?: string;
+}
+export declare namespace EndpointDemographic {
+    
+    const filterSensitiveLog: (obj: EndpointDemographic) => any;
+}
+
+export interface EndpointLocation {
+    
+    City?: string;
+    
+    Country?: string;
+    
+    Latitude?: number;
+    
+    Longitude?: number;
+    
+    PostalCode?: string;
+    
+    Region?: string;
+}
+export declare namespace EndpointLocation {
+    
+    const filterSensitiveLog: (obj: EndpointLocation) => any;
+}
+
+export interface EndpointUser {
+    
+    UserAttributes?: {
+        [key: string]: string[];
+    };
+    
+    UserId?: string;
+}
+export declare namespace EndpointUser {
+    
+    const filterSensitiveLog: (obj: EndpointUser) => any;
+}
+
+export interface EndpointResponse {
+    
+    Address?: string;
+    
+    ApplicationId?: string;
+    
+    Attributes?: {
+        [key: string]: string[];
+    };
+    
+    ChannelType?: ChannelType | string;
+    
+    CohortId?: string;
+    
+    CreationDate?: string;
+    
+    Demographic?: EndpointDemographic;
+    
+    EffectiveDate?: string;
+    
+    EndpointStatus?: string;
+    
+    Id?: string;
+    
+    Location?: EndpointLocation;
+    
+    Metrics?: {
+        [key: string]: number;
+    };
+    
+    OptOut?: string;
+    
+    RequestId?: string;
+    
+    User?: EndpointUser;
+}
+export declare namespace EndpointResponse {
+    
+    const filterSensitiveLog: (obj: EndpointResponse) => any;
+}
+export interface DeleteEndpointResponse {
+    
+    EndpointResponse: EndpointResponse | undefined;
+}
+export declare namespace DeleteEndpointResponse {
+    
+    const filterSensitiveLog: (obj: DeleteEndpointResponse) => any;
+}
+export interface DeleteEventStreamRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace DeleteEventStreamRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEventStreamRequest) => any;
+}
+
+export interface EventStream {
+    
+    ApplicationId: string | undefined;
+    
+    DestinationStreamArn: string | undefined;
+    
+    ExternalId?: string;
+    
+    LastModifiedDate?: string;
+    
+    LastUpdatedBy?: string;
+    
+    RoleArn: string | undefined;
+}
+export declare namespace EventStream {
+    
+    const filterSensitiveLog: (obj: EventStream) => any;
+}
+export interface DeleteEventStreamResponse {
+    
+    EventStream: EventStream | undefined;
+}
+export declare namespace DeleteEventStreamResponse {
+    
+    const filterSensitiveLog: (obj: DeleteEventStreamResponse) => any;
+}
+export interface DeleteGcmChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace DeleteGcmChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteGcmChannelRequest) => any;
+}
+
+export interface GCMChannelResponse {
+    
+    ApplicationId?: string;
+    
+    CreationDate?: string;
+    
+    Credential: string | undefined;
+    
+    Enabled?: boolean;
+    
+    HasCredential?: boolean;
+    
+    Id?: string;
+    
+    IsArchived?: boolean;
+    
+    LastModifiedBy?: string;
+    
+    LastModifiedDate?: string;
+    
+    Platform: string | undefined;
+    
+    Version?: number;
+}
+export declare namespace GCMChannelResponse {
+    
+    const filterSensitiveLog: (obj: GCMChannelResponse) => any;
+}
+export interface DeleteGcmChannelResponse {
+    
+    GCMChannelResponse: GCMChannelResponse | undefined;
+}
+export declare namespace DeleteGcmChannelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteGcmChannelResponse) => any;
+}
+export interface DeleteInAppTemplateRequest {
+    
+    TemplateName: string | undefined;
+    
+    Version?: string;
+}
+export declare namespace DeleteInAppTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DeleteInAppTemplateRequest) => any;
+}
+export interface DeleteInAppTemplateResponse {
+    
+    MessageBody: MessageBody | undefined;
+}
+export declare namespace DeleteInAppTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DeleteInAppTemplateResponse) => any;
+}
+export interface DeleteJourneyRequest {
+    
+    ApplicationId: string | undefined;
+    
+    JourneyId: string | undefined;
+}
+export declare namespace DeleteJourneyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteJourneyRequest) => any;
+}
+export interface DeleteJourneyResponse {
+    
+    JourneyResponse: JourneyResponse | undefined;
+}
+export declare namespace DeleteJourneyResponse {
+    
+    const filterSensitiveLog: (obj: DeleteJourneyResponse) => any;
+}
+export interface DeletePushTemplateRequest {
+    
+    TemplateName: string | undefined;
+    
+    Version?: string;
+}
+export declare namespace DeletePushTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DeletePushTemplateRequest) => any;
+}
+export interface DeletePushTemplateResponse {
+    
+    MessageBody: MessageBody | undefined;
+}
+export declare namespace DeletePushTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DeletePushTemplateResponse) => any;
+}
+export interface DeleteRecommenderConfigurationRequest {
+    
+    RecommenderId: string | undefined;
+}
+export declare namespace DeleteRecommenderConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRecommenderConfigurationRequest) => any;
+}
+export interface DeleteRecommenderConfigurationResponse {
+    
+    RecommenderConfigurationResponse: RecommenderConfigurationResponse | undefined;
+}
+export declare namespace DeleteRecommenderConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteRecommenderConfigurationResponse) => any;
+}
+export interface DeleteSegmentRequest {
+    
+    ApplicationId: string | undefined;
+    
+    SegmentId: string | undefined;
+}
+export declare namespace DeleteSegmentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSegmentRequest) => any;
+}
+export interface DeleteSegmentResponse {
+    
+    SegmentResponse: SegmentResponse | undefined;
+}
+export declare namespace DeleteSegmentResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSegmentResponse) => any;
+}
+export interface DeleteSmsChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace DeleteSmsChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSmsChannelRequest) => any;
+}
+
+export interface SMSChannelResponse {
+    
+    ApplicationId?: string;
+    
+    CreationDate?: string;
+    
+    Enabled?: boolean;
+    
+    HasCredential?: boolean;
+    
+    Id?: string;
+    
+    IsArchived?: boolean;
+    
+    LastModifiedBy?: string;
+    
+    LastModifiedDate?: string;
+    
+    Platform: string | undefined;
+    
+    PromotionalMessagesPerSecond?: number;
+    
+    SenderId?: string;
+    
+    ShortCode?: string;
+    
+    TransactionalMessagesPerSecond?: number;
+    
+    Version?: number;
+}
+export declare namespace SMSChannelResponse {
+    
+    const filterSensitiveLog: (obj: SMSChannelResponse) => any;
+}
+export interface DeleteSmsChannelResponse {
+    
+    SMSChannelResponse: SMSChannelResponse | undefined;
+}
+export declare namespace DeleteSmsChannelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSmsChannelResponse) => any;
+}
+export interface DeleteSmsTemplateRequest {
+    
+    TemplateName: string | undefined;
+    
+    Version?: string;
+}
+export declare namespace DeleteSmsTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSmsTemplateRequest) => any;
+}
+export interface DeleteSmsTemplateResponse {
+    
+    MessageBody: MessageBody | undefined;
+}
+export declare namespace DeleteSmsTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSmsTemplateResponse) => any;
+}
+export interface DeleteUserEndpointsRequest {
+    
+    ApplicationId: string | undefined;
+    
+    UserId: string | undefined;
+}
+export declare namespace DeleteUserEndpointsRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUserEndpointsRequest) => any;
+}
+
+export interface EndpointsResponse {
+    
+    Item: EndpointResponse[] | undefined;
+}
+export declare namespace EndpointsResponse {
+    
+    const filterSensitiveLog: (obj: EndpointsResponse) => any;
+}
+export interface DeleteUserEndpointsResponse {
+    
+    EndpointsResponse: EndpointsResponse | undefined;
+}
+export declare namespace DeleteUserEndpointsResponse {
+    
+    const filterSensitiveLog: (obj: DeleteUserEndpointsResponse) => any;
+}
+export interface DeleteVoiceChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace DeleteVoiceChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVoiceChannelRequest) => any;
+}
+
+export interface VoiceChannelResponse {
+    
+    ApplicationId?: string;
+    
+    CreationDate?: string;
+    
+    Enabled?: boolean;
+    
+    HasCredential?: boolean;
+    
+    Id?: string;
+    
+    IsArchived?: boolean;
+    
+    LastModifiedBy?: string;
+    
+    LastModifiedDate?: string;
+    
+    Platform: string | undefined;
+    
+    Version?: number;
+}
+export declare namespace VoiceChannelResponse {
+    
+    const filterSensitiveLog: (obj: VoiceChannelResponse) => any;
+}
+export interface DeleteVoiceChannelResponse {
+    
+    VoiceChannelResponse: VoiceChannelResponse | undefined;
+}
+export declare namespace DeleteVoiceChannelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteVoiceChannelResponse) => any;
+}
+export interface DeleteVoiceTemplateRequest {
+    
+    TemplateName: string | undefined;
+    
+    Version?: string;
+}
+export declare namespace DeleteVoiceTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVoiceTemplateRequest) => any;
+}
+export interface DeleteVoiceTemplateResponse {
+    
+    MessageBody: MessageBody | undefined;
+}
+export declare namespace DeleteVoiceTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DeleteVoiceTemplateResponse) => any;
+}
+export declare enum DeliveryStatus {
+    DUPLICATE = "DUPLICATE",
+    OPT_OUT = "OPT_OUT",
+    PERMANENT_FAILURE = "PERMANENT_FAILURE",
+    SUCCESSFUL = "SUCCESSFUL",
+    TEMPORARY_FAILURE = "TEMPORARY_FAILURE",
+    THROTTLED = "THROTTLED",
+    UNKNOWN_FAILURE = "UNKNOWN_FAILURE"
+}
+
+export interface RawEmail {
+    
+    Data?: Uint8Array;
+}
+export declare namespace RawEmail {
+    
+    const filterSensitiveLog: (obj: RawEmail) => any;
+}
+
+export interface SimpleEmailPart {
+    
+    Charset?: string;
+    
+    Data?: string;
+}
+export declare namespace SimpleEmailPart {
+    
+    const filterSensitiveLog: (obj: SimpleEmailPart) => any;
+}
+
+export interface SimpleEmail {
+    
+    HtmlPart?: SimpleEmailPart;
+    
+    Subject?: SimpleEmailPart;
+    
+    TextPart?: SimpleEmailPart;
+}
+export declare namespace SimpleEmail {
+    
+    const filterSensitiveLog: (obj: SimpleEmail) => any;
+}
+
+export interface EmailMessage {
+    
+    Body?: string;
+    
+    FeedbackForwardingAddress?: string;
+    
+    FromAddress?: string;
+    
+    RawEmail?: RawEmail;
+    
+    ReplyToAddresses?: string[];
+    
+    SimpleEmail?: SimpleEmail;
+    
+    Substitutions?: {
+        [key: string]: string[];
+    };
+}
+export declare namespace EmailMessage {
+    
+    const filterSensitiveLog: (obj: EmailMessage) => any;
+}
+
+export interface GCMMessage {
+    
+    Action?: Action | string;
+    
+    Body?: string;
+    
+    CollapseKey?: string;
+    
+    Data?: {
+        [key: string]: string;
+    };
+    
+    IconReference?: string;
+    
+    ImageIconUrl?: string;
+    
+    ImageUrl?: string;
+    
+    Priority?: string;
+    
+    RawContent?: string;
+    
+    RestrictedPackageName?: string;
+    
+    SilentPush?: boolean;
+    
+    SmallImageIconUrl?: string;
+    
+    Sound?: string;
+    
+    Substitutions?: {
+        [key: string]: string[];
+    };
+    
+    TimeToLive?: number;
+    
+    Title?: string;
+    
+    Url?: string;
+}
+export declare namespace GCMMessage {
+    
+    const filterSensitiveLog: (obj: GCMMessage) => any;
+}
+
+export interface SMSMessage {
+    
+    Body?: string;
+    
+    Keyword?: string;
+    
+    MediaUrl?: string;
+    
+    MessageType?: MessageType | string;
+    
+    OriginationNumber?: string;
+    
+    SenderId?: string;
+    
+    Substitutions?: {
+        [key: string]: string[];
+    };
+    
+    EntityId?: string;
+    
+    TemplateId?: string;
+}
+export declare namespace SMSMessage {
+    
+    const filterSensitiveLog: (obj: SMSMessage) => any;
+}
+
+export interface VoiceMessage {
+    
+    Body?: string;
+    
+    LanguageCode?: string;
+    
+    OriginationNumber?: string;
+    
+    Substitutions?: {
+        [key: string]: string[];
+    };
+    
+    VoiceId?: string;
+}
+export declare namespace VoiceMessage {
+    
+    const filterSensitiveLog: (obj: VoiceMessage) => any;
+}
+
+export interface DirectMessageConfiguration {
+    
+    ADMMessage?: ADMMessage;
+    
+    APNSMessage?: APNSMessage;
+    
+    BaiduMessage?: BaiduMessage;
+    
+    DefaultMessage?: DefaultMessage;
+    
+    DefaultPushNotificationMessage?: DefaultPushNotificationMessage;
+    
+    EmailMessage?: EmailMessage;
+    
+    GCMMessage?: GCMMessage;
+    
+    SMSMessage?: SMSMessage;
+    
+    VoiceMessage?: VoiceMessage;
+}
+export declare namespace DirectMessageConfiguration {
+    
+    const filterSensitiveLog: (obj: DirectMessageConfiguration) => any;
+}
+
+export interface EmailChannelRequest {
+    
+    ConfigurationSet?: string;
+    
+    Enabled?: boolean;
+    
+    FromAddress: string | undefined;
+    
+    Identity: string | undefined;
+    
+    RoleArn?: string;
+}
+export declare namespace EmailChannelRequest {
+    
+    const filterSensitiveLog: (obj: EmailChannelRequest) => any;
+}
+export declare enum TemplateType {
+    EMAIL = "EMAIL",
+    INAPP = "INAPP",
+    PUSH = "PUSH",
+    SMS = "SMS",
+    VOICE = "VOICE"
+}
+
+export interface EmailTemplateResponse {
+    
+    Arn?: string;
+    
+    CreationDate: string | undefined;
+    
+    DefaultSubstitutions?: string;
+    
+    HtmlPart?: string;
+    
+    LastModifiedDate: string | undefined;
+    
+    RecommenderId?: string;
+    
+    Subject?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    TemplateDescription?: string;
+    
+    TemplateName: string | undefined;
+    
+    TemplateType: TemplateType | string | undefined;
+    
+    TextPart?: string;
+    
+    Version?: string;
+}
+export declare namespace EmailTemplateResponse {
+    
+    const filterSensitiveLog: (obj: EmailTemplateResponse) => any;
+}
+
+export interface EndpointBatchItem {
+    
+    Address?: string;
+    
+    Attributes?: {
+        [key: string]: string[];
+    };
+    
+    ChannelType?: ChannelType | string;
+    
+    Demographic?: EndpointDemographic;
+    
+    EffectiveDate?: string;
+    
+    EndpointStatus?: string;
+    
+    Id?: string;
+    
+    Location?: EndpointLocation;
+    
+    Metrics?: {
+        [key: string]: number;
+    };
+    
+    OptOut?: string;
+    
+    RequestId?: string;
+    
+    User?: EndpointUser;
+}
+export declare namespace EndpointBatchItem {
+    
+    const filterSensitiveLog: (obj: EndpointBatchItem) => any;
+}
+
+export interface EndpointBatchRequest {
+    
+    Item: EndpointBatchItem[] | undefined;
+}
+export declare namespace EndpointBatchRequest {
+    
+    const filterSensitiveLog: (obj: EndpointBatchRequest) => any;
+}
+
+export interface EndpointItemResponse {
+    
+    Message?: string;
+    
+    StatusCode?: number;
+}
+export declare namespace EndpointItemResponse {
+    
+    const filterSensitiveLog: (obj: EndpointItemResponse) => any;
+}
+
+export interface EndpointMessageResult {
+    
+    Address?: string;
+    
+    DeliveryStatus: DeliveryStatus | string | undefined;
+    
+    MessageId?: string;
+    
+    StatusCode: number | undefined;
+    
+    StatusMessage?: string;
+    
+    UpdatedToken?: string;
+}
+export declare namespace EndpointMessageResult {
+    
+    const filterSensitiveLog: (obj: EndpointMessageResult) => any;
+}
+
+export interface EndpointRequest {
+    
+    Address?: string;
+    
+    Attributes?: {
+        [key: string]: string[];
+    };
+    
+    ChannelType?: ChannelType | string;
+    
+    Demographic?: EndpointDemographic;
+    
+    EffectiveDate?: string;
+    
+    EndpointStatus?: string;
+    
+    Location?: EndpointLocation;
+    
+    Metrics?: {
+        [key: string]: number;
+    };
+    
+    OptOut?: string;
+    
+    RequestId?: string;
+    
+    User?: EndpointUser;
+}
+export declare namespace EndpointRequest {
+    
+    const filterSensitiveLog: (obj: EndpointRequest) => any;
+}
+
+export interface EndpointSendConfiguration {
+    
+    BodyOverride?: string;
+    
+    Context?: {
+        [key: string]: string;
+    };
+    
+    RawContent?: string;
+    
+    Substitutions?: {
+        [key: string]: string[];
+    };
+    
+    TitleOverride?: string;
+}
+export declare namespace EndpointSendConfiguration {
+    
+    const filterSensitiveLog: (obj: EndpointSendConfiguration) => any;
+}
+
+export interface Session {
+    
+    Duration?: number;
+    
+    Id: string | undefined;
+    
+    StartTimestamp: string | undefined;
+    
+    StopTimestamp?: string;
+}
+export declare namespace Session {
+    
+    const filterSensitiveLog: (obj: Session) => any;
+}
+
+export interface Event {
+    
+    AppPackageName?: string;
+    
+    AppTitle?: string;
+    
+    AppVersionCode?: string;
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+    
+    ClientSdkVersion?: string;
+    
+    EventType: string | undefined;
+    
+    Metrics?: {
+        [key: string]: number;
+    };
+    
+    SdkName?: string;
+    
+    Session?: Session;
+    
+    Timestamp: string | undefined;
+}
+export declare namespace Event {
+    
+    const filterSensitiveLog: (obj: Event) => any;
+}
+
+export interface EventItemResponse {
+    
+    Message?: string;
+    
+    StatusCode?: number;
+}
+export declare namespace EventItemResponse {
+    
+    const filterSensitiveLog: (obj: EventItemResponse) => any;
+}
+
+export interface PublicEndpoint {
+    
+    Address?: string;
+    
+    Attributes?: {
+        [key: string]: string[];
+    };
+    
+    ChannelType?: ChannelType | string;
+    
+    Demographic?: EndpointDemographic;
+    
+    EffectiveDate?: string;
+    
+    EndpointStatus?: string;
+    
+    Location?: EndpointLocation;
+    
+    Metrics?: {
+        [key: string]: number;
+    };
+    
+    OptOut?: string;
+    
+    RequestId?: string;
+    
+    User?: EndpointUser;
+}
+export declare namespace PublicEndpoint {
+    
+    const filterSensitiveLog: (obj: PublicEndpoint) => any;
+}
+
+export interface EventsBatch {
+    
+    Endpoint: PublicEndpoint | undefined;
+    
+    Events: {
+        [key: string]: Event;
+    } | undefined;
+}
+export declare namespace EventsBatch {
+    
+    const filterSensitiveLog: (obj: EventsBatch) => any;
+}
+
+export interface EventsRequest {
+    
+    BatchItem: {
+        [key: string]: EventsBatch;
+    } | undefined;
+}
+export declare namespace EventsRequest {
+    
+    const filterSensitiveLog: (obj: EventsRequest) => any;
+}
+
+export interface ItemResponse {
+    
+    EndpointItemResponse?: EndpointItemResponse;
+    
+    EventsItemResponse?: {
+        [key: string]: EventItemResponse;
+    };
+}
+export declare namespace ItemResponse {
+    
+    const filterSensitiveLog: (obj: ItemResponse) => any;
+}
+
+export interface EventsResponse {
+    
+    Results?: {
+        [key: string]: ItemResponse;
+    };
+}
+export declare namespace EventsResponse {
+    
+    const filterSensitiveLog: (obj: EventsResponse) => any;
+}
+
+export interface ExportJobsResponse {
+    
+    Item: ExportJobResponse[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ExportJobsResponse {
+    
+    const filterSensitiveLog: (obj: ExportJobsResponse) => any;
+}
+
+export interface GCMChannelRequest {
+    
+    ApiKey: string | undefined;
+    
+    Enabled?: boolean;
+}
+export declare namespace GCMChannelRequest {
+    
+    const filterSensitiveLog: (obj: GCMChannelRequest) => any;
+}
+export interface GetAdmChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace GetAdmChannelRequest {
+    
+    const filterSensitiveLog: (obj: GetAdmChannelRequest) => any;
+}
+export interface GetAdmChannelResponse {
+    
+    ADMChannelResponse: ADMChannelResponse | undefined;
+}
+export declare namespace GetAdmChannelResponse {
+    
+    const filterSensitiveLog: (obj: GetAdmChannelResponse) => any;
+}
+export interface GetApnsChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace GetApnsChannelRequest {
+    
+    const filterSensitiveLog: (obj: GetApnsChannelRequest) => any;
+}
+export interface GetApnsChannelResponse {
+    
+    APNSChannelResponse: APNSChannelResponse | undefined;
+}
+export declare namespace GetApnsChannelResponse {
+    
+    const filterSensitiveLog: (obj: GetApnsChannelResponse) => any;
+}
+export interface GetApnsSandboxChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace GetApnsSandboxChannelRequest {
+    
+    const filterSensitiveLog: (obj: GetApnsSandboxChannelRequest) => any;
+}
+export interface GetApnsSandboxChannelResponse {
+    
+    APNSSandboxChannelResponse: APNSSandboxChannelResponse | undefined;
+}
+export declare namespace GetApnsSandboxChannelResponse {
+    
+    const filterSensitiveLog: (obj: GetApnsSandboxChannelResponse) => any;
+}
+export interface GetApnsVoipChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace GetApnsVoipChannelRequest {
+    
+    const filterSensitiveLog: (obj: GetApnsVoipChannelRequest) => any;
+}
+export interface GetApnsVoipChannelResponse {
+    
+    APNSVoipChannelResponse: APNSVoipChannelResponse | undefined;
+}
+export declare namespace GetApnsVoipChannelResponse {
+    
+    const filterSensitiveLog: (obj: GetApnsVoipChannelResponse) => any;
+}
+export interface GetApnsVoipSandboxChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace GetApnsVoipSandboxChannelRequest {
+    
+    const filterSensitiveLog: (obj: GetApnsVoipSandboxChannelRequest) => any;
+}
+export interface GetApnsVoipSandboxChannelResponse {
+    
+    APNSVoipSandboxChannelResponse: APNSVoipSandboxChannelResponse | undefined;
+}
+export declare namespace GetApnsVoipSandboxChannelResponse {
+    
+    const filterSensitiveLog: (obj: GetApnsVoipSandboxChannelResponse) => any;
+}
+export interface GetAppRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace GetAppRequest {
+    
+    const filterSensitiveLog: (obj: GetAppRequest) => any;
+}
+export interface GetAppResponse {
+    
+    ApplicationResponse: ApplicationResponse | undefined;
+}
+export declare namespace GetAppResponse {
+    
+    const filterSensitiveLog: (obj: GetAppResponse) => any;
+}
+export interface GetApplicationDateRangeKpiRequest {
+    
+    ApplicationId: string | undefined;
+    
+    EndTime?: Date;
+    
+    KpiName: string | undefined;
+    
+    NextToken?: string;
+    
+    PageSize?: string;
+    
+    StartTime?: Date;
+}
+export declare namespace GetApplicationDateRangeKpiRequest {
+    
+    const filterSensitiveLog: (obj: GetApplicationDateRangeKpiRequest) => any;
+}
+export interface GetApplicationDateRangeKpiResponse {
+    
+    ApplicationDateRangeKpiResponse: ApplicationDateRangeKpiResponse | undefined;
+}
+export declare namespace GetApplicationDateRangeKpiResponse {
+    
+    const filterSensitiveLog: (obj: GetApplicationDateRangeKpiResponse) => any;
+}
+export interface GetApplicationSettingsRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace GetApplicationSettingsRequest {
+    
+    const filterSensitiveLog: (obj: GetApplicationSettingsRequest) => any;
+}
+export interface GetApplicationSettingsResponse {
+    
+    ApplicationSettingsResource: ApplicationSettingsResource | undefined;
+}
+export declare namespace GetApplicationSettingsResponse {
+    
+    const filterSensitiveLog: (obj: GetApplicationSettingsResponse) => any;
+}
+export interface GetAppsRequest {
+    
+    PageSize?: string;
+    
+    Token?: string;
+}
+export declare namespace GetAppsRequest {
+    
+    const filterSensitiveLog: (obj: GetAppsRequest) => any;
+}
+export interface GetAppsResponse {
+    
+    ApplicationsResponse: ApplicationsResponse | undefined;
+}
+export declare namespace GetAppsResponse {
+    
+    const filterSensitiveLog: (obj: GetAppsResponse) => any;
+}
+export interface GetBaiduChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace GetBaiduChannelRequest {
+    
+    const filterSensitiveLog: (obj: GetBaiduChannelRequest) => any;
+}
+export interface GetBaiduChannelResponse {
+    
+    BaiduChannelResponse: BaiduChannelResponse | undefined;
+}
+export declare namespace GetBaiduChannelResponse {
+    
+    const filterSensitiveLog: (obj: GetBaiduChannelResponse) => any;
+}
+export interface GetCampaignRequest {
+    
+    ApplicationId: string | undefined;
+    
+    CampaignId: string | undefined;
+}
+export declare namespace GetCampaignRequest {
+    
+    const filterSensitiveLog: (obj: GetCampaignRequest) => any;
+}
+export interface GetCampaignResponse {
+    
+    CampaignResponse: CampaignResponse | undefined;
+}
+export declare namespace GetCampaignResponse {
+    
+    const filterSensitiveLog: (obj: GetCampaignResponse) => any;
+}
+export interface GetCampaignActivitiesRequest {
+    
+    ApplicationId: string | undefined;
+    
+    CampaignId: string | undefined;
+    
+    PageSize?: string;
+    
+    Token?: string;
+}
+export declare namespace GetCampaignActivitiesRequest {
+    
+    const filterSensitiveLog: (obj: GetCampaignActivitiesRequest) => any;
+}
+export interface GetCampaignActivitiesResponse {
+    
+    ActivitiesResponse: ActivitiesResponse | undefined;
+}
+export declare namespace GetCampaignActivitiesResponse {
+    
+    const filterSensitiveLog: (obj: GetCampaignActivitiesResponse) => any;
+}
+export interface GetCampaignDateRangeKpiRequest {
+    
+    ApplicationId: string | undefined;
+    
+    CampaignId: string | undefined;
+    
+    EndTime?: Date;
+    
+    KpiName: string | undefined;
+    
+    NextToken?: string;
+    
+    PageSize?: string;
+    
+    StartTime?: Date;
+}
+export declare namespace GetCampaignDateRangeKpiRequest {
+    
+    const filterSensitiveLog: (obj: GetCampaignDateRangeKpiRequest) => any;
+}
+export interface GetCampaignDateRangeKpiResponse {
+    
+    CampaignDateRangeKpiResponse: CampaignDateRangeKpiResponse | undefined;
+}
+export declare namespace GetCampaignDateRangeKpiResponse {
+    
+    const filterSensitiveLog: (obj: GetCampaignDateRangeKpiResponse) => any;
+}
+export interface GetCampaignsRequest {
+    
+    ApplicationId: string | undefined;
+    
+    PageSize?: string;
+    
+    Token?: string;
+}
+export declare namespace GetCampaignsRequest {
+    
+    const filterSensitiveLog: (obj: GetCampaignsRequest) => any;
+}
+export interface GetCampaignsResponse {
+    
+    CampaignsResponse: CampaignsResponse | undefined;
+}
+export declare namespace GetCampaignsResponse {
+    
+    const filterSensitiveLog: (obj: GetCampaignsResponse) => any;
+}
+export interface GetCampaignVersionRequest {
+    
+    ApplicationId: string | undefined;
+    
+    CampaignId: string | undefined;
+    
+    Version: string | undefined;
+}
+export declare namespace GetCampaignVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetCampaignVersionRequest) => any;
+}
+export interface GetCampaignVersionResponse {
+    
+    CampaignResponse: CampaignResponse | undefined;
+}
+export declare namespace GetCampaignVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetCampaignVersionResponse) => any;
+}
+export interface GetCampaignVersionsRequest {
+    
+    ApplicationId: string | undefined;
+    
+    CampaignId: string | undefined;
+    
+    PageSize?: string;
+    
+    Token?: string;
+}
+export declare namespace GetCampaignVersionsRequest {
+    
+    const filterSensitiveLog: (obj: GetCampaignVersionsRequest) => any;
+}
+export interface GetCampaignVersionsResponse {
+    
+    CampaignsResponse: CampaignsResponse | undefined;
+}
+export declare namespace GetCampaignVersionsResponse {
+    
+    const filterSensitiveLog: (obj: GetCampaignVersionsResponse) => any;
+}
+export interface GetChannelsRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace GetChannelsRequest {
+    
+    const filterSensitiveLog: (obj: GetChannelsRequest) => any;
+}
+export interface GetChannelsResponse {
+    
+    ChannelsResponse: ChannelsResponse | undefined;
+}
+export declare namespace GetChannelsResponse {
+    
+    const filterSensitiveLog: (obj: GetChannelsResponse) => any;
+}
+export interface GetEmailChannelRequest {
+    
+    ApplicationId: string | undefined;
+}
+export declare namespace GetEmailChannelRequest {
+    
+    const filterSensitiveLog: (obj: GetEmailChannelRequest) => any;
+}
+export interface GetEmailChannelResponse {
+    
+    EmailChannelResponse: EmailChannelResponse | undefined;
+}
+export declare namespace GetEmailChannelResponse {
+    
+    const filterSensitiveLog: (obj: GetEmailChannelResponse) => any;
+}
+export interface GetEmailTemplateRequest {
+    
+    TemplateName: string | undefined;
+    
+    Version?: string;
+}
+export declare namespace GetEmailTemplateRequest {
+    
+    const filterSensitiveLog: (obj: GetEmailTemplateRequest) => any;
+}