@aws-sdk/client-chime 3.35.0 → 3.38.0

package/dist-types/ts3.4/commands/ListSupportedPhoneNumberCountriesCommand.d.ts

@@ -6,29 +6,11 @@ export interface ListSupportedPhoneNumberCountriesCommandInput extends ListSuppo
 }
 export interface ListSupportedPhoneNumberCountriesCommandOutput extends ListSupportedPhoneNumberCountriesResponse, __MetadataBearer {
 }
-/**
- * <p>Lists supported phone number countries.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, ListSupportedPhoneNumberCountriesCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, ListSupportedPhoneNumberCountriesCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new ListSupportedPhoneNumberCountriesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListSupportedPhoneNumberCountriesCommandInput} for command's `input` shape.
- * @see {@link ListSupportedPhoneNumberCountriesCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListSupportedPhoneNumberCountriesCommand extends $Command<ListSupportedPhoneNumberCountriesCommandInput, ListSupportedPhoneNumberCountriesCommandOutput, ChimeClientResolvedConfig> {
     readonly input: ListSupportedPhoneNumberCountriesCommandInput;
     constructor(input: ListSupportedPhoneNumberCountriesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSupportedPhoneNumberCountriesCommandInput, ListSupportedPhoneNumberCountriesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the tags applied to an Amazon Chime SDK meeting resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, ListTagsForResourceCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, ListTagsForResourceCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(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 ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, ChimeClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListUsersCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListUsersCommandInput extends ListUsersRequest {
 }
 export interface ListUsersCommandOutput extends ListUsersResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the users that belong to the specified Amazon Chime account. You can specify an email
- *             address to list only the user that the email address belongs to.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, ListUsersCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, ListUsersCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new ListUsersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListUsersCommandInput} for command's `input` shape.
- * @see {@link ListUsersCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListUsersCommand extends $Command<ListUsersCommandInput, ListUsersCommandOutput, ChimeClientResolvedConfig> {
     readonly input: ListUsersCommandInput;
     constructor(input: ListUsersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListUsersCommandInput, ListUsersCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListVoiceConnectorGroupsCommand.d.ts

@@ -6,29 +6,11 @@ export interface ListVoiceConnectorGroupsCommandInput extends ListVoiceConnector
 }
 export interface ListVoiceConnectorGroupsCommandOutput extends ListVoiceConnectorGroupsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the Amazon Chime Voice Connector groups for the administrator's AWS account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, ListVoiceConnectorGroupsCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, ListVoiceConnectorGroupsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new ListVoiceConnectorGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListVoiceConnectorGroupsCommandInput} for command's `input` shape.
- * @see {@link ListVoiceConnectorGroupsCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListVoiceConnectorGroupsCommand extends $Command<ListVoiceConnectorGroupsCommandInput, ListVoiceConnectorGroupsCommandOutput, ChimeClientResolvedConfig> {
     readonly input: ListVoiceConnectorGroupsCommandInput;
     constructor(input: ListVoiceConnectorGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListVoiceConnectorGroupsCommandInput, ListVoiceConnectorGroupsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListVoiceConnectorTerminationCredentialsCommand.d.ts

@@ -6,29 +6,11 @@ export interface ListVoiceConnectorTerminationCredentialsCommandInput extends Li
 }
 export interface ListVoiceConnectorTerminationCredentialsCommandOutput extends ListVoiceConnectorTerminationCredentialsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the SIP credentials for the specified Amazon Chime Voice Connector.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, ListVoiceConnectorTerminationCredentialsCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, ListVoiceConnectorTerminationCredentialsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new ListVoiceConnectorTerminationCredentialsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListVoiceConnectorTerminationCredentialsCommandInput} for command's `input` shape.
- * @see {@link ListVoiceConnectorTerminationCredentialsCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListVoiceConnectorTerminationCredentialsCommand extends $Command<ListVoiceConnectorTerminationCredentialsCommandInput, ListVoiceConnectorTerminationCredentialsCommandOutput, ChimeClientResolvedConfig> {
     readonly input: ListVoiceConnectorTerminationCredentialsCommandInput;
     constructor(input: ListVoiceConnectorTerminationCredentialsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListVoiceConnectorTerminationCredentialsCommandInput, ListVoiceConnectorTerminationCredentialsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListVoiceConnectorsCommand.d.ts

@@ -6,29 +6,11 @@ export interface ListVoiceConnectorsCommandInput extends ListVoiceConnectorsRequ
 }
 export interface ListVoiceConnectorsCommandOutput extends ListVoiceConnectorsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the Amazon Chime Voice Connectors for the administrator's AWS account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, ListVoiceConnectorsCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, ListVoiceConnectorsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new ListVoiceConnectorsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListVoiceConnectorsCommandInput} for command's `input` shape.
- * @see {@link ListVoiceConnectorsCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListVoiceConnectorsCommand extends $Command<ListVoiceConnectorsCommandInput, ListVoiceConnectorsCommandOutput, ChimeClientResolvedConfig> {
     readonly input: ListVoiceConnectorsCommandInput;
     constructor(input: ListVoiceConnectorsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListVoiceConnectorsCommandInput, ListVoiceConnectorsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/LogoutUserCommand.d.ts

@@ -6,29 +6,11 @@ export interface LogoutUserCommandInput extends LogoutUserRequest {
 }
 export interface LogoutUserCommandOutput extends LogoutUserResponse, __MetadataBearer {
 }
-/**
- * <p>Logs out the specified user from all of the devices they are currently logged into.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, LogoutUserCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, LogoutUserCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new LogoutUserCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link LogoutUserCommandInput} for command's `input` shape.
- * @see {@link LogoutUserCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class LogoutUserCommand extends $Command<LogoutUserCommandInput, LogoutUserCommandOutput, ChimeClientResolvedConfig> {
     readonly input: LogoutUserCommandInput;
     constructor(input: LogoutUserCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<LogoutUserCommandInput, LogoutUserCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutAppInstanceRetentionSettingsCommand.d.ts

@@ -6,29 +6,11 @@ export interface PutAppInstanceRetentionSettingsCommandInput extends PutAppInsta
 }
 export interface PutAppInstanceRetentionSettingsCommandOutput extends PutAppInstanceRetentionSettingsResponse, __MetadataBearer {
 }
-/**
- * <p>Sets the amount of time in days that a given <code>AppInstance</code> retains data.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, PutAppInstanceRetentionSettingsCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, PutAppInstanceRetentionSettingsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new PutAppInstanceRetentionSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutAppInstanceRetentionSettingsCommandInput} for command's `input` shape.
- * @see {@link PutAppInstanceRetentionSettingsCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutAppInstanceRetentionSettingsCommand extends $Command<PutAppInstanceRetentionSettingsCommandInput, PutAppInstanceRetentionSettingsCommandOutput, ChimeClientResolvedConfig> {
     readonly input: PutAppInstanceRetentionSettingsCommandInput;
     constructor(input: PutAppInstanceRetentionSettingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAppInstanceRetentionSettingsCommandInput, PutAppInstanceRetentionSettingsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutAppInstanceStreamingConfigurationsCommand.d.ts

@@ -6,29 +6,11 @@ export interface PutAppInstanceStreamingConfigurationsCommandInput extends PutAp
 }
 export interface PutAppInstanceStreamingConfigurationsCommandOutput extends PutAppInstanceStreamingConfigurationsResponse, __MetadataBearer {
 }
-/**
- * <p>The data streaming configurations of an <code>AppInstance</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, PutAppInstanceStreamingConfigurationsCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, PutAppInstanceStreamingConfigurationsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new PutAppInstanceStreamingConfigurationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutAppInstanceStreamingConfigurationsCommandInput} for command's `input` shape.
- * @see {@link PutAppInstanceStreamingConfigurationsCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutAppInstanceStreamingConfigurationsCommand extends $Command<PutAppInstanceStreamingConfigurationsCommandInput, PutAppInstanceStreamingConfigurationsCommandOutput, ChimeClientResolvedConfig> {
     readonly input: PutAppInstanceStreamingConfigurationsCommandInput;
     constructor(input: PutAppInstanceStreamingConfigurationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAppInstanceStreamingConfigurationsCommandInput, PutAppInstanceStreamingConfigurationsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutEventsConfigurationCommand.d.ts

@@ -6,31 +6,11 @@ export interface PutEventsConfigurationCommandInput extends PutEventsConfigurati
 }
 export interface PutEventsConfigurationCommandOutput extends PutEventsConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an events configuration that allows a bot to receive outgoing events sent by Amazon
- *             Chime. Choose either an HTTPS endpoint or a Lambda function ARN. For more information,
- *             see <a>Bot</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, PutEventsConfigurationCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, PutEventsConfigurationCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new PutEventsConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutEventsConfigurationCommandInput} for command's `input` shape.
- * @see {@link PutEventsConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutEventsConfigurationCommand extends $Command<PutEventsConfigurationCommandInput, PutEventsConfigurationCommandOutput, ChimeClientResolvedConfig> {
     readonly input: PutEventsConfigurationCommandInput;
     constructor(input: PutEventsConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutEventsConfigurationCommandInput, PutEventsConfigurationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutRetentionSettingsCommand.d.ts

@@ -6,41 +6,11 @@ export interface PutRetentionSettingsCommandInput extends PutRetentionSettingsRe
 }
 export interface PutRetentionSettingsCommandOutput extends PutRetentionSettingsResponse, __MetadataBearer {
 }
-/**
- * <p>
- * Puts retention settings for the specified Amazon Chime Enterprise account. We recommend using AWS CloudTrail to monitor usage of this API for your account. For more information, see
- * <a href="https://docs.aws.amazon.com/chime/latest/ag/cloudtrail.html">Logging Amazon Chime API Calls with AWS CloudTrail</a>
- * in the <i>Amazon Chime Administration Guide</i>.</p>
- *
- *          <p>
- * To turn off existing retention settings, remove the number of days from the corresponding
- * <b>RetentionDays</b>
- * field in the
- * <b>RetentionSettings</b>
- * object. For more information about retention settings, see
- * <a href="https://docs.aws.amazon.com/chime/latest/ag/chat-retention.html">Managing Chat Retention Policies</a>
- * in the <i>Amazon Chime Administration Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, PutRetentionSettingsCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, PutRetentionSettingsCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new PutRetentionSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutRetentionSettingsCommandInput} for command's `input` shape.
- * @see {@link PutRetentionSettingsCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutRetentionSettingsCommand extends $Command<PutRetentionSettingsCommandInput, PutRetentionSettingsCommandOutput, ChimeClientResolvedConfig> {
     readonly input: PutRetentionSettingsCommandInput;
     constructor(input: PutRetentionSettingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRetentionSettingsCommandInput, PutRetentionSettingsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutSipMediaApplicationLoggingConfigurationCommand.d.ts

@@ -6,29 +6,11 @@ export interface PutSipMediaApplicationLoggingConfigurationCommandInput extends
 }
 export interface PutSipMediaApplicationLoggingConfigurationCommandOutput extends PutSipMediaApplicationLoggingConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the logging configuration for the specified SIP media application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, PutSipMediaApplicationLoggingConfigurationCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, PutSipMediaApplicationLoggingConfigurationCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new PutSipMediaApplicationLoggingConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutSipMediaApplicationLoggingConfigurationCommandInput} for command's `input` shape.
- * @see {@link PutSipMediaApplicationLoggingConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutSipMediaApplicationLoggingConfigurationCommand extends $Command<PutSipMediaApplicationLoggingConfigurationCommandInput, PutSipMediaApplicationLoggingConfigurationCommandOutput, ChimeClientResolvedConfig> {
     readonly input: PutSipMediaApplicationLoggingConfigurationCommandInput;
     constructor(input: PutSipMediaApplicationLoggingConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutSipMediaApplicationLoggingConfigurationCommandInput, PutSipMediaApplicationLoggingConfigurationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutVoiceConnectorEmergencyCallingConfigurationCommand.d.ts

@@ -6,30 +6,11 @@ export interface PutVoiceConnectorEmergencyCallingConfigurationCommandInput exte
 }
 export interface PutVoiceConnectorEmergencyCallingConfigurationCommandOutput extends PutVoiceConnectorEmergencyCallingConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Puts emergency calling configuration details to the specified Amazon Chime Voice Connector, such as emergency phone numbers and calling countries. Origination and termination settings must be enabled for
- *     the Amazon Chime Voice Connector before emergency calling can be configured.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, PutVoiceConnectorEmergencyCallingConfigurationCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, PutVoiceConnectorEmergencyCallingConfigurationCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new PutVoiceConnectorEmergencyCallingConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutVoiceConnectorEmergencyCallingConfigurationCommandInput} for command's `input` shape.
- * @see {@link PutVoiceConnectorEmergencyCallingConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutVoiceConnectorEmergencyCallingConfigurationCommand extends $Command<PutVoiceConnectorEmergencyCallingConfigurationCommandInput, PutVoiceConnectorEmergencyCallingConfigurationCommandOutput, ChimeClientResolvedConfig> {
     readonly input: PutVoiceConnectorEmergencyCallingConfigurationCommandInput;
     constructor(input: PutVoiceConnectorEmergencyCallingConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutVoiceConnectorEmergencyCallingConfigurationCommandInput, PutVoiceConnectorEmergencyCallingConfigurationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutVoiceConnectorLoggingConfigurationCommand.d.ts

@@ -6,29 +6,11 @@ export interface PutVoiceConnectorLoggingConfigurationCommandInput extends PutVo
 }
 export interface PutVoiceConnectorLoggingConfigurationCommandOutput extends PutVoiceConnectorLoggingConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Adds a logging configuration for the specified Amazon Chime Voice Connector. The logging configuration specifies whether SIP message logs are enabled for sending to Amazon CloudWatch Logs.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, PutVoiceConnectorLoggingConfigurationCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, PutVoiceConnectorLoggingConfigurationCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new PutVoiceConnectorLoggingConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutVoiceConnectorLoggingConfigurationCommandInput} for command's `input` shape.
- * @see {@link PutVoiceConnectorLoggingConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutVoiceConnectorLoggingConfigurationCommand extends $Command<PutVoiceConnectorLoggingConfigurationCommandInput, PutVoiceConnectorLoggingConfigurationCommandOutput, ChimeClientResolvedConfig> {
     readonly input: PutVoiceConnectorLoggingConfigurationCommandInput;
     constructor(input: PutVoiceConnectorLoggingConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutVoiceConnectorLoggingConfigurationCommandInput, PutVoiceConnectorLoggingConfigurationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutVoiceConnectorOriginationCommand.d.ts

@@ -6,33 +6,11 @@ export interface PutVoiceConnectorOriginationCommandInput extends PutVoiceConnec
 }
 export interface PutVoiceConnectorOriginationCommandOutput extends PutVoiceConnectorOriginationResponse, __MetadataBearer {
 }
-/**
- * <p>Adds origination settings for the specified Amazon Chime Voice Connector.</p>
- *
- *          <note>
- *             <p>If emergency calling is configured for the Amazon Chime Voice Connector, it must be deleted prior to turning off origination settings.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, PutVoiceConnectorOriginationCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, PutVoiceConnectorOriginationCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new PutVoiceConnectorOriginationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutVoiceConnectorOriginationCommandInput} for command's `input` shape.
- * @see {@link PutVoiceConnectorOriginationCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutVoiceConnectorOriginationCommand extends $Command<PutVoiceConnectorOriginationCommandInput, PutVoiceConnectorOriginationCommandOutput, ChimeClientResolvedConfig> {
     readonly input: PutVoiceConnectorOriginationCommandInput;
     constructor(input: PutVoiceConnectorOriginationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutVoiceConnectorOriginationCommandInput, PutVoiceConnectorOriginationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutVoiceConnectorProxyCommand.d.ts

@@ -6,29 +6,11 @@ export interface PutVoiceConnectorProxyCommandInput extends PutVoiceConnectorPro
 }
 export interface PutVoiceConnectorProxyCommandOutput extends PutVoiceConnectorProxyResponse, __MetadataBearer {
 }
-/**
- * <p>Puts the specified proxy configuration to the specified Amazon Chime Voice Connector.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, PutVoiceConnectorProxyCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, PutVoiceConnectorProxyCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new PutVoiceConnectorProxyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutVoiceConnectorProxyCommandInput} for command's `input` shape.
- * @see {@link PutVoiceConnectorProxyCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutVoiceConnectorProxyCommand extends $Command<PutVoiceConnectorProxyCommandInput, PutVoiceConnectorProxyCommandOutput, ChimeClientResolvedConfig> {
     readonly input: PutVoiceConnectorProxyCommandInput;
     constructor(input: PutVoiceConnectorProxyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutVoiceConnectorProxyCommandInput, PutVoiceConnectorProxyCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutVoiceConnectorStreamingConfigurationCommand.d.ts

@@ -6,31 +6,11 @@ export interface PutVoiceConnectorStreamingConfigurationCommandInput extends Put
 }
 export interface PutVoiceConnectorStreamingConfigurationCommandOutput extends PutVoiceConnectorStreamingConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Adds a streaming configuration for the specified Amazon Chime Voice Connector. The streaming
- *             configuration specifies whether media streaming is enabled for sending to Indonesians.
- *             It also sets the retention period, in hours, for the Amazon Kinesis data.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, PutVoiceConnectorStreamingConfigurationCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, PutVoiceConnectorStreamingConfigurationCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new PutVoiceConnectorStreamingConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutVoiceConnectorStreamingConfigurationCommandInput} for command's `input` shape.
- * @see {@link PutVoiceConnectorStreamingConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutVoiceConnectorStreamingConfigurationCommand extends $Command<PutVoiceConnectorStreamingConfigurationCommandInput, PutVoiceConnectorStreamingConfigurationCommandOutput, ChimeClientResolvedConfig> {
     readonly input: PutVoiceConnectorStreamingConfigurationCommandInput;
     constructor(input: PutVoiceConnectorStreamingConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutVoiceConnectorStreamingConfigurationCommandInput, PutVoiceConnectorStreamingConfigurationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutVoiceConnectorTerminationCommand.d.ts

@@ -6,33 +6,11 @@ export interface PutVoiceConnectorTerminationCommandInput extends PutVoiceConnec
 }
 export interface PutVoiceConnectorTerminationCommandOutput extends PutVoiceConnectorTerminationResponse, __MetadataBearer {
 }
-/**
- * <p>Adds termination settings for the specified Amazon Chime Voice Connector.</p>
- *
- *          <note>
- *             <p>If emergency calling is configured for the Amazon Chime Voice Connector, it must be deleted prior to turning off termination settings.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ChimeClient, PutVoiceConnectorTerminationCommand } from "@aws-sdk/client-chime"; // ES Modules import
- * // const { ChimeClient, PutVoiceConnectorTerminationCommand } = require("@aws-sdk/client-chime"); // CommonJS import
- * const client = new ChimeClient(config);
- * const command = new PutVoiceConnectorTerminationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutVoiceConnectorTerminationCommandInput} for command's `input` shape.
- * @see {@link PutVoiceConnectorTerminationCommandOutput} for command's `response` shape.
- * @see {@link ChimeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutVoiceConnectorTerminationCommand extends $Command<PutVoiceConnectorTerminationCommandInput, PutVoiceConnectorTerminationCommandOutput, ChimeClientResolvedConfig> {
     readonly input: PutVoiceConnectorTerminationCommandInput;
     constructor(input: PutVoiceConnectorTerminationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutVoiceConnectorTerminationCommandInput, PutVoiceConnectorTerminationCommandOutput>;
     private serialize;
     private deserialize;