@aws-sdk/client-ivs 3.36.0 → 3.36.1

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

@@ -6,32 +6,11 @@ export interface CreateStreamKeyCommandInput extends CreateStreamKeyRequest {
 }
 export interface CreateStreamKeyCommandOutput extends CreateStreamKeyResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a stream key, used to initiate a stream, for the specified channel ARN.</p>
- *          <p>Note that <a>CreateChannel</a> creates a stream key. If you subsequently use
- *       CreateStreamKey on the same channel, it will fail because a stream key already exists and
- *       there is a limit of 1 stream key per channel. To reset the stream key on a channel, use <a>DeleteStreamKey</a> and then CreateStreamKey.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, CreateStreamKeyCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, CreateStreamKeyCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new CreateStreamKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateStreamKeyCommandInput} for command's `input` shape.
- * @see {@link CreateStreamKeyCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateStreamKeyCommand extends $Command<CreateStreamKeyCommandInput, CreateStreamKeyCommandOutput, IvsClientResolvedConfig> {
     readonly input: CreateStreamKeyCommandInput;
     constructor(input: CreateStreamKeyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateStreamKeyCommandInput, CreateStreamKeyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DeleteChannelCommandInput extends DeleteChannelRequest {
 }
 export interface DeleteChannelCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified channel and its associated stream keys.</p>
- *          <p>If you try to delete a live channel, you will get an error (409 ConflictException). To
- *       delete a channel that is live, call <a>StopStream</a>, wait for the Amazon
- *       EventBridge "Stream End" event (to verify that the stream's state was changed from Live to
- *       Offline), then call DeleteChannel. (See <a href="https://docs.aws.amazon.com/ivs/latest/userguide/eventbridge.html"> Using EventBridge with Amazon IVS</a>.) </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, DeleteChannelCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, DeleteChannelCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new DeleteChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteChannelCommandInput} for command's `input` shape.
- * @see {@link DeleteChannelCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteChannelCommand extends $Command<DeleteChannelCommandInput, DeleteChannelCommandOutput, IvsClientResolvedConfig> {
     readonly input: DeleteChannelCommandInput;
     constructor(input: DeleteChannelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteChannelCommandInput, DeleteChannelCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeletePlaybackKeyPairCommandInput extends DeletePlaybackKeyPair
 }
 export interface DeletePlaybackKeyPairCommandOutput extends DeletePlaybackKeyPairResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a specified authorization key pair. This invalidates future viewer tokens
- *       generated using the key pair’s <code>privateKey</code>. For more information, see <a href="https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html">Setting Up Private
- *         Channels</a> in the <i>Amazon IVS User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, DeletePlaybackKeyPairCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, DeletePlaybackKeyPairCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new DeletePlaybackKeyPairCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeletePlaybackKeyPairCommandInput} for command's `input` shape.
- * @see {@link DeletePlaybackKeyPairCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeletePlaybackKeyPairCommand extends $Command<DeletePlaybackKeyPairCommandInput, DeletePlaybackKeyPairCommandOutput, IvsClientResolvedConfig> {
     readonly input: DeletePlaybackKeyPairCommandInput;
     constructor(input: DeletePlaybackKeyPairCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePlaybackKeyPairCommandInput, DeletePlaybackKeyPairCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DeleteRecordingConfigurationCommandInput extends DeleteRecordin
 }
 export interface DeleteRecordingConfigurationCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the recording configuration for the specified ARN.</p>
- *          <p>If you try to delete a recording configuration that is associated with a channel, you will
- *       get an error (409 ConflictException). To avoid this, for all channels that reference the
- *       recording configuration, first use <a>UpdateChannel</a> to set the
- *         <code>recordingConfigurationArn</code> field to an empty string, then use
- *       DeleteRecordingConfiguration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, DeleteRecordingConfigurationCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, DeleteRecordingConfigurationCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new DeleteRecordingConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteRecordingConfigurationCommandInput} for command's `input` shape.
- * @see {@link DeleteRecordingConfigurationCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteRecordingConfigurationCommand extends $Command<DeleteRecordingConfigurationCommandInput, DeleteRecordingConfigurationCommandOutput, IvsClientResolvedConfig> {
     readonly input: DeleteRecordingConfigurationCommandInput;
     constructor(input: DeleteRecordingConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRecordingConfigurationCommandInput, DeleteRecordingConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteStreamKeyCommandInput extends DeleteStreamKeyRequest {
 }
 export interface DeleteStreamKeyCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the stream key for the specified ARN, so it can no longer be used to
- *       stream.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, DeleteStreamKeyCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, DeleteStreamKeyCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new DeleteStreamKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteStreamKeyCommandInput} for command's `input` shape.
- * @see {@link DeleteStreamKeyCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteStreamKeyCommand extends $Command<DeleteStreamKeyCommandInput, DeleteStreamKeyCommandOutput, IvsClientResolvedConfig> {
     readonly input: DeleteStreamKeyCommandInput;
     constructor(input: DeleteStreamKeyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteStreamKeyCommandInput, DeleteStreamKeyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetChannelCommandInput extends GetChannelRequest {
 }
 export interface GetChannelCommandOutput extends GetChannelResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the channel configuration for the specified channel ARN. See also <a>BatchGetChannel</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, GetChannelCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, GetChannelCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new GetChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetChannelCommandInput} for command's `input` shape.
- * @see {@link GetChannelCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetChannelCommand extends $Command<GetChannelCommandInput, GetChannelCommandOutput, IvsClientResolvedConfig> {
     readonly input: GetChannelCommandInput;
     constructor(input: GetChannelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetChannelCommandInput, GetChannelCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetPlaybackKeyPairCommandInput extends GetPlaybackKeyPairReques
 }
 export interface GetPlaybackKeyPairCommandOutput extends GetPlaybackKeyPairResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a specified playback authorization key pair and returns the <code>arn</code> and
- *         <code>fingerprint</code>. The <code>privateKey</code> held by the caller can be used to
- *       generate viewer authorization tokens, to grant viewers access to private channels. For more
- *       information, see <a href="https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html">Setting Up Private Channels</a> in the <i>Amazon IVS User
- *       Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, GetPlaybackKeyPairCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, GetPlaybackKeyPairCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new GetPlaybackKeyPairCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetPlaybackKeyPairCommandInput} for command's `input` shape.
- * @see {@link GetPlaybackKeyPairCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetPlaybackKeyPairCommand extends $Command<GetPlaybackKeyPairCommandInput, GetPlaybackKeyPairCommandOutput, IvsClientResolvedConfig> {
     readonly input: GetPlaybackKeyPairCommandInput;
     constructor(input: GetPlaybackKeyPairCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetPlaybackKeyPairCommandInput, GetPlaybackKeyPairCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetRecordingConfigurationCommandInput extends GetRecordingConfi
 }
 export interface GetRecordingConfigurationCommandOutput extends GetRecordingConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the recording configuration for the specified ARN.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, GetRecordingConfigurationCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, GetRecordingConfigurationCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new GetRecordingConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRecordingConfigurationCommandInput} for command's `input` shape.
- * @see {@link GetRecordingConfigurationCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRecordingConfigurationCommand extends $Command<GetRecordingConfigurationCommandInput, GetRecordingConfigurationCommandOutput, IvsClientResolvedConfig> {
     readonly input: GetRecordingConfigurationCommandInput;
     constructor(input: GetRecordingConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRecordingConfigurationCommandInput, GetRecordingConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetStreamCommandInput extends GetStreamRequest {
 }
 export interface GetStreamCommandOutput extends GetStreamResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about the active (live) stream on a specified channel.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, GetStreamCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, GetStreamCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new GetStreamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetStreamCommandInput} for command's `input` shape.
- * @see {@link GetStreamCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetStreamCommand extends $Command<GetStreamCommandInput, GetStreamCommandOutput, IvsClientResolvedConfig> {
     readonly input: GetStreamCommandInput;
     constructor(input: GetStreamCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetStreamCommandInput, GetStreamCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetStreamKeyCommandInput extends GetStreamKeyRequest {
 }
 export interface GetStreamKeyCommandOutput extends GetStreamKeyResponse, __MetadataBearer {
 }
-/**
- * <p>Gets stream-key information for a specified ARN.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, GetStreamKeyCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, GetStreamKeyCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new GetStreamKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetStreamKeyCommandInput} for command's `input` shape.
- * @see {@link GetStreamKeyCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetStreamKeyCommand extends $Command<GetStreamKeyCommandInput, GetStreamKeyCommandOutput, IvsClientResolvedConfig> {
     readonly input: GetStreamKeyCommandInput;
     constructor(input: GetStreamKeyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetStreamKeyCommandInput, GetStreamKeyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ImportPlaybackKeyPairCommandInput extends ImportPlaybackKeyPair
 }
 export interface ImportPlaybackKeyPairCommandOutput extends ImportPlaybackKeyPairResponse, __MetadataBearer {
 }
-/**
- * <p>Imports the public portion of a new key pair and returns its <code>arn</code> and
- *         <code>fingerprint</code>. The <code>privateKey</code> can then be used to generate viewer
- *       authorization tokens, to grant viewers access to private channels. For more information, see
- *         <a href="https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html">Setting Up
- *         Private Channels</a> in the <i>Amazon IVS User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, ImportPlaybackKeyPairCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, ImportPlaybackKeyPairCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new ImportPlaybackKeyPairCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportPlaybackKeyPairCommandInput} for command's `input` shape.
- * @see {@link ImportPlaybackKeyPairCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportPlaybackKeyPairCommand extends $Command<ImportPlaybackKeyPairCommandInput, ImportPlaybackKeyPairCommandOutput, IvsClientResolvedConfig> {
     readonly input: ImportPlaybackKeyPairCommandInput;
     constructor(input: ImportPlaybackKeyPairCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportPlaybackKeyPairCommandInput, ImportPlaybackKeyPairCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface ListChannelsCommandInput extends ListChannelsRequest {
 }
 export interface ListChannelsCommandOutput extends ListChannelsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets summary information about all channels in your account, in the AWS region where the
- *       API request is processed. This list can be filtered to match a specified name or
- *       recording-configuration ARN. Filters are mutually exclusive and cannot be used together. If
- *       you try to use both filters, you will get an error (409 ConflictException).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, ListChannelsCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, ListChannelsCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new ListChannelsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListChannelsCommandInput} for command's `input` shape.
- * @see {@link ListChannelsCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListChannelsCommand extends $Command<ListChannelsCommandInput, ListChannelsCommandOutput, IvsClientResolvedConfig> {
     readonly input: ListChannelsCommandInput;
     constructor(input: ListChannelsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListChannelsCommandInput, ListChannelsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListPlaybackKeyPairsCommandInput extends ListPlaybackKeyPairsRe
 }
 export interface ListPlaybackKeyPairsCommandOutput extends ListPlaybackKeyPairsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets summary information about playback key pairs. For more information, see <a href="https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html">Setting Up Private
- *         Channels</a> in the <i>Amazon IVS User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, ListPlaybackKeyPairsCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, ListPlaybackKeyPairsCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new ListPlaybackKeyPairsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListPlaybackKeyPairsCommandInput} for command's `input` shape.
- * @see {@link ListPlaybackKeyPairsCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListPlaybackKeyPairsCommand extends $Command<ListPlaybackKeyPairsCommandInput, ListPlaybackKeyPairsCommandOutput, IvsClientResolvedConfig> {
     readonly input: ListPlaybackKeyPairsCommandInput;
     constructor(input: ListPlaybackKeyPairsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPlaybackKeyPairsCommandInput, ListPlaybackKeyPairsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListRecordingConfigurationsCommandInput extends ListRecordingCo
 }
 export interface ListRecordingConfigurationsCommandOutput extends ListRecordingConfigurationsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets summary information about all recording configurations in your account, in the AWS
- *       region where the API request is processed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, ListRecordingConfigurationsCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, ListRecordingConfigurationsCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new ListRecordingConfigurationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListRecordingConfigurationsCommandInput} for command's `input` shape.
- * @see {@link ListRecordingConfigurationsCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListRecordingConfigurationsCommand extends $Command<ListRecordingConfigurationsCommandInput, ListRecordingConfigurationsCommandOutput, IvsClientResolvedConfig> {
     readonly input: ListRecordingConfigurationsCommandInput;
     constructor(input: ListRecordingConfigurationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRecordingConfigurationsCommandInput, ListRecordingConfigurationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListStreamKeysCommandInput extends ListStreamKeysRequest {
 }
 export interface ListStreamKeysCommandOutput extends ListStreamKeysResponse, __MetadataBearer {
 }
-/**
- * <p>Gets summary information about stream keys for the specified channel.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, ListStreamKeysCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, ListStreamKeysCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new ListStreamKeysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListStreamKeysCommandInput} for command's `input` shape.
- * @see {@link ListStreamKeysCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListStreamKeysCommand extends $Command<ListStreamKeysCommandInput, ListStreamKeysCommandOutput, IvsClientResolvedConfig> {
     readonly input: ListStreamKeysCommandInput;
     constructor(input: ListStreamKeysCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListStreamKeysCommandInput, ListStreamKeysCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListStreamsCommandInput extends ListStreamsRequest {
 }
 export interface ListStreamsCommandOutput extends ListStreamsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets summary information about live streams in your account, in the AWS region where the
- *       API request is processed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, ListStreamsCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, ListStreamsCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new ListStreamsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListStreamsCommandInput} for command's `input` shape.
- * @see {@link ListStreamsCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListStreamsCommand extends $Command<ListStreamsCommandInput, ListStreamsCommandOutput, IvsClientResolvedConfig> {
     readonly input: ListStreamsCommandInput;
     constructor(input: ListStreamsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListStreamsCommandInput, ListStreamsCommandOutput>;
     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>Gets information about AWS tags for the specified ARN.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, ListTagsForResourceCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, ListTagsForResourceCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(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 IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, IvsClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface PutMetadataCommandInput extends PutMetadataRequest {
 }
 export interface PutMetadataCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Inserts metadata into the active stream of the specified channel. A maximum of 5 requests
- *       per second per channel is allowed, each with a maximum 1 KB payload. (If 5 TPS is not
- *       sufficient for your needs, we recommend batching your data into a single PutMetadata call.)
- *
- *       Also see <a href="https://docs.aws.amazon.com/ivs/latest/userguide/metadata.html">Embedding Metadata
- *
- *         within a Video Stream</a> in the <i>Amazon IVS User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IvsClient, PutMetadataCommand } from "@aws-sdk/client-ivs"; // ES Modules import
- * // const { IvsClient, PutMetadataCommand } = require("@aws-sdk/client-ivs"); // CommonJS import
- * const client = new IvsClient(config);
- * const command = new PutMetadataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutMetadataCommandInput} for command's `input` shape.
- * @see {@link PutMetadataCommandOutput} for command's `response` shape.
- * @see {@link IvsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutMetadataCommand extends $Command<PutMetadataCommandInput, PutMetadataCommandOutput, IvsClientResolvedConfig> {
     readonly input: PutMetadataCommandInput;
     constructor(input: PutMetadataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IvsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutMetadataCommandInput, PutMetadataCommandOutput>;
     private serialize;
     private deserialize;