@aws-sdk/client-medialive 3.34.0 → 3.37.0

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
+import { ListInputDeviceTransfersRequest, ListInputDeviceTransfersResponse } from "../models/models_1";
+export interface ListInputDeviceTransfersCommandInput extends ListInputDeviceTransfersRequest {
+}
+export interface ListInputDeviceTransfersCommandOutput extends ListInputDeviceTransfersResponse, __MetadataBearer {
+}
+/**
+ * List input devices that are currently being transferred. List input devices that you are transferring from your AWS account or input devices that another AWS account is transferring to you.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { MediaLiveClient, ListInputDeviceTransfersCommand } from "@aws-sdk/client-medialive"; // ES Modules import
+ * // const { MediaLiveClient, ListInputDeviceTransfersCommand } = require("@aws-sdk/client-medialive"); // CommonJS import
+ * const client = new MediaLiveClient(config);
+ * const command = new ListInputDeviceTransfersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListInputDeviceTransfersCommandInput} for command's `input` shape.
+ * @see {@link ListInputDeviceTransfersCommandOutput} for command's `response` shape.
+ * @see {@link MediaLiveClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListInputDeviceTransfersCommand extends $Command<ListInputDeviceTransfersCommandInput, ListInputDeviceTransfersCommandOutput, MediaLiveClientResolvedConfig> {
+    readonly input: ListInputDeviceTransfersCommandInput;
+    constructor(input: ListInputDeviceTransfersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MediaLiveClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListInputDeviceTransfersCommandInput, ListInputDeviceTransfersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
+import { ListInputSecurityGroupsRequest, ListInputSecurityGroupsResponse } from "../models/models_1";
+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/commands/ListInputsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
+import { ListInputsRequest, ListInputsResponse } from "../models/models_1";
+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/commands/ListMultiplexProgramsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
+import { ListMultiplexProgramsRequest, ListMultiplexProgramsResponse } from "../models/models_1";
+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/commands/ListMultiplexesCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
+import { ListMultiplexesRequest, ListMultiplexesResponse } from "../models/models_1";
+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/commands/ListOfferingsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
+import { ListOfferingsRequest, ListOfferingsResponse } from "../models/models_1";
+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/commands/ListReservationsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
+import { ListReservationsRequest, ListReservationsResponse } from "../models/models_1";
+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/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
+import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_1";
+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/commands/PurchaseOfferingCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
+import { PurchaseOfferingRequest, PurchaseOfferingResponse } from "../models/models_1";
+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/commands/RejectInputDeviceTransferCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
+import { RejectInputDeviceTransferRequest, RejectInputDeviceTransferResponse } from "../models/models_1";
+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/commands/StartChannelCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
+import { StartChannelRequest, StartChannelResponse } from "../models/models_1";
+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/commands/StartMultiplexCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MediaLiveClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MediaLiveClient";
+import { StartMultiplexRequest, StartMultiplexResponse } from "../models/models_1";
+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;
+}