@aws-sdk/client-pinpoint-sms-voice-v2 3.61.0

package/dist-types/commands/DisassociateOriginationIdentityCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DisassociateOriginationIdentityRequest, DisassociateOriginationIdentityResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface DisassociateOriginationIdentityCommandInput extends DisassociateOriginationIdentityRequest {
+}
+export interface DisassociateOriginationIdentityCommandOutput extends DisassociateOriginationIdentityResult, __MetadataBearer {
+}
+/**
+ * <p>Removes the specified origination identity from an existing pool.</p>
+ *         <p>If the origination identity isn't associated with the specified pool, an Error is
+ *             returned.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, DisassociateOriginationIdentityCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, DisassociateOriginationIdentityCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new DisassociateOriginationIdentityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisassociateOriginationIdentityCommandInput} for command's `input` shape.
+ * @see {@link DisassociateOriginationIdentityCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class DisassociateOriginationIdentityCommand extends $Command<DisassociateOriginationIdentityCommandInput, DisassociateOriginationIdentityCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: DisassociateOriginationIdentityCommandInput;
+    constructor(input: DisassociateOriginationIdentityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateOriginationIdentityCommandInput, DisassociateOriginationIdentityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListPoolOriginationIdentitiesCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListPoolOriginationIdentitiesRequest, ListPoolOriginationIdentitiesResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface ListPoolOriginationIdentitiesCommandInput extends ListPoolOriginationIdentitiesRequest {
+}
+export interface ListPoolOriginationIdentitiesCommandOutput extends ListPoolOriginationIdentitiesResult, __MetadataBearer {
+}
+/**
+ * <p>Lists all associated origination identities in your pool.</p>
+ *         <p>If you specify filters, the output includes information for only those origination
+ *             identities that meet the filter criteria.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, ListPoolOriginationIdentitiesCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, ListPoolOriginationIdentitiesCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new ListPoolOriginationIdentitiesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListPoolOriginationIdentitiesCommandInput} for command's `input` shape.
+ * @see {@link ListPoolOriginationIdentitiesCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class ListPoolOriginationIdentitiesCommand extends $Command<ListPoolOriginationIdentitiesCommandInput, ListPoolOriginationIdentitiesCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: ListPoolOriginationIdentitiesCommandInput;
+    constructor(input: ListPoolOriginationIdentitiesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPoolOriginationIdentitiesCommandInput, ListPoolOriginationIdentitiesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListTagsForResourceRequest, ListTagsForResourceResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResult, __MetadataBearer {
+}
+/**
+ * <p>List all tags associated with a resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, ListTagsForResourceCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, ListTagsForResourceCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutKeywordCommand.d.ts

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PutKeywordRequest, PutKeywordResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface PutKeywordCommandInput extends PutKeywordRequest {
+}
+export interface PutKeywordCommandOutput extends PutKeywordResult, __MetadataBearer {
+}
+/**
+ * <p>Creates or updates a keyword configuration on an origination phone number or
+ *             pool.</p>
+ *         <p> A keyword is a word that you can search for on a particular phone number or pool. It
+ *             is also a specific word or phrase that an end user can send to your number to elicit a
+ *             response, such as an informational message or a special offer. When your number receives
+ *             a message that begins with a keyword, Amazon Pinpoint responds with a customizable
+ *             message.</p>
+ *         <p>If you specify a keyword that isn't valid, an Error is returned.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, PutKeywordCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, PutKeywordCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new PutKeywordCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutKeywordCommandInput} for command's `input` shape.
+ * @see {@link PutKeywordCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class PutKeywordCommand extends $Command<PutKeywordCommandInput, PutKeywordCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: PutKeywordCommandInput;
+    constructor(input: PutKeywordCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutKeywordCommandInput, PutKeywordCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutOptedOutNumberCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PutOptedOutNumberRequest, PutOptedOutNumberResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface PutOptedOutNumberCommandInput extends PutOptedOutNumberRequest {
+}
+export interface PutOptedOutNumberCommandOutput extends PutOptedOutNumberResult, __MetadataBearer {
+}
+/**
+ * <p>Creates an opted out destination phone number in the opt-out list.</p>
+ *         <p>If the destination phone number isn't valid or if the specified opt-out list doesn't
+ *             exist, an Error is returned.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, PutOptedOutNumberCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, PutOptedOutNumberCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new PutOptedOutNumberCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutOptedOutNumberCommandInput} for command's `input` shape.
+ * @see {@link PutOptedOutNumberCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class PutOptedOutNumberCommand extends $Command<PutOptedOutNumberCommandInput, PutOptedOutNumberCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: PutOptedOutNumberCommandInput;
+    constructor(input: PutOptedOutNumberCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutOptedOutNumberCommandInput, PutOptedOutNumberCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ReleasePhoneNumberCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ReleasePhoneNumberRequest, ReleasePhoneNumberResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface ReleasePhoneNumberCommandInput extends ReleasePhoneNumberRequest {
+}
+export interface ReleasePhoneNumberCommandOutput extends ReleasePhoneNumberResult, __MetadataBearer {
+}
+/**
+ * <p>Releases an existing origination phone number in your account. Once released, a phone
+ *             number is no longer available for sending messages.</p>
+ *         <p>If the origination phone number has deletion protection enabled or is associated with
+ *             a pool, an Error is returned.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, ReleasePhoneNumberCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, ReleasePhoneNumberCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new ReleasePhoneNumberCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ReleasePhoneNumberCommandInput} for command's `input` shape.
+ * @see {@link ReleasePhoneNumberCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class ReleasePhoneNumberCommand extends $Command<ReleasePhoneNumberCommandInput, ReleasePhoneNumberCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: ReleasePhoneNumberCommandInput;
+    constructor(input: ReleasePhoneNumberCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReleasePhoneNumberCommandInput, ReleasePhoneNumberCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RequestPhoneNumberCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RequestPhoneNumberRequest, RequestPhoneNumberResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface RequestPhoneNumberCommandInput extends RequestPhoneNumberRequest {
+}
+export interface RequestPhoneNumberCommandOutput extends RequestPhoneNumberResult, __MetadataBearer {
+}
+/**
+ * <p>Request an origination phone number for use in your account. For more information on
+ *             phone number request see <a href="https://docs.aws.amazon.com/pinpoint/latest/userguide/settings-sms-request-number.html"> Requesting a
+ *                 number </a> in the <i>Amazon Pinpoint User Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, RequestPhoneNumberCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, RequestPhoneNumberCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new RequestPhoneNumberCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RequestPhoneNumberCommandInput} for command's `input` shape.
+ * @see {@link RequestPhoneNumberCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class RequestPhoneNumberCommand extends $Command<RequestPhoneNumberCommandInput, RequestPhoneNumberCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: RequestPhoneNumberCommandInput;
+    constructor(input: RequestPhoneNumberCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RequestPhoneNumberCommandInput, RequestPhoneNumberCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SendTextMessageCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SendTextMessageRequest, SendTextMessageResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface SendTextMessageCommandInput extends SendTextMessageRequest {
+}
+export interface SendTextMessageCommandOutput extends SendTextMessageResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a new text message and sends it to a recipient's phone number.</p>
+ *         <p>SMS throughput limits are measured in Message Parts per Second (MPS). Your MPS limit
+ *             depends on the destination country of your messages, as well as the type of phone number
+ *             (origination number) that you use to send the message. For more information, see <a href="https://docs.aws.amazon.com/pinpoint/latest/userguide/channels-sms-limitations-mps.html">Message Parts per
+ *                 Second (MPS) limits</a> in the <i>Amazon Pinpoint User
+ *                 Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, SendTextMessageCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, SendTextMessageCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new SendTextMessageCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SendTextMessageCommandInput} for command's `input` shape.
+ * @see {@link SendTextMessageCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class SendTextMessageCommand extends $Command<SendTextMessageCommandInput, SendTextMessageCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: SendTextMessageCommandInput;
+    constructor(input: SendTextMessageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendTextMessageCommandInput, SendTextMessageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SendVoiceMessageCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SendVoiceMessageRequest, SendVoiceMessageResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface SendVoiceMessageCommandInput extends SendVoiceMessageRequest {
+}
+export interface SendVoiceMessageCommandOutput extends SendVoiceMessageResult, __MetadataBearer {
+}
+/**
+ * <p>Allows you to send a request that sends a text message through Amazon Pinpoint.
+ *             This operation uses <a href="http://aws.amazon.com/polly/">Amazon Polly</a> to
+ *             convert a text script into a voice message.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, SendVoiceMessageCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, SendVoiceMessageCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new SendVoiceMessageCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SendVoiceMessageCommandInput} for command's `input` shape.
+ * @see {@link SendVoiceMessageCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class SendVoiceMessageCommand extends $Command<SendVoiceMessageCommandInput, SendVoiceMessageCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: SendVoiceMessageCommandInput;
+    constructor(input: SendVoiceMessageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendVoiceMessageCommandInput, SendVoiceMessageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SetDefaultMessageTypeCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SetDefaultMessageTypeRequest, SetDefaultMessageTypeResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface SetDefaultMessageTypeCommandInput extends SetDefaultMessageTypeRequest {
+}
+export interface SetDefaultMessageTypeCommandOutput extends SetDefaultMessageTypeResult, __MetadataBearer {
+}
+/**
+ * <p>Sets the default message type on a configuration set.</p>
+ *         <p>Choose the category of SMS messages that you plan to send from this account. If you
+ *             send account-related messages or time-sensitive messages such as one-time passcodes,
+ *             choose <b>Transactional</b>. If you plan to send messages that
+ *             contain marketing material or other promotional content, choose <b>Promotional</b>. This setting applies to your entire Amazon Web Services
+ *             account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, SetDefaultMessageTypeCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, SetDefaultMessageTypeCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new SetDefaultMessageTypeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetDefaultMessageTypeCommandInput} for command's `input` shape.
+ * @see {@link SetDefaultMessageTypeCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class SetDefaultMessageTypeCommand extends $Command<SetDefaultMessageTypeCommandInput, SetDefaultMessageTypeCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: SetDefaultMessageTypeCommandInput;
+    constructor(input: SetDefaultMessageTypeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetDefaultMessageTypeCommandInput, SetDefaultMessageTypeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SetDefaultSenderIdCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SetDefaultSenderIdRequest, SetDefaultSenderIdResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface SetDefaultSenderIdCommandInput extends SetDefaultSenderIdRequest {
+}
+export interface SetDefaultSenderIdCommandOutput extends SetDefaultSenderIdResult, __MetadataBearer {
+}
+/**
+ * <p>Sets default sender ID on a configuration set.</p>
+ *         <p>When sending a text message to a destination country that supports sender IDs, the
+ *             default sender ID on the configuration set specified will be used if no dedicated
+ *             origination phone numbers or registered sender IDs are available in your account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, SetDefaultSenderIdCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, SetDefaultSenderIdCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new SetDefaultSenderIdCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetDefaultSenderIdCommandInput} for command's `input` shape.
+ * @see {@link SetDefaultSenderIdCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class SetDefaultSenderIdCommand extends $Command<SetDefaultSenderIdCommandInput, SetDefaultSenderIdCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: SetDefaultSenderIdCommandInput;
+    constructor(input: SetDefaultSenderIdCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetDefaultSenderIdCommandInput, SetDefaultSenderIdCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SetTextMessageSpendLimitOverrideCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SetTextMessageSpendLimitOverrideRequest, SetTextMessageSpendLimitOverrideResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface SetTextMessageSpendLimitOverrideCommandInput extends SetTextMessageSpendLimitOverrideRequest {
+}
+export interface SetTextMessageSpendLimitOverrideCommandOutput extends SetTextMessageSpendLimitOverrideResult, __MetadataBearer {
+}
+/**
+ * <p>Sets an account level monthly spend limit override for sending text messages. The
+ *             requested spend limit must be less than or equal to the <code>MaxLimit</code>, which is
+ *             set by Amazon Web Services. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, SetTextMessageSpendLimitOverrideCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, SetTextMessageSpendLimitOverrideCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new SetTextMessageSpendLimitOverrideCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetTextMessageSpendLimitOverrideCommandInput} for command's `input` shape.
+ * @see {@link SetTextMessageSpendLimitOverrideCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class SetTextMessageSpendLimitOverrideCommand extends $Command<SetTextMessageSpendLimitOverrideCommandInput, SetTextMessageSpendLimitOverrideCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: SetTextMessageSpendLimitOverrideCommandInput;
+    constructor(input: SetTextMessageSpendLimitOverrideCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetTextMessageSpendLimitOverrideCommandInput, SetTextMessageSpendLimitOverrideCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SetVoiceMessageSpendLimitOverrideCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SetVoiceMessageSpendLimitOverrideRequest, SetVoiceMessageSpendLimitOverrideResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface SetVoiceMessageSpendLimitOverrideCommandInput extends SetVoiceMessageSpendLimitOverrideRequest {
+}
+export interface SetVoiceMessageSpendLimitOverrideCommandOutput extends SetVoiceMessageSpendLimitOverrideResult, __MetadataBearer {
+}
+/**
+ * <p>Sets an account level monthly spend limit override for sending voice messages. The
+ *             requested spend limit must be less than or equal to the <code>MaxLimit</code>, which is
+ *             set by Amazon Web Services. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, SetVoiceMessageSpendLimitOverrideCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, SetVoiceMessageSpendLimitOverrideCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new SetVoiceMessageSpendLimitOverrideCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetVoiceMessageSpendLimitOverrideCommandInput} for command's `input` shape.
+ * @see {@link SetVoiceMessageSpendLimitOverrideCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class SetVoiceMessageSpendLimitOverrideCommand extends $Command<SetVoiceMessageSpendLimitOverrideCommandInput, SetVoiceMessageSpendLimitOverrideCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: SetVoiceMessageSpendLimitOverrideCommandInput;
+    constructor(input: SetVoiceMessageSpendLimitOverrideCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetVoiceMessageSpendLimitOverrideCommandInput, SetVoiceMessageSpendLimitOverrideCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TagResourceCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { TagResourceRequest, TagResourceResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends TagResourceResult, __MetadataBearer {
+}
+/**
+ * <p>Adds or overwrites only the specified tags for the specified Amazon Pinpoint SMS
+ *             Voice, version 2 resource. When you specify an existing tag key, the value is
+ *             overwritten with the new value. Each resource can have a maximum of 50 tags. Each tag
+ *             consists of a key and an optional value. Tag keys must be unique per resource. For more
+ *             information about tags, see <a href="https://docs.aws.amazon.com/pinpoint/latest/developerguide/tagging-resources.html"> Tagging Amazon Pinpoint resources</a> in the <i>Amazon Pinpoint Developer
+ *                 Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, TagResourceCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, TagResourceCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UntagResourceCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UntagResourceRequest, UntagResourceResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface UntagResourceCommandInput extends UntagResourceRequest {
+}
+export interface UntagResourceCommandOutput extends UntagResourceResult, __MetadataBearer {
+}
+/**
+ * <p>Removes the association of the specified tags from an Amazon Pinpoint SMS Voice V2
+ *             resource. For more information on tags see <a href="https://docs.aws.amazon.com/pinpoint/latest/developerguide/tagging-resources.html"> Tagging Amazon Pinpoint resources</a> in the <i>Amazon Pinpoint Developer
+ *                 Guide</i>. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, UntagResourceCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, UntagResourceCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new UntagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UntagResourceCommandInput} for command's `input` shape.
+ * @see {@link UntagResourceCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: UntagResourceCommandInput;
+    constructor(input: UntagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateEventDestinationCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateEventDestinationRequest, UpdateEventDestinationResult } from "../models/models_0";
+import { PinpointSMSVoiceV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointSMSVoiceV2Client";
+export interface UpdateEventDestinationCommandInput extends UpdateEventDestinationRequest {
+}
+export interface UpdateEventDestinationCommandOutput extends UpdateEventDestinationResult, __MetadataBearer {
+}
+/**
+ * <p>Updates an existing event destination in a configuration set. You can update the
+ *                 IAM role ARN for CloudWatch Logs and Kinesis Data Firehose. You can
+ *             also enable or disable the event destination.</p>
+ *         <p>You may want to update an event destination to change its matching event types or
+ *             updating the destination resource ARN. You can't change an event destination's type
+ *             between CloudWatch Logs, Kinesis Data Firehose, and Amazon SNS.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointSMSVoiceV2Client, UpdateEventDestinationCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2"; // ES Modules import
+ * // const { PinpointSMSVoiceV2Client, UpdateEventDestinationCommand } = require("@aws-sdk/client-pinpoint-sms-voice-v2"); // CommonJS import
+ * const client = new PinpointSMSVoiceV2Client(config);
+ * const command = new UpdateEventDestinationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateEventDestinationCommandInput} for command's `input` shape.
+ * @see {@link UpdateEventDestinationCommandOutput} for command's `response` shape.
+ * @see {@link PinpointSMSVoiceV2ClientResolvedConfig | config} for PinpointSMSVoiceV2Client's `config` shape.
+ *
+ */
+export declare class UpdateEventDestinationCommand extends $Command<UpdateEventDestinationCommandInput, UpdateEventDestinationCommandOutput, PinpointSMSVoiceV2ClientResolvedConfig> {
+    readonly input: UpdateEventDestinationCommandInput;
+    constructor(input: UpdateEventDestinationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointSMSVoiceV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEventDestinationCommandInput, UpdateEventDestinationCommandOutput>;
+    private serialize;
+    private deserialize;
+}