awscdk-construct-scte-scheduler/node_modules/@aws-sdk/client-medialive/dist-cjs/index.js

AWS CDK Construct for scheduling SCTE-35 events using the MediaLive schedule API

'use strict';

var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
var middlewareLogger = require('@aws-sdk/middleware-logger');
var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
var core = require('@smithy/core');
var client = require('@smithy/core/client');
var config = require('@smithy/core/config');
var endpoints = require('@smithy/core/endpoints');
var protocols = require('@smithy/core/protocols');
var retry = require('@smithy/core/retry');
var schema = require('@smithy/core/schema');
var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
var runtimeConfig = require('./runtimeConfig');
var regionConfigResolver = require('@aws-sdk/region-config-resolver');
var schemas_0 = require('./schemas/schemas_0');
var errors = require('./models/errors');
var MediaLiveServiceException = require('./models/MediaLiveServiceException');

const resolveClientEndpointParameters = (options) => {
    return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "medialive",
    });
};
const commonParams = {
    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
    Endpoint: { type: "builtInParams", name: "endpoint" },
    Region: { type: "builtInParams", name: "region" },
    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
};

const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
    let _credentials = runtimeConfig.credentials;
    return {
        setHttpAuthScheme(httpAuthScheme) {
            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
            if (index === -1) {
                _httpAuthSchemes.push(httpAuthScheme);
            }
            else {
                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
            }
        },
        httpAuthSchemes() {
            return _httpAuthSchemes;
        },
        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
            _httpAuthSchemeProvider = httpAuthSchemeProvider;
        },
        httpAuthSchemeProvider() {
            return _httpAuthSchemeProvider;
        },
        setCredentials(credentials) {
            _credentials = credentials;
        },
        credentials() {
            return _credentials;
        },
    };
};
const resolveHttpAuthRuntimeConfig = (config) => {
    return {
        httpAuthSchemes: config.httpAuthSchemes(),
        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
        credentials: config.credentials(),
    };
};

const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
    extensions.forEach((extension) => extension.configure(extensionConfiguration));
    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};

class MediaLiveClient extends client.Client {
    config;
    constructor(...[configuration]) {
        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
        super(_config_0);
        this.initConfig = _config_0;
        const _config_1 = resolveClientEndpointParameters(_config_0);
        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
        const _config_3 = retry.resolveRetryConfig(_config_2);
        const _config_4 = config.resolveRegionConfig(_config_3);
        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
        this.config = _config_8;
        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
        this.middlewareStack.use(retry.getRetryPlugin(this.config));
        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultMediaLiveHttpAuthSchemeParametersProvider,
            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
                "aws.auth#sigv4": config.credentials,
            }),
        }));
        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
    }
    destroy() {
        super.destroy();
    }
}

class AcceptInputDeviceTransferCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "AcceptInputDeviceTransfer", {})
    .n("MediaLiveClient", "AcceptInputDeviceTransferCommand")
    .sc(schemas_0.AcceptInputDeviceTransfer$)
    .build() {
}

class BatchDeleteCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "BatchDelete", {})
    .n("MediaLiveClient", "BatchDeleteCommand")
    .sc(schemas_0.BatchDelete$)
    .build() {
}

class BatchStartCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "BatchStart", {})
    .n("MediaLiveClient", "BatchStartCommand")
    .sc(schemas_0.BatchStart$)
    .build() {
}

class BatchStopCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "BatchStop", {})
    .n("MediaLiveClient", "BatchStopCommand")
    .sc(schemas_0.BatchStop$)
    .build() {
}

class BatchUpdateScheduleCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "BatchUpdateSchedule", {})
    .n("MediaLiveClient", "BatchUpdateScheduleCommand")
    .sc(schemas_0.BatchUpdateSchedule$)
    .build() {
}

class CancelInputDeviceTransferCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CancelInputDeviceTransfer", {})
    .n("MediaLiveClient", "CancelInputDeviceTransferCommand")
    .sc(schemas_0.CancelInputDeviceTransfer$)
    .build() {
}

class ClaimDeviceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ClaimDevice", {})
    .n("MediaLiveClient", "ClaimDeviceCommand")
    .sc(schemas_0.ClaimDevice$)
    .build() {
}

class CreateChannelCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateChannel", {})
    .n("MediaLiveClient", "CreateChannelCommand")
    .sc(schemas_0.CreateChannel$)
    .build() {
}

class CreateChannelPlacementGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateChannelPlacementGroup", {})
    .n("MediaLiveClient", "CreateChannelPlacementGroupCommand")
    .sc(schemas_0.CreateChannelPlacementGroup$)
    .build() {
}

class CreateCloudWatchAlarmTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateCloudWatchAlarmTemplate", {})
    .n("MediaLiveClient", "CreateCloudWatchAlarmTemplateCommand")
    .sc(schemas_0.CreateCloudWatchAlarmTemplate$)
    .build() {
}

class CreateCloudWatchAlarmTemplateGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateCloudWatchAlarmTemplateGroup", {})
    .n("MediaLiveClient", "CreateCloudWatchAlarmTemplateGroupCommand")
    .sc(schemas_0.CreateCloudWatchAlarmTemplateGroup$)
    .build() {
}

class CreateClusterCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateCluster", {})
    .n("MediaLiveClient", "CreateClusterCommand")
    .sc(schemas_0.CreateCluster$)
    .build() {
}

class CreateEventBridgeRuleTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateEventBridgeRuleTemplate", {})
    .n("MediaLiveClient", "CreateEventBridgeRuleTemplateCommand")
    .sc(schemas_0.CreateEventBridgeRuleTemplate$)
    .build() {
}

class CreateEventBridgeRuleTemplateGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateEventBridgeRuleTemplateGroup", {})
    .n("MediaLiveClient", "CreateEventBridgeRuleTemplateGroupCommand")
    .sc(schemas_0.CreateEventBridgeRuleTemplateGroup$)
    .build() {
}

class CreateInputCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateInput", {})
    .n("MediaLiveClient", "CreateInputCommand")
    .sc(schemas_0.CreateInput$)
    .build() {
}

class CreateInputSecurityGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateInputSecurityGroup", {})
    .n("MediaLiveClient", "CreateInputSecurityGroupCommand")
    .sc(schemas_0.CreateInputSecurityGroup$)
    .build() {
}

class CreateMultiplexCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateMultiplex", {})
    .n("MediaLiveClient", "CreateMultiplexCommand")
    .sc(schemas_0.CreateMultiplex$)
    .build() {
}

class CreateMultiplexProgramCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateMultiplexProgram", {})
    .n("MediaLiveClient", "CreateMultiplexProgramCommand")
    .sc(schemas_0.CreateMultiplexProgram$)
    .build() {
}

class CreateNetworkCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateNetwork", {})
    .n("MediaLiveClient", "CreateNetworkCommand")
    .sc(schemas_0.CreateNetwork$)
    .build() {
}

class CreateNodeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateNode", {})
    .n("MediaLiveClient", "CreateNodeCommand")
    .sc(schemas_0.CreateNode$)
    .build() {
}

class CreateNodeRegistrationScriptCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateNodeRegistrationScript", {})
    .n("MediaLiveClient", "CreateNodeRegistrationScriptCommand")
    .sc(schemas_0.CreateNodeRegistrationScript$)
    .build() {
}

class CreatePartnerInputCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreatePartnerInput", {})
    .n("MediaLiveClient", "CreatePartnerInputCommand")
    .sc(schemas_0.CreatePartnerInput$)
    .build() {
}

class CreateSdiSourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateSdiSource", {})
    .n("MediaLiveClient", "CreateSdiSourceCommand")
    .sc(schemas_0.CreateSdiSource$)
    .build() {
}

class CreateSignalMapCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateSignalMap", {})
    .n("MediaLiveClient", "CreateSignalMapCommand")
    .sc(schemas_0.CreateSignalMap$)
    .build() {
}

class CreateTagsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "CreateTags", {})
    .n("MediaLiveClient", "CreateTagsCommand")
    .sc(schemas_0.CreateTags$)
    .build() {
}

class DeleteChannelCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteChannel", {})
    .n("MediaLiveClient", "DeleteChannelCommand")
    .sc(schemas_0.DeleteChannel$)
    .build() {
}

class DeleteChannelPlacementGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteChannelPlacementGroup", {})
    .n("MediaLiveClient", "DeleteChannelPlacementGroupCommand")
    .sc(schemas_0.DeleteChannelPlacementGroup$)
    .build() {
}

class DeleteCloudWatchAlarmTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteCloudWatchAlarmTemplate", {})
    .n("MediaLiveClient", "DeleteCloudWatchAlarmTemplateCommand")
    .sc(schemas_0.DeleteCloudWatchAlarmTemplate$)
    .build() {
}

class DeleteCloudWatchAlarmTemplateGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteCloudWatchAlarmTemplateGroup", {})
    .n("MediaLiveClient", "DeleteCloudWatchAlarmTemplateGroupCommand")
    .sc(schemas_0.DeleteCloudWatchAlarmTemplateGroup$)
    .build() {
}

class DeleteClusterCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteCluster", {})
    .n("MediaLiveClient", "DeleteClusterCommand")
    .sc(schemas_0.DeleteCluster$)
    .build() {
}

class DeleteEventBridgeRuleTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteEventBridgeRuleTemplate", {})
    .n("MediaLiveClient", "DeleteEventBridgeRuleTemplateCommand")
    .sc(schemas_0.DeleteEventBridgeRuleTemplate$)
    .build() {
}

class DeleteEventBridgeRuleTemplateGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteEventBridgeRuleTemplateGroup", {})
    .n("MediaLiveClient", "DeleteEventBridgeRuleTemplateGroupCommand")
    .sc(schemas_0.DeleteEventBridgeRuleTemplateGroup$)
    .build() {
}

class DeleteInputCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteInput", {})
    .n("MediaLiveClient", "DeleteInputCommand")
    .sc(schemas_0.DeleteInput$)
    .build() {
}

class DeleteInputSecurityGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteInputSecurityGroup", {})
    .n("MediaLiveClient", "DeleteInputSecurityGroupCommand")
    .sc(schemas_0.DeleteInputSecurityGroup$)
    .build() {
}

class DeleteMultiplexCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteMultiplex", {})
    .n("MediaLiveClient", "DeleteMultiplexCommand")
    .sc(schemas_0.DeleteMultiplex$)
    .build() {
}

class DeleteMultiplexProgramCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteMultiplexProgram", {})
    .n("MediaLiveClient", "DeleteMultiplexProgramCommand")
    .sc(schemas_0.DeleteMultiplexProgram$)
    .build() {
}

class DeleteNetworkCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteNetwork", {})
    .n("MediaLiveClient", "DeleteNetworkCommand")
    .sc(schemas_0.DeleteNetwork$)
    .build() {
}

class DeleteNodeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteNode", {})
    .n("MediaLiveClient", "DeleteNodeCommand")
    .sc(schemas_0.DeleteNode$)
    .build() {
}

class DeleteReservationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteReservation", {})
    .n("MediaLiveClient", "DeleteReservationCommand")
    .sc(schemas_0.DeleteReservation$)
    .build() {
}

class DeleteScheduleCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteSchedule", {})
    .n("MediaLiveClient", "DeleteScheduleCommand")
    .sc(schemas_0.DeleteSchedule$)
    .build() {
}

class DeleteSdiSourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteSdiSource", {})
    .n("MediaLiveClient", "DeleteSdiSourceCommand")
    .sc(schemas_0.DeleteSdiSource$)
    .build() {
}

class DeleteSignalMapCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteSignalMap", {})
    .n("MediaLiveClient", "DeleteSignalMapCommand")
    .sc(schemas_0.DeleteSignalMap$)
    .build() {
}

class DeleteTagsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DeleteTags", {})
    .n("MediaLiveClient", "DeleteTagsCommand")
    .sc(schemas_0.DeleteTags$)
    .build() {
}

class DescribeAccountConfigurationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeAccountConfiguration", {})
    .n("MediaLiveClient", "DescribeAccountConfigurationCommand")
    .sc(schemas_0.DescribeAccountConfiguration$)
    .build() {
}

class DescribeChannelCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeChannel", {})
    .n("MediaLiveClient", "DescribeChannelCommand")
    .sc(schemas_0.DescribeChannel$)
    .build() {
}

class DescribeChannelPlacementGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeChannelPlacementGroup", {})
    .n("MediaLiveClient", "DescribeChannelPlacementGroupCommand")
    .sc(schemas_0.DescribeChannelPlacementGroup$)
    .build() {
}

class DescribeClusterCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeCluster", {})
    .n("MediaLiveClient", "DescribeClusterCommand")
    .sc(schemas_0.DescribeCluster$)
    .build() {
}

class DescribeInputCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeInput", {})
    .n("MediaLiveClient", "DescribeInputCommand")
    .sc(schemas_0.DescribeInput$)
    .build() {
}

class DescribeInputDeviceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeInputDevice", {})
    .n("MediaLiveClient", "DescribeInputDeviceCommand")
    .sc(schemas_0.DescribeInputDevice$)
    .build() {
}

class DescribeInputDeviceThumbnailCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeInputDeviceThumbnail", {})
    .n("MediaLiveClient", "DescribeInputDeviceThumbnailCommand")
    .sc(schemas_0.DescribeInputDeviceThumbnail$)
    .build() {
}

class DescribeInputSecurityGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeInputSecurityGroup", {})
    .n("MediaLiveClient", "DescribeInputSecurityGroupCommand")
    .sc(schemas_0.DescribeInputSecurityGroup$)
    .build() {
}

class DescribeMultiplexCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeMultiplex", {})
    .n("MediaLiveClient", "DescribeMultiplexCommand")
    .sc(schemas_0.DescribeMultiplex$)
    .build() {
}

class DescribeMultiplexProgramCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeMultiplexProgram", {})
    .n("MediaLiveClient", "DescribeMultiplexProgramCommand")
    .sc(schemas_0.DescribeMultiplexProgram$)
    .build() {
}

class DescribeNetworkCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeNetwork", {})
    .n("MediaLiveClient", "DescribeNetworkCommand")
    .sc(schemas_0.DescribeNetwork$)
    .build() {
}

class DescribeNodeCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeNode", {})
    .n("MediaLiveClient", "DescribeNodeCommand")
    .sc(schemas_0.DescribeNode$)
    .build() {
}

class DescribeOfferingCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeOffering", {})
    .n("MediaLiveClient", "DescribeOfferingCommand")
    .sc(schemas_0.DescribeOffering$)
    .build() {
}

class DescribeReservationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeReservation", {})
    .n("MediaLiveClient", "DescribeReservationCommand")
    .sc(schemas_0.DescribeReservation$)
    .build() {
}

class DescribeScheduleCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeSchedule", {})
    .n("MediaLiveClient", "DescribeScheduleCommand")
    .sc(schemas_0.DescribeSchedule$)
    .build() {
}

class DescribeSdiSourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeSdiSource", {})
    .n("MediaLiveClient", "DescribeSdiSourceCommand")
    .sc(schemas_0.DescribeSdiSource$)
    .build() {
}

class DescribeThumbnailsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "DescribeThumbnails", {})
    .n("MediaLiveClient", "DescribeThumbnailsCommand")
    .sc(schemas_0.DescribeThumbnails$)
    .build() {
}

class GetCloudWatchAlarmTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "GetCloudWatchAlarmTemplate", {})
    .n("MediaLiveClient", "GetCloudWatchAlarmTemplateCommand")
    .sc(schemas_0.GetCloudWatchAlarmTemplate$)
    .build() {
}

class GetCloudWatchAlarmTemplateGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "GetCloudWatchAlarmTemplateGroup", {})
    .n("MediaLiveClient", "GetCloudWatchAlarmTemplateGroupCommand")
    .sc(schemas_0.GetCloudWatchAlarmTemplateGroup$)
    .build() {
}

class GetEventBridgeRuleTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "GetEventBridgeRuleTemplate", {})
    .n("MediaLiveClient", "GetEventBridgeRuleTemplateCommand")
    .sc(schemas_0.GetEventBridgeRuleTemplate$)
    .build() {
}

class GetEventBridgeRuleTemplateGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "GetEventBridgeRuleTemplateGroup", {})
    .n("MediaLiveClient", "GetEventBridgeRuleTemplateGroupCommand")
    .sc(schemas_0.GetEventBridgeRuleTemplateGroup$)
    .build() {
}

class GetSignalMapCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "GetSignalMap", {})
    .n("MediaLiveClient", "GetSignalMapCommand")
    .sc(schemas_0.GetSignalMap$)
    .build() {
}

class ListAlertsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListAlerts", {})
    .n("MediaLiveClient", "ListAlertsCommand")
    .sc(schemas_0.ListAlerts$)
    .build() {
}

class ListChannelPlacementGroupsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListChannelPlacementGroups", {})
    .n("MediaLiveClient", "ListChannelPlacementGroupsCommand")
    .sc(schemas_0.ListChannelPlacementGroups$)
    .build() {
}

class ListChannelsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListChannels", {})
    .n("MediaLiveClient", "ListChannelsCommand")
    .sc(schemas_0.ListChannels$)
    .build() {
}

class ListCloudWatchAlarmTemplateGroupsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListCloudWatchAlarmTemplateGroups", {})
    .n("MediaLiveClient", "ListCloudWatchAlarmTemplateGroupsCommand")
    .sc(schemas_0.ListCloudWatchAlarmTemplateGroups$)
    .build() {
}

class ListCloudWatchAlarmTemplatesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListCloudWatchAlarmTemplates", {})
    .n("MediaLiveClient", "ListCloudWatchAlarmTemplatesCommand")
    .sc(schemas_0.ListCloudWatchAlarmTemplates$)
    .build() {
}

class ListClusterAlertsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListClusterAlerts", {})
    .n("MediaLiveClient", "ListClusterAlertsCommand")
    .sc(schemas_0.ListClusterAlerts$)
    .build() {
}

class ListClustersCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListClusters", {})
    .n("MediaLiveClient", "ListClustersCommand")
    .sc(schemas_0.ListClusters$)
    .build() {
}

class ListEventBridgeRuleTemplateGroupsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListEventBridgeRuleTemplateGroups", {})
    .n("MediaLiveClient", "ListEventBridgeRuleTemplateGroupsCommand")
    .sc(schemas_0.ListEventBridgeRuleTemplateGroups$)
    .build() {
}

class ListEventBridgeRuleTemplatesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListEventBridgeRuleTemplates", {})
    .n("MediaLiveClient", "ListEventBridgeRuleTemplatesCommand")
    .sc(schemas_0.ListEventBridgeRuleTemplates$)
    .build() {
}

class ListInputDevicesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListInputDevices", {})
    .n("MediaLiveClient", "ListInputDevicesCommand")
    .sc(schemas_0.ListInputDevices$)
    .build() {
}

class ListInputDeviceTransfersCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListInputDeviceTransfers", {})
    .n("MediaLiveClient", "ListInputDeviceTransfersCommand")
    .sc(schemas_0.ListInputDeviceTransfers$)
    .build() {
}

class ListInputsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListInputs", {})
    .n("MediaLiveClient", "ListInputsCommand")
    .sc(schemas_0.ListInputs$)
    .build() {
}

class ListInputSecurityGroupsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListInputSecurityGroups", {})
    .n("MediaLiveClient", "ListInputSecurityGroupsCommand")
    .sc(schemas_0.ListInputSecurityGroups$)
    .build() {
}

class ListMultiplexAlertsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListMultiplexAlerts", {})
    .n("MediaLiveClient", "ListMultiplexAlertsCommand")
    .sc(schemas_0.ListMultiplexAlerts$)
    .build() {
}

class ListMultiplexesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListMultiplexes", {})
    .n("MediaLiveClient", "ListMultiplexesCommand")
    .sc(schemas_0.ListMultiplexes$)
    .build() {
}

class ListMultiplexProgramsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListMultiplexPrograms", {})
    .n("MediaLiveClient", "ListMultiplexProgramsCommand")
    .sc(schemas_0.ListMultiplexPrograms$)
    .build() {
}

class ListNetworksCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListNetworks", {})
    .n("MediaLiveClient", "ListNetworksCommand")
    .sc(schemas_0.ListNetworks$)
    .build() {
}

class ListNodesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListNodes", {})
    .n("MediaLiveClient", "ListNodesCommand")
    .sc(schemas_0.ListNodes$)
    .build() {
}

class ListOfferingsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListOfferings", {})
    .n("MediaLiveClient", "ListOfferingsCommand")
    .sc(schemas_0.ListOfferings$)
    .build() {
}

class ListReservationsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListReservations", {})
    .n("MediaLiveClient", "ListReservationsCommand")
    .sc(schemas_0.ListReservations$)
    .build() {
}

class ListSdiSourcesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListSdiSources", {})
    .n("MediaLiveClient", "ListSdiSourcesCommand")
    .sc(schemas_0.ListSdiSources$)
    .build() {
}

class ListSignalMapsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListSignalMaps", {})
    .n("MediaLiveClient", "ListSignalMapsCommand")
    .sc(schemas_0.ListSignalMaps$)
    .build() {
}

class ListTagsForResourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListTagsForResource", {})
    .n("MediaLiveClient", "ListTagsForResourceCommand")
    .sc(schemas_0.ListTagsForResource$)
    .build() {
}

class ListVersionsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "ListVersions", {})
    .n("MediaLiveClient", "ListVersionsCommand")
    .sc(schemas_0.ListVersions$)
    .build() {
}

class PurchaseOfferingCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "PurchaseOffering", {})
    .n("MediaLiveClient", "PurchaseOfferingCommand")
    .sc(schemas_0.PurchaseOffering$)
    .build() {
}

class RebootInputDeviceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "RebootInputDevice", {})
    .n("MediaLiveClient", "RebootInputDeviceCommand")
    .sc(schemas_0.RebootInputDevice$)
    .build() {
}

class RejectInputDeviceTransferCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "RejectInputDeviceTransfer", {})
    .n("MediaLiveClient", "RejectInputDeviceTransferCommand")
    .sc(schemas_0.RejectInputDeviceTransfer$)
    .build() {
}

class RestartChannelPipelinesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "RestartChannelPipelines", {})
    .n("MediaLiveClient", "RestartChannelPipelinesCommand")
    .sc(schemas_0.RestartChannelPipelines$)
    .build() {
}

class StartChannelCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "StartChannel", {})
    .n("MediaLiveClient", "StartChannelCommand")
    .sc(schemas_0.StartChannel$)
    .build() {
}

class StartDeleteMonitorDeploymentCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "StartDeleteMonitorDeployment", {})
    .n("MediaLiveClient", "StartDeleteMonitorDeploymentCommand")
    .sc(schemas_0.StartDeleteMonitorDeployment$)
    .build() {
}

class StartInputDeviceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "StartInputDevice", {})
    .n("MediaLiveClient", "StartInputDeviceCommand")
    .sc(schemas_0.StartInputDevice$)
    .build() {
}

class StartInputDeviceMaintenanceWindowCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "StartInputDeviceMaintenanceWindow", {})
    .n("MediaLiveClient", "StartInputDeviceMaintenanceWindowCommand")
    .sc(schemas_0.StartInputDeviceMaintenanceWindow$)
    .build() {
}

class StartMonitorDeploymentCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "StartMonitorDeployment", {})
    .n("MediaLiveClient", "StartMonitorDeploymentCommand")
    .sc(schemas_0.StartMonitorDeployment$)
    .build() {
}

class StartMultiplexCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "StartMultiplex", {})
    .n("MediaLiveClient", "StartMultiplexCommand")
    .sc(schemas_0.StartMultiplex$)
    .build() {
}

class StartUpdateSignalMapCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "StartUpdateSignalMap", {})
    .n("MediaLiveClient", "StartUpdateSignalMapCommand")
    .sc(schemas_0.StartUpdateSignalMap$)
    .build() {
}

class StopChannelCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "StopChannel", {})
    .n("MediaLiveClient", "StopChannelCommand")
    .sc(schemas_0.StopChannel$)
    .build() {
}

class StopInputDeviceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "StopInputDevice", {})
    .n("MediaLiveClient", "StopInputDeviceCommand")
    .sc(schemas_0.StopInputDevice$)
    .build() {
}

class StopMultiplexCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "StopMultiplex", {})
    .n("MediaLiveClient", "StopMultiplexCommand")
    .sc(schemas_0.StopMultiplex$)
    .build() {
}

class TransferInputDeviceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "TransferInputDevice", {})
    .n("MediaLiveClient", "TransferInputDeviceCommand")
    .sc(schemas_0.TransferInputDevice$)
    .build() {
}

class UpdateAccountConfigurationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "UpdateAccountConfiguration", {})
    .n("MediaLiveClient", "UpdateAccountConfigurationCommand")
    .sc(schemas_0.UpdateAccountConfiguration$)
    .build() {
}

class UpdateChannelClassCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "UpdateChannelClass", {})
    .n("MediaLiveClient", "UpdateChannelClassCommand")
    .sc(schemas_0.UpdateChannelClass$)
    .build() {
}

class UpdateChannelCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "UpdateChannel", {})
    .n("MediaLiveClient", "UpdateChannelCommand")
    .sc(schemas_0.UpdateChannel$)
    .build() {
}

class UpdateChannelPlacementGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "UpdateChannelPlacementGroup", {})
    .n("MediaLiveClient", "UpdateChannelPlacementGroupCommand")
    .sc(schemas_0.UpdateChannelPlacementGroup$)
    .build() {
}

class UpdateCloudWatchAlarmTemplateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "UpdateCloudWatchAlarmTemplate", {})
    .n("MediaLiveClient", "UpdateCloudWatchAlarmTemplateCommand")
    .sc(schemas_0.UpdateCloudWatchAlarmTemplate$)
    .build() {
}

class UpdateCloudWatchAlarmTemplateGroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "UpdateCloudWatchAlarmTemplateGroup", {})
    .n("MediaLiveClient", "UpdateCloudWatchAlarmTemplateGroupCommand")
    .sc(schemas_0.UpdateCloudWatchAlarmTemplateGroup$)
    .build() {
}

class UpdateClusterCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("MediaLive", "UpdateCluster", {})
    .n("MediaLiveClient", "UpdateClusterComman