@aws-sdk/client-medialive 3.34.0 → 3.37.0

package/dist/types/ts3.4/commands/ListInputSecurityGroupsCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { ListInputSecurityGroupsRequest, ListInputSecurityGroupsResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListInputSecurityGroupsCommandInput extends ListInputSecurityGroupsRequest {
-}
-export interface ListInputSecurityGroupsCommandOutput extends ListInputSecurityGroupsResponse, __MetadataBearer {
-}
-/**
- * Produces a list of Input Security Groups for an account
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, ListInputSecurityGroupsCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, ListInputSecurityGroupsCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new ListInputSecurityGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListInputSecurityGroupsCommandInput} for command's `input` shape.
- * @see {@link ListInputSecurityGroupsCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListInputSecurityGroupsCommand extends $Command<ListInputSecurityGroupsCommandInput, ListInputSecurityGroupsCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: ListInputSecurityGroupsCommandInput;
-    constructor(input: ListInputSecurityGroupsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListInputSecurityGroupsCommandInput, ListInputSecurityGroupsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListInputsCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { ListInputsRequest, ListInputsResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListInputsCommandInput extends ListInputsRequest {
-}
-export interface ListInputsCommandOutput extends ListInputsResponse, __MetadataBearer {
-}
-/**
- * Produces list of inputs that have been created
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, ListInputsCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, ListInputsCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new ListInputsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListInputsCommandInput} for command's `input` shape.
- * @see {@link ListInputsCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListInputsCommand extends $Command<ListInputsCommandInput, ListInputsCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: ListInputsCommandInput;
-    constructor(input: ListInputsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListInputsCommandInput, ListInputsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListMultiplexProgramsCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { ListMultiplexProgramsRequest, ListMultiplexProgramsResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListMultiplexProgramsCommandInput extends ListMultiplexProgramsRequest {
-}
-export interface ListMultiplexProgramsCommandOutput extends ListMultiplexProgramsResponse, __MetadataBearer {
-}
-/**
- * List the programs that currently exist for a specific multiplex.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, ListMultiplexProgramsCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, ListMultiplexProgramsCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new ListMultiplexProgramsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListMultiplexProgramsCommandInput} for command's `input` shape.
- * @see {@link ListMultiplexProgramsCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListMultiplexProgramsCommand extends $Command<ListMultiplexProgramsCommandInput, ListMultiplexProgramsCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: ListMultiplexProgramsCommandInput;
-    constructor(input: ListMultiplexProgramsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListMultiplexProgramsCommandInput, ListMultiplexProgramsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListMultiplexesCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { ListMultiplexesRequest, ListMultiplexesResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListMultiplexesCommandInput extends ListMultiplexesRequest {
-}
-export interface ListMultiplexesCommandOutput extends ListMultiplexesResponse, __MetadataBearer {
-}
-/**
- * Retrieve a list of the existing multiplexes.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, ListMultiplexesCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, ListMultiplexesCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new ListMultiplexesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListMultiplexesCommandInput} for command's `input` shape.
- * @see {@link ListMultiplexesCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListMultiplexesCommand extends $Command<ListMultiplexesCommandInput, ListMultiplexesCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: ListMultiplexesCommandInput;
-    constructor(input: ListMultiplexesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListMultiplexesCommandInput, ListMultiplexesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListOfferingsCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { ListOfferingsRequest, ListOfferingsResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListOfferingsCommandInput extends ListOfferingsRequest {
-}
-export interface ListOfferingsCommandOutput extends ListOfferingsResponse, __MetadataBearer {
-}
-/**
- * List offerings available for purchase.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, ListOfferingsCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, ListOfferingsCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new ListOfferingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListOfferingsCommandInput} for command's `input` shape.
- * @see {@link ListOfferingsCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListOfferingsCommand extends $Command<ListOfferingsCommandInput, ListOfferingsCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: ListOfferingsCommandInput;
-    constructor(input: ListOfferingsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListOfferingsCommandInput, ListOfferingsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListReservationsCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { ListReservationsRequest, ListReservationsResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListReservationsCommandInput extends ListReservationsRequest {
-}
-export interface ListReservationsCommandOutput extends ListReservationsResponse, __MetadataBearer {
-}
-/**
- * List purchased reservations.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, ListReservationsCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, ListReservationsCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new ListReservationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListReservationsCommandInput} for command's `input` shape.
- * @see {@link ListReservationsCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListReservationsCommand extends $Command<ListReservationsCommandInput, ListReservationsCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: ListReservationsCommandInput;
-    constructor(input: ListReservationsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListReservationsCommandInput, ListReservationsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
-}
-export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
-}
-/**
- * Produces list of tags that have been created for a resource
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, ListTagsForResourceCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, ListTagsForResourceCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(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 MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: ListTagsForResourceCommandInput;
-    constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/PurchaseOfferingCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { PurchaseOfferingRequest, PurchaseOfferingResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PurchaseOfferingCommandInput extends PurchaseOfferingRequest {
-}
-export interface PurchaseOfferingCommandOutput extends PurchaseOfferingResponse, __MetadataBearer {
-}
-/**
- * Purchase an offering and create a reservation.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, PurchaseOfferingCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, PurchaseOfferingCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new PurchaseOfferingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PurchaseOfferingCommandInput} for command's `input` shape.
- * @see {@link PurchaseOfferingCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PurchaseOfferingCommand extends $Command<PurchaseOfferingCommandInput, PurchaseOfferingCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: PurchaseOfferingCommandInput;
-    constructor(input: PurchaseOfferingCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PurchaseOfferingCommandInput, PurchaseOfferingCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/RejectInputDeviceTransferCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { RejectInputDeviceTransferRequest, RejectInputDeviceTransferResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface RejectInputDeviceTransferCommandInput extends RejectInputDeviceTransferRequest {
-}
-export interface RejectInputDeviceTransferCommandOutput extends RejectInputDeviceTransferResponse, __MetadataBearer {
-}
-/**
- * Reject the transfer of the specified input device to your AWS account.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, RejectInputDeviceTransferCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, RejectInputDeviceTransferCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new RejectInputDeviceTransferCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RejectInputDeviceTransferCommandInput} for command's `input` shape.
- * @see {@link RejectInputDeviceTransferCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class RejectInputDeviceTransferCommand extends $Command<RejectInputDeviceTransferCommandInput, RejectInputDeviceTransferCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: RejectInputDeviceTransferCommandInput;
-    constructor(input: RejectInputDeviceTransferCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RejectInputDeviceTransferCommandInput, RejectInputDeviceTransferCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/StartChannelCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { StartChannelRequest, StartChannelResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartChannelCommandInput extends StartChannelRequest {
-}
-export interface StartChannelCommandOutput extends StartChannelResponse, __MetadataBearer {
-}
-/**
- * Starts an existing channel
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, StartChannelCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, StartChannelCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new StartChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartChannelCommandInput} for command's `input` shape.
- * @see {@link StartChannelCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartChannelCommand extends $Command<StartChannelCommandInput, StartChannelCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: StartChannelCommandInput;
-    constructor(input: StartChannelCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartChannelCommandInput, StartChannelCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/StartMultiplexCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { StartMultiplexRequest, StartMultiplexResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartMultiplexCommandInput extends StartMultiplexRequest {
-}
-export interface StartMultiplexCommandOutput extends StartMultiplexResponse, __MetadataBearer {
-}
-/**
- * Start (run) the multiplex. Starting the multiplex does not start the channels. You must explicitly start each channel.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, StartMultiplexCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, StartMultiplexCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new StartMultiplexCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartMultiplexCommandInput} for command's `input` shape.
- * @see {@link StartMultiplexCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartMultiplexCommand extends $Command<StartMultiplexCommandInput, StartMultiplexCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: StartMultiplexCommandInput;
-    constructor(input: StartMultiplexCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartMultiplexCommandInput, StartMultiplexCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/StopChannelCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { StopChannelRequest, StopChannelResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StopChannelCommandInput extends StopChannelRequest {
-}
-export interface StopChannelCommandOutput extends StopChannelResponse, __MetadataBearer {
-}
-/**
- * Stops a running channel
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, StopChannelCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, StopChannelCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new StopChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopChannelCommandInput} for command's `input` shape.
- * @see {@link StopChannelCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StopChannelCommand extends $Command<StopChannelCommandInput, StopChannelCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: StopChannelCommandInput;
-    constructor(input: StopChannelCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopChannelCommandInput, StopChannelCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/StopMultiplexCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { StopMultiplexRequest, StopMultiplexResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StopMultiplexCommandInput extends StopMultiplexRequest {
-}
-export interface StopMultiplexCommandOutput extends StopMultiplexResponse, __MetadataBearer {
-}
-/**
- * Stops a running multiplex. If the multiplex isn't running, this action has no effect.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, StopMultiplexCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, StopMultiplexCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new StopMultiplexCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopMultiplexCommandInput} for command's `input` shape.
- * @see {@link StopMultiplexCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StopMultiplexCommand extends $Command<StopMultiplexCommandInput, StopMultiplexCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: StopMultiplexCommandInput;
-    constructor(input: StopMultiplexCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopMultiplexCommandInput, StopMultiplexCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/TransferInputDeviceCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { TransferInputDeviceRequest, TransferInputDeviceResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface TransferInputDeviceCommandInput extends TransferInputDeviceRequest {
-}
-export interface TransferInputDeviceCommandOutput extends TransferInputDeviceResponse, __MetadataBearer {
-}
-/**
- * Start an input device transfer to another AWS account. After you make the request, the other account must accept or reject the transfer.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, TransferInputDeviceCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, TransferInputDeviceCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new TransferInputDeviceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TransferInputDeviceCommandInput} for command's `input` shape.
- * @see {@link TransferInputDeviceCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class TransferInputDeviceCommand extends $Command<TransferInputDeviceCommandInput, TransferInputDeviceCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: TransferInputDeviceCommandInput;
-    constructor(input: TransferInputDeviceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TransferInputDeviceCommandInput, TransferInputDeviceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/UpdateChannelClassCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { UpdateChannelClassRequest, UpdateChannelClassResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateChannelClassCommandInput extends UpdateChannelClassRequest {
-}
-export interface UpdateChannelClassCommandOutput extends UpdateChannelClassResponse, __MetadataBearer {
-}
-/**
- * Changes the class of the channel.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, UpdateChannelClassCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, UpdateChannelClassCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new UpdateChannelClassCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateChannelClassCommandInput} for command's `input` shape.
- * @see {@link UpdateChannelClassCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateChannelClassCommand extends $Command<UpdateChannelClassCommandInput, UpdateChannelClassCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: UpdateChannelClassCommandInput;
-    constructor(input: UpdateChannelClassCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateChannelClassCommandInput, UpdateChannelClassCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/UpdateChannelCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { UpdateChannelRequest, UpdateChannelResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateChannelCommandInput extends UpdateChannelRequest {
-}
-export interface UpdateChannelCommandOutput extends UpdateChannelResponse, __MetadataBearer {
-}
-/**
- * Updates a channel.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, UpdateChannelCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, UpdateChannelCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new UpdateChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateChannelCommandInput} for command's `input` shape.
- * @see {@link UpdateChannelCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateChannelCommand extends $Command<UpdateChannelCommandInput, UpdateChannelCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: UpdateChannelCommandInput;
-    constructor(input: UpdateChannelCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateChannelCommandInput, UpdateChannelCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/UpdateInputCommand.d.ts

@@ -1,35 +0,0 @@
-import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
-import { UpdateInputRequest, UpdateInputResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateInputCommandInput extends UpdateInputRequest {
-}
-export interface UpdateInputCommandOutput extends UpdateInputResponse, __MetadataBearer {
-}
-/**
- * Updates an input.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MediaLiveClient, UpdateInputCommand } from "@aws-sdk/client-medialive"; // ES Modules import
- * // const { MediaLiveClient, UpdateInputCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
- * const client = new MediaLiveClient(config);
- * const command = new UpdateInputCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateInputCommandInput} for command's `input` shape.
- * @see {@link UpdateInputCommandOutput} for command's `response` shape.
- * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateInputCommand extends $Command<UpdateInputCommandInput, UpdateInputCommandOutput, MediaLiveClientResolvedConfig> {
-    readonly input: UpdateInputCommandInput;
-    constructor(input: UpdateInputCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateInputCommandInput, UpdateInputCommandOutput>;
-    private serialize;
-    private deserialize;
-}