@aws-sdk/client-sns 3.50.0 → 3.53.0

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

@@ -0,0 +1,1134 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { SNSServiceException as __BaseException } from "./SNSServiceException";
+export interface AddPermissionInput {
+    
+    TopicArn: string | undefined;
+    
+    Label: string | undefined;
+    
+    AWSAccountId: string[] | undefined;
+    
+    ActionName: string[] | undefined;
+}
+export declare namespace AddPermissionInput {
+    
+    const filterSensitiveLog: (obj: AddPermissionInput) => any;
+}
+
+export declare class AuthorizationErrorException extends __BaseException {
+    readonly name: "AuthorizationErrorException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AuthorizationErrorException, __BaseException>);
+}
+
+export declare class InternalErrorException extends __BaseException {
+    readonly name: "InternalErrorException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<InternalErrorException, __BaseException>);
+}
+
+export declare class InvalidParameterException extends __BaseException {
+    readonly name: "InvalidParameterException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterException, __BaseException>);
+}
+
+export declare class NotFoundException extends __BaseException {
+    readonly name: "NotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NotFoundException, __BaseException>);
+}
+
+export interface CheckIfPhoneNumberIsOptedOutInput {
+    
+    phoneNumber: string | undefined;
+}
+export declare namespace CheckIfPhoneNumberIsOptedOutInput {
+    
+    const filterSensitiveLog: (obj: CheckIfPhoneNumberIsOptedOutInput) => any;
+}
+
+export interface CheckIfPhoneNumberIsOptedOutResponse {
+    
+    isOptedOut?: boolean;
+}
+export declare namespace CheckIfPhoneNumberIsOptedOutResponse {
+    
+    const filterSensitiveLog: (obj: CheckIfPhoneNumberIsOptedOutResponse) => any;
+}
+
+export declare class ThrottledException extends __BaseException {
+    readonly name: "ThrottledException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ThrottledException, __BaseException>);
+}
+
+export interface ConfirmSubscriptionInput {
+    
+    TopicArn: string | undefined;
+    
+    Token: string | undefined;
+    
+    AuthenticateOnUnsubscribe?: string;
+}
+export declare namespace ConfirmSubscriptionInput {
+    
+    const filterSensitiveLog: (obj: ConfirmSubscriptionInput) => any;
+}
+
+export interface ConfirmSubscriptionResponse {
+    
+    SubscriptionArn?: string;
+}
+export declare namespace ConfirmSubscriptionResponse {
+    
+    const filterSensitiveLog: (obj: ConfirmSubscriptionResponse) => any;
+}
+
+export declare class FilterPolicyLimitExceededException extends __BaseException {
+    readonly name: "FilterPolicyLimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<FilterPolicyLimitExceededException, __BaseException>);
+}
+
+export declare class SubscriptionLimitExceededException extends __BaseException {
+    readonly name: "SubscriptionLimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubscriptionLimitExceededException, __BaseException>);
+}
+
+export interface CreatePlatformApplicationInput {
+    
+    Name: string | undefined;
+    
+    Platform: string | undefined;
+    
+    Attributes: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace CreatePlatformApplicationInput {
+    
+    const filterSensitiveLog: (obj: CreatePlatformApplicationInput) => any;
+}
+
+export interface CreatePlatformApplicationResponse {
+    
+    PlatformApplicationArn?: string;
+}
+export declare namespace CreatePlatformApplicationResponse {
+    
+    const filterSensitiveLog: (obj: CreatePlatformApplicationResponse) => any;
+}
+
+export interface CreateEndpointResponse {
+    
+    EndpointArn?: string;
+}
+export declare namespace CreateEndpointResponse {
+    
+    const filterSensitiveLog: (obj: CreateEndpointResponse) => any;
+}
+
+export interface CreatePlatformEndpointInput {
+    
+    PlatformApplicationArn: string | undefined;
+    
+    Token: string | undefined;
+    
+    CustomUserData?: string;
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreatePlatformEndpointInput {
+    
+    const filterSensitiveLog: (obj: CreatePlatformEndpointInput) => any;
+}
+export declare enum LanguageCodeString {
+    de_DE = "de-DE",
+    en_GB = "en-GB",
+    en_US = "en-US",
+    es_419 = "es-419",
+    es_ES = "es-ES",
+    fr_CA = "fr-CA",
+    fr_FR = "fr-FR",
+    it_IT = "it-IT",
+    jp_JP = "ja-JP",
+    kr_KR = "kr-KR",
+    pt_BR = "pt-BR",
+    zh_CN = "zh-CN",
+    zh_TW = "zh-TW"
+}
+export interface CreateSMSSandboxPhoneNumberInput {
+    
+    PhoneNumber: string | undefined;
+    
+    LanguageCode?: LanguageCodeString | string;
+}
+export declare namespace CreateSMSSandboxPhoneNumberInput {
+    
+    const filterSensitiveLog: (obj: CreateSMSSandboxPhoneNumberInput) => any;
+}
+export interface CreateSMSSandboxPhoneNumberResult {
+}
+export declare namespace CreateSMSSandboxPhoneNumberResult {
+    
+    const filterSensitiveLog: (obj: CreateSMSSandboxPhoneNumberResult) => any;
+}
+
+export declare class OptedOutException extends __BaseException {
+    readonly name: "OptedOutException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OptedOutException, __BaseException>);
+}
+
+export declare class UserErrorException extends __BaseException {
+    readonly name: "UserErrorException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UserErrorException, __BaseException>);
+}
+
+export declare class ConcurrentAccessException extends __BaseException {
+    readonly name: "ConcurrentAccessException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ConcurrentAccessException, __BaseException>);
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface CreateTopicInput {
+    
+    Name: string | undefined;
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateTopicInput {
+    
+    const filterSensitiveLog: (obj: CreateTopicInput) => any;
+}
+
+export interface CreateTopicResponse {
+    
+    TopicArn?: string;
+}
+export declare namespace CreateTopicResponse {
+    
+    const filterSensitiveLog: (obj: CreateTopicResponse) => any;
+}
+
+export declare class InvalidSecurityException extends __BaseException {
+    readonly name: "InvalidSecurityException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSecurityException, __BaseException>);
+}
+
+export declare class StaleTagException extends __BaseException {
+    readonly name: "StaleTagException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<StaleTagException, __BaseException>);
+}
+
+export declare class TagLimitExceededException extends __BaseException {
+    readonly name: "TagLimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TagLimitExceededException, __BaseException>);
+}
+
+export declare class TagPolicyException extends __BaseException {
+    readonly name: "TagPolicyException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TagPolicyException, __BaseException>);
+}
+
+export declare class TopicLimitExceededException extends __BaseException {
+    readonly name: "TopicLimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TopicLimitExceededException, __BaseException>);
+}
+
+export interface DeleteEndpointInput {
+    
+    EndpointArn: string | undefined;
+}
+export declare namespace DeleteEndpointInput {
+    
+    const filterSensitiveLog: (obj: DeleteEndpointInput) => any;
+}
+
+export interface DeletePlatformApplicationInput {
+    
+    PlatformApplicationArn: string | undefined;
+}
+export declare namespace DeletePlatformApplicationInput {
+    
+    const filterSensitiveLog: (obj: DeletePlatformApplicationInput) => any;
+}
+export interface DeleteSMSSandboxPhoneNumberInput {
+    
+    PhoneNumber: string | undefined;
+}
+export declare namespace DeleteSMSSandboxPhoneNumberInput {
+    
+    const filterSensitiveLog: (obj: DeleteSMSSandboxPhoneNumberInput) => any;
+}
+export interface DeleteSMSSandboxPhoneNumberResult {
+}
+export declare namespace DeleteSMSSandboxPhoneNumberResult {
+    
+    const filterSensitiveLog: (obj: DeleteSMSSandboxPhoneNumberResult) => any;
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+export interface DeleteTopicInput {
+    
+    TopicArn: string | undefined;
+}
+export declare namespace DeleteTopicInput {
+    
+    const filterSensitiveLog: (obj: DeleteTopicInput) => any;
+}
+
+export interface GetEndpointAttributesInput {
+    
+    EndpointArn: string | undefined;
+}
+export declare namespace GetEndpointAttributesInput {
+    
+    const filterSensitiveLog: (obj: GetEndpointAttributesInput) => any;
+}
+
+export interface GetEndpointAttributesResponse {
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetEndpointAttributesResponse {
+    
+    const filterSensitiveLog: (obj: GetEndpointAttributesResponse) => any;
+}
+
+export interface GetPlatformApplicationAttributesInput {
+    
+    PlatformApplicationArn: string | undefined;
+}
+export declare namespace GetPlatformApplicationAttributesInput {
+    
+    const filterSensitiveLog: (obj: GetPlatformApplicationAttributesInput) => any;
+}
+
+export interface GetPlatformApplicationAttributesResponse {
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetPlatformApplicationAttributesResponse {
+    
+    const filterSensitiveLog: (obj: GetPlatformApplicationAttributesResponse) => any;
+}
+
+export interface GetSMSAttributesInput {
+    
+    attributes?: string[];
+}
+export declare namespace GetSMSAttributesInput {
+    
+    const filterSensitiveLog: (obj: GetSMSAttributesInput) => any;
+}
+
+export interface GetSMSAttributesResponse {
+    
+    attributes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetSMSAttributesResponse {
+    
+    const filterSensitiveLog: (obj: GetSMSAttributesResponse) => any;
+}
+export interface GetSMSSandboxAccountStatusInput {
+}
+export declare namespace GetSMSSandboxAccountStatusInput {
+    
+    const filterSensitiveLog: (obj: GetSMSSandboxAccountStatusInput) => any;
+}
+export interface GetSMSSandboxAccountStatusResult {
+    
+    IsInSandbox: boolean | undefined;
+}
+export declare namespace GetSMSSandboxAccountStatusResult {
+    
+    const filterSensitiveLog: (obj: GetSMSSandboxAccountStatusResult) => any;
+}
+
+export interface GetSubscriptionAttributesInput {
+    
+    SubscriptionArn: string | undefined;
+}
+export declare namespace GetSubscriptionAttributesInput {
+    
+    const filterSensitiveLog: (obj: GetSubscriptionAttributesInput) => any;
+}
+
+export interface GetSubscriptionAttributesResponse {
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetSubscriptionAttributesResponse {
+    
+    const filterSensitiveLog: (obj: GetSubscriptionAttributesResponse) => any;
+}
+
+export interface GetTopicAttributesInput {
+    
+    TopicArn: string | undefined;
+}
+export declare namespace GetTopicAttributesInput {
+    
+    const filterSensitiveLog: (obj: GetTopicAttributesInput) => any;
+}
+
+export interface GetTopicAttributesResponse {
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetTopicAttributesResponse {
+    
+    const filterSensitiveLog: (obj: GetTopicAttributesResponse) => any;
+}
+
+export interface ListEndpointsByPlatformApplicationInput {
+    
+    PlatformApplicationArn: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListEndpointsByPlatformApplicationInput {
+    
+    const filterSensitiveLog: (obj: ListEndpointsByPlatformApplicationInput) => any;
+}
+
+export interface Endpoint {
+    
+    EndpointArn?: string;
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Endpoint {
+    
+    const filterSensitiveLog: (obj: Endpoint) => any;
+}
+
+export interface ListEndpointsByPlatformApplicationResponse {
+    
+    Endpoints?: Endpoint[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEndpointsByPlatformApplicationResponse {
+    
+    const filterSensitiveLog: (obj: ListEndpointsByPlatformApplicationResponse) => any;
+}
+export interface ListOriginationNumbersRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListOriginationNumbersRequest {
+    
+    const filterSensitiveLog: (obj: ListOriginationNumbersRequest) => any;
+}
+export declare enum NumberCapability {
+    MMS = "MMS",
+    SMS = "SMS",
+    VOICE = "VOICE"
+}
+export declare enum RouteType {
+    Premium = "Premium",
+    Promotional = "Promotional",
+    Transactional = "Transactional"
+}
+
+export interface PhoneNumberInformation {
+    
+    CreatedAt?: Date;
+    
+    PhoneNumber?: string;
+    
+    Status?: string;
+    
+    Iso2CountryCode?: string;
+    
+    RouteType?: RouteType | string;
+    
+    NumberCapabilities?: (NumberCapability | string)[];
+}
+export declare namespace PhoneNumberInformation {
+    
+    const filterSensitiveLog: (obj: PhoneNumberInformation) => any;
+}
+export interface ListOriginationNumbersResult {
+    
+    NextToken?: string;
+    
+    PhoneNumbers?: PhoneNumberInformation[];
+}
+export declare namespace ListOriginationNumbersResult {
+    
+    const filterSensitiveLog: (obj: ListOriginationNumbersResult) => any;
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+
+export interface ListPhoneNumbersOptedOutInput {
+    
+    nextToken?: string;
+}
+export declare namespace ListPhoneNumbersOptedOutInput {
+    
+    const filterSensitiveLog: (obj: ListPhoneNumbersOptedOutInput) => any;
+}
+
+export interface ListPhoneNumbersOptedOutResponse {
+    
+    phoneNumbers?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListPhoneNumbersOptedOutResponse {
+    
+    const filterSensitiveLog: (obj: ListPhoneNumbersOptedOutResponse) => any;
+}
+
+export interface ListPlatformApplicationsInput {
+    
+    NextToken?: string;
+}
+export declare namespace ListPlatformApplicationsInput {
+    
+    const filterSensitiveLog: (obj: ListPlatformApplicationsInput) => any;
+}
+
+export interface PlatformApplication {
+    
+    PlatformApplicationArn?: string;
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace PlatformApplication {
+    
+    const filterSensitiveLog: (obj: PlatformApplication) => any;
+}
+
+export interface ListPlatformApplicationsResponse {
+    
+    PlatformApplications?: PlatformApplication[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPlatformApplicationsResponse {
+    
+    const filterSensitiveLog: (obj: ListPlatformApplicationsResponse) => any;
+}
+export interface ListSMSSandboxPhoneNumbersInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListSMSSandboxPhoneNumbersInput {
+    
+    const filterSensitiveLog: (obj: ListSMSSandboxPhoneNumbersInput) => any;
+}
+export declare enum SMSSandboxPhoneNumberVerificationStatus {
+    Pending = "Pending",
+    Verified = "Verified"
+}
+
+export interface SMSSandboxPhoneNumber {
+    
+    PhoneNumber?: string;
+    
+    Status?: SMSSandboxPhoneNumberVerificationStatus | string;
+}
+export declare namespace SMSSandboxPhoneNumber {
+    
+    const filterSensitiveLog: (obj: SMSSandboxPhoneNumber) => any;
+}
+export interface ListSMSSandboxPhoneNumbersResult {
+    
+    PhoneNumbers: SMSSandboxPhoneNumber[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListSMSSandboxPhoneNumbersResult {
+    
+    const filterSensitiveLog: (obj: ListSMSSandboxPhoneNumbersResult) => any;
+}
+
+export interface ListSubscriptionsInput {
+    
+    NextToken?: string;
+}
+export declare namespace ListSubscriptionsInput {
+    
+    const filterSensitiveLog: (obj: ListSubscriptionsInput) => any;
+}
+
+export interface Subscription {
+    
+    SubscriptionArn?: string;
+    
+    Owner?: string;
+    
+    Protocol?: string;
+    
+    Endpoint?: string;
+    
+    TopicArn?: string;
+}
+export declare namespace Subscription {
+    
+    const filterSensitiveLog: (obj: Subscription) => any;
+}
+
+export interface ListSubscriptionsResponse {
+    
+    Subscriptions?: Subscription[];
+    
+    NextToken?: string;
+}
+export declare namespace ListSubscriptionsResponse {
+    
+    const filterSensitiveLog: (obj: ListSubscriptionsResponse) => any;
+}
+
+export interface ListSubscriptionsByTopicInput {
+    
+    TopicArn: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListSubscriptionsByTopicInput {
+    
+    const filterSensitiveLog: (obj: ListSubscriptionsByTopicInput) => any;
+}
+
+export interface ListSubscriptionsByTopicResponse {
+    
+    Subscriptions?: Subscription[];
+    
+    NextToken?: string;
+}
+export declare namespace ListSubscriptionsByTopicResponse {
+    
+    const filterSensitiveLog: (obj: ListSubscriptionsByTopicResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListTopicsInput {
+    
+    NextToken?: string;
+}
+export declare namespace ListTopicsInput {
+    
+    const filterSensitiveLog: (obj: ListTopicsInput) => any;
+}
+
+export interface Topic {
+    
+    TopicArn?: string;
+}
+export declare namespace Topic {
+    
+    const filterSensitiveLog: (obj: Topic) => any;
+}
+
+export interface ListTopicsResponse {
+    
+    Topics?: Topic[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTopicsResponse {
+    
+    const filterSensitiveLog: (obj: ListTopicsResponse) => any;
+}
+
+export interface OptInPhoneNumberInput {
+    
+    phoneNumber: string | undefined;
+}
+export declare namespace OptInPhoneNumberInput {
+    
+    const filterSensitiveLog: (obj: OptInPhoneNumberInput) => any;
+}
+
+export interface OptInPhoneNumberResponse {
+}
+export declare namespace OptInPhoneNumberResponse {
+    
+    const filterSensitiveLog: (obj: OptInPhoneNumberResponse) => any;
+}
+
+export declare class EndpointDisabledException extends __BaseException {
+    readonly name: "EndpointDisabledException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EndpointDisabledException, __BaseException>);
+}
+
+export declare class InvalidParameterValueException extends __BaseException {
+    readonly name: "InvalidParameterValueException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterValueException, __BaseException>);
+}
+
+export declare class KMSAccessDeniedException extends __BaseException {
+    readonly name: "KMSAccessDeniedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<KMSAccessDeniedException, __BaseException>);
+}
+
+export declare class KMSDisabledException extends __BaseException {
+    readonly name: "KMSDisabledException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<KMSDisabledException, __BaseException>);
+}
+
+export declare class KMSInvalidStateException extends __BaseException {
+    readonly name: "KMSInvalidStateException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<KMSInvalidStateException, __BaseException>);
+}
+
+export declare class KMSNotFoundException extends __BaseException {
+    readonly name: "KMSNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<KMSNotFoundException, __BaseException>);
+}
+
+export declare class KMSOptInRequired extends __BaseException {
+    readonly name: "KMSOptInRequired";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<KMSOptInRequired, __BaseException>);
+}
+
+export declare class KMSThrottlingException extends __BaseException {
+    readonly name: "KMSThrottlingException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<KMSThrottlingException, __BaseException>);
+}
+
+export declare class PlatformApplicationDisabledException extends __BaseException {
+    readonly name: "PlatformApplicationDisabledException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PlatformApplicationDisabledException, __BaseException>);
+}
+
+export interface MessageAttributeValue {
+    
+    DataType: string | undefined;
+    
+    StringValue?: string;
+    
+    BinaryValue?: Uint8Array;
+}
+export declare namespace MessageAttributeValue {
+    
+    const filterSensitiveLog: (obj: MessageAttributeValue) => any;
+}
+
+export interface PublishInput {
+    
+    TopicArn?: string;
+    
+    TargetArn?: string;
+    
+    PhoneNumber?: string;
+    
+    Message: string | undefined;
+    
+    Subject?: string;
+    
+    MessageStructure?: string;
+    
+    MessageAttributes?: {
+        [key: string]: MessageAttributeValue;
+    };
+    
+    MessageDeduplicationId?: string;
+    
+    MessageGroupId?: string;
+}
+export declare namespace PublishInput {
+    
+    const filterSensitiveLog: (obj: PublishInput) => any;
+}
+
+export interface PublishResponse {
+    
+    MessageId?: string;
+    
+    SequenceNumber?: string;
+}
+export declare namespace PublishResponse {
+    
+    const filterSensitiveLog: (obj: PublishResponse) => any;
+}
+
+export declare class BatchEntryIdsNotDistinctException extends __BaseException {
+    readonly name: "BatchEntryIdsNotDistinctException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BatchEntryIdsNotDistinctException, __BaseException>);
+}
+
+export declare class BatchRequestTooLongException extends __BaseException {
+    readonly name: "BatchRequestTooLongException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BatchRequestTooLongException, __BaseException>);
+}
+
+export declare class EmptyBatchRequestException extends __BaseException {
+    readonly name: "EmptyBatchRequestException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EmptyBatchRequestException, __BaseException>);
+}
+
+export declare class InvalidBatchEntryIdException extends __BaseException {
+    readonly name: "InvalidBatchEntryIdException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidBatchEntryIdException, __BaseException>);
+}
+
+export interface PublishBatchRequestEntry {
+    
+    Id: string | undefined;
+    
+    Message: string | undefined;
+    
+    Subject?: string;
+    
+    MessageStructure?: string;
+    
+    MessageAttributes?: {
+        [key: string]: MessageAttributeValue;
+    };
+    
+    MessageDeduplicationId?: string;
+    
+    MessageGroupId?: string;
+}
+export declare namespace PublishBatchRequestEntry {
+    
+    const filterSensitiveLog: (obj: PublishBatchRequestEntry) => any;
+}
+export interface PublishBatchInput {
+    
+    TopicArn: string | undefined;
+    
+    PublishBatchRequestEntries: PublishBatchRequestEntry[] | undefined;
+}
+export declare namespace PublishBatchInput {
+    
+    const filterSensitiveLog: (obj: PublishBatchInput) => any;
+}
+
+export interface BatchResultErrorEntry {
+    
+    Id: string | undefined;
+    
+    Code: string | undefined;
+    
+    Message?: string;
+    
+    SenderFault: boolean | undefined;
+}
+export declare namespace BatchResultErrorEntry {
+    
+    const filterSensitiveLog: (obj: BatchResultErrorEntry) => any;
+}
+
+export interface PublishBatchResultEntry {
+    
+    Id?: string;
+    
+    MessageId?: string;
+    
+    SequenceNumber?: string;
+}
+export declare namespace PublishBatchResultEntry {
+    
+    const filterSensitiveLog: (obj: PublishBatchResultEntry) => any;
+}
+export interface PublishBatchResponse {
+    
+    Successful?: PublishBatchResultEntry[];
+    
+    Failed?: BatchResultErrorEntry[];
+}
+export declare namespace PublishBatchResponse {
+    
+    const filterSensitiveLog: (obj: PublishBatchResponse) => any;
+}
+
+export declare class TooManyEntriesInBatchRequestException extends __BaseException {
+    readonly name: "TooManyEntriesInBatchRequestException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TooManyEntriesInBatchRequestException, __BaseException>);
+}
+
+export interface RemovePermissionInput {
+    
+    TopicArn: string | undefined;
+    
+    Label: string | undefined;
+}
+export declare namespace RemovePermissionInput {
+    
+    const filterSensitiveLog: (obj: RemovePermissionInput) => any;
+}
+
+export interface SetEndpointAttributesInput {
+    
+    EndpointArn: string | undefined;
+    
+    Attributes: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace SetEndpointAttributesInput {
+    
+    const filterSensitiveLog: (obj: SetEndpointAttributesInput) => any;
+}
+
+export interface SetPlatformApplicationAttributesInput {
+    
+    PlatformApplicationArn: string | undefined;
+    
+    Attributes: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace SetPlatformApplicationAttributesInput {
+    
+    const filterSensitiveLog: (obj: SetPlatformApplicationAttributesInput) => any;
+}
+
+export interface SetSMSAttributesInput {
+    
+    attributes: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace SetSMSAttributesInput {
+    
+    const filterSensitiveLog: (obj: SetSMSAttributesInput) => any;
+}
+
+export interface SetSMSAttributesResponse {
+}
+export declare namespace SetSMSAttributesResponse {
+    
+    const filterSensitiveLog: (obj: SetSMSAttributesResponse) => any;
+}
+
+export interface SetSubscriptionAttributesInput {
+    
+    SubscriptionArn: string | undefined;
+    
+    AttributeName: string | undefined;
+    
+    AttributeValue?: string;
+}
+export declare namespace SetSubscriptionAttributesInput {
+    
+    const filterSensitiveLog: (obj: SetSubscriptionAttributesInput) => any;
+}
+
+export interface SetTopicAttributesInput {
+    
+    TopicArn: string | undefined;
+    
+    AttributeName: string | undefined;
+    
+    AttributeValue?: string;
+}
+export declare namespace SetTopicAttributesInput {
+    
+    const filterSensitiveLog: (obj: SetTopicAttributesInput) => any;
+}
+
+export interface SubscribeInput {
+    
+    TopicArn: string | undefined;
+    
+    Protocol: string | undefined;
+    
+    Endpoint?: string;
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+    
+    ReturnSubscriptionArn?: boolean;
+}
+export declare namespace SubscribeInput {
+    
+    const filterSensitiveLog: (obj: SubscribeInput) => any;
+}
+
+export interface SubscribeResponse {
+    
+    SubscriptionArn?: string;
+}
+export declare namespace SubscribeResponse {
+    
+    const filterSensitiveLog: (obj: SubscribeResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+
+export interface UnsubscribeInput {
+    
+    SubscriptionArn: string | undefined;
+}
+export declare namespace UnsubscribeInput {
+    
+    const filterSensitiveLog: (obj: UnsubscribeInput) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+
+export declare class VerificationException extends __BaseException {
+    readonly name: "VerificationException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    Status: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<VerificationException, __BaseException>);
+}
+export interface VerifySMSSandboxPhoneNumberInput {
+    
+    PhoneNumber: string | undefined;
+    
+    OneTimePassword: string | undefined;
+}
+export declare namespace VerifySMSSandboxPhoneNumberInput {
+    
+    const filterSensitiveLog: (obj: VerifySMSSandboxPhoneNumberInput) => any;
+}
+
+export interface VerifySMSSandboxPhoneNumberResult {
+}
+export declare namespace VerifySMSSandboxPhoneNumberResult {
+    
+    const filterSensitiveLog: (obj: VerifySMSSandboxPhoneNumberResult) => any;
+}