File Explorer

/proc/self/root/var/runtime/node_modules/@aws-sdk/client-mediaconnect/dist-cjs

This explorer reads the filesystem of the server it runs on, so /workspace/user isn't present here. Browsing and the terminal still work against this server's own disk from /.

index.js79.9 KB · 2348 lines
'use strict'; var client$1 = require('@aws-sdk/core/client');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 schemas_0 = require('./schemas/schemas_0');var errors = require('./models/errors');var MediaConnectServiceException = require('./models/MediaConnectServiceException'); const resolveClientEndpointParameters = (options) => {    return Object.assign(options, {        useDualstackEndpoint: options.useDualstackEndpoint ?? false,        useFipsEndpoint: options.useFipsEndpoint ?? false,        defaultSigningName: "mediaconnect",    });};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(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));    extensions.forEach((extension) => extension.configure(extensionConfiguration));    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));}; class MediaConnectClient 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 = client$1.resolveUserAgentConfig(_config_1);        const _config_3 = retry.resolveRetryConfig(_config_2);        const _config_4 = config.resolveRegionConfig(_config_3);        const _config_5 = client$1.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(client$1.getUserAgentPlugin(this.config));        this.middlewareStack.use(retry.getRetryPlugin(this.config));        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultMediaConnectHttpAuthSchemeParametersProvider,            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({                "aws.auth#sigv4": config.credentials,            }),        }));        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));    }    destroy() {        super.destroy();    }} class AddBridgeOutputsCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "AddBridgeOutputs", {})    .n("MediaConnectClient", "AddBridgeOutputsCommand")    .sc(schemas_0.AddBridgeOutputs$)    .build() {} class AddBridgeSourcesCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "AddBridgeSources", {})    .n("MediaConnectClient", "AddBridgeSourcesCommand")    .sc(schemas_0.AddBridgeSources$)    .build() {} class AddFlowMediaStreamsCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "AddFlowMediaStreams", {})    .n("MediaConnectClient", "AddFlowMediaStreamsCommand")    .sc(schemas_0.AddFlowMediaStreams$)    .build() {} class AddFlowOutputsCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "AddFlowOutputs", {})    .n("MediaConnectClient", "AddFlowOutputsCommand")    .sc(schemas_0.AddFlowOutputs$)    .build() {} class AddFlowSourcesCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "AddFlowSources", {})    .n("MediaConnectClient", "AddFlowSourcesCommand")    .sc(schemas_0.AddFlowSources$)    .build() {} class AddFlowVpcInterfacesCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "AddFlowVpcInterfaces", {})    .n("MediaConnectClient", "AddFlowVpcInterfacesCommand")    .sc(schemas_0.AddFlowVpcInterfaces$)    .build() {} class BatchGetRouterInputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "BatchGetRouterInput", {})    .n("MediaConnectClient", "BatchGetRouterInputCommand")    .sc(schemas_0.BatchGetRouterInput$)    .build() {} class BatchGetRouterNetworkInterfaceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "BatchGetRouterNetworkInterface", {})    .n("MediaConnectClient", "BatchGetRouterNetworkInterfaceCommand")    .sc(schemas_0.BatchGetRouterNetworkInterface$)    .build() {} class BatchGetRouterOutputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "BatchGetRouterOutput", {})    .n("MediaConnectClient", "BatchGetRouterOutputCommand")    .sc(schemas_0.BatchGetRouterOutput$)    .build() {} class CreateBridgeCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "CreateBridge", {})    .n("MediaConnectClient", "CreateBridgeCommand")    .sc(schemas_0.CreateBridge$)    .build() {} class CreateFlowCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "CreateFlow", {})    .n("MediaConnectClient", "CreateFlowCommand")    .sc(schemas_0.CreateFlow$)    .build() {} class CreateGatewayCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "CreateGateway", {})    .n("MediaConnectClient", "CreateGatewayCommand")    .sc(schemas_0.CreateGateway$)    .build() {} class CreateRouterInputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "CreateRouterInput", {})    .n("MediaConnectClient", "CreateRouterInputCommand")    .sc(schemas_0.CreateRouterInput$)    .build() {} class CreateRouterNetworkInterfaceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "CreateRouterNetworkInterface", {})    .n("MediaConnectClient", "CreateRouterNetworkInterfaceCommand")    .sc(schemas_0.CreateRouterNetworkInterface$)    .build() {} class CreateRouterOutputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "CreateRouterOutput", {})    .n("MediaConnectClient", "CreateRouterOutputCommand")    .sc(schemas_0.CreateRouterOutput$)    .build() {} class DeleteBridgeCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DeleteBridge", {})    .n("MediaConnectClient", "DeleteBridgeCommand")    .sc(schemas_0.DeleteBridge$)    .build() {} class DeleteFlowCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DeleteFlow", {})    .n("MediaConnectClient", "DeleteFlowCommand")    .sc(schemas_0.DeleteFlow$)    .build() {} class DeleteGatewayCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DeleteGateway", {})    .n("MediaConnectClient", "DeleteGatewayCommand")    .sc(schemas_0.DeleteGateway$)    .build() {} class DeleteRouterInputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DeleteRouterInput", {})    .n("MediaConnectClient", "DeleteRouterInputCommand")    .sc(schemas_0.DeleteRouterInput$)    .build() {} class DeleteRouterNetworkInterfaceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DeleteRouterNetworkInterface", {})    .n("MediaConnectClient", "DeleteRouterNetworkInterfaceCommand")    .sc(schemas_0.DeleteRouterNetworkInterface$)    .build() {} class DeleteRouterOutputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DeleteRouterOutput", {})    .n("MediaConnectClient", "DeleteRouterOutputCommand")    .sc(schemas_0.DeleteRouterOutput$)    .build() {} class DeregisterGatewayInstanceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DeregisterGatewayInstance", {})    .n("MediaConnectClient", "DeregisterGatewayInstanceCommand")    .sc(schemas_0.DeregisterGatewayInstance$)    .build() {} class DescribeBridgeCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DescribeBridge", {})    .n("MediaConnectClient", "DescribeBridgeCommand")    .sc(schemas_0.DescribeBridge$)    .build() {} class DescribeFlowCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DescribeFlow", {})    .n("MediaConnectClient", "DescribeFlowCommand")    .sc(schemas_0.DescribeFlow$)    .build() {} class DescribeFlowSourceMetadataCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DescribeFlowSourceMetadata", {})    .n("MediaConnectClient", "DescribeFlowSourceMetadataCommand")    .sc(schemas_0.DescribeFlowSourceMetadata$)    .build() {} class DescribeFlowSourceThumbnailCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DescribeFlowSourceThumbnail", {})    .n("MediaConnectClient", "DescribeFlowSourceThumbnailCommand")    .sc(schemas_0.DescribeFlowSourceThumbnail$)    .build() {} class DescribeGatewayCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DescribeGateway", {})    .n("MediaConnectClient", "DescribeGatewayCommand")    .sc(schemas_0.DescribeGateway$)    .build() {} class DescribeGatewayInstanceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DescribeGatewayInstance", {})    .n("MediaConnectClient", "DescribeGatewayInstanceCommand")    .sc(schemas_0.DescribeGatewayInstance$)    .build() {} class DescribeOfferingCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "DescribeOffering", {})    .n("MediaConnectClient", "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("MediaConnect", "DescribeReservation", {})    .n("MediaConnectClient", "DescribeReservationCommand")    .sc(schemas_0.DescribeReservation$)    .build() {} class GetRouterInputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "GetRouterInput", {})    .n("MediaConnectClient", "GetRouterInputCommand")    .sc(schemas_0.GetRouterInput$)    .build() {} class GetRouterInputSourceMetadataCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "GetRouterInputSourceMetadata", {})    .n("MediaConnectClient", "GetRouterInputSourceMetadataCommand")    .sc(schemas_0.GetRouterInputSourceMetadata$)    .build() {} class GetRouterInputThumbnailCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "GetRouterInputThumbnail", {})    .n("MediaConnectClient", "GetRouterInputThumbnailCommand")    .sc(schemas_0.GetRouterInputThumbnail$)    .build() {} class GetRouterNetworkInterfaceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "GetRouterNetworkInterface", {})    .n("MediaConnectClient", "GetRouterNetworkInterfaceCommand")    .sc(schemas_0.GetRouterNetworkInterface$)    .build() {} class GetRouterOutputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "GetRouterOutput", {})    .n("MediaConnectClient", "GetRouterOutputCommand")    .sc(schemas_0.GetRouterOutput$)    .build() {} class GrantFlowEntitlementsCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "GrantFlowEntitlements", {})    .n("MediaConnectClient", "GrantFlowEntitlementsCommand")    .sc(schemas_0.GrantFlowEntitlements$)    .build() {} class ListBridgesCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "ListBridges", {})    .n("MediaConnectClient", "ListBridgesCommand")    .sc(schemas_0.ListBridges$)    .build() {} class ListEntitlementsCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "ListEntitlements", {})    .n("MediaConnectClient", "ListEntitlementsCommand")    .sc(schemas_0.ListEntitlements$)    .build() {} class ListFlowsCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "ListFlows", {})    .n("MediaConnectClient", "ListFlowsCommand")    .sc(schemas_0.ListFlows$)    .build() {} class ListGatewayInstancesCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "ListGatewayInstances", {})    .n("MediaConnectClient", "ListGatewayInstancesCommand")    .sc(schemas_0.ListGatewayInstances$)    .build() {} class ListGatewaysCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "ListGateways", {})    .n("MediaConnectClient", "ListGatewaysCommand")    .sc(schemas_0.ListGateways$)    .build() {} class ListOfferingsCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "ListOfferings", {})    .n("MediaConnectClient", "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("MediaConnect", "ListReservations", {})    .n("MediaConnectClient", "ListReservationsCommand")    .sc(schemas_0.ListReservations$)    .build() {} class ListRouterInputsCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "ListRouterInputs", {})    .n("MediaConnectClient", "ListRouterInputsCommand")    .sc(schemas_0.ListRouterInputs$)    .build() {} class ListRouterNetworkInterfacesCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "ListRouterNetworkInterfaces", {})    .n("MediaConnectClient", "ListRouterNetworkInterfacesCommand")    .sc(schemas_0.ListRouterNetworkInterfaces$)    .build() {} class ListRouterOutputsCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "ListRouterOutputs", {})    .n("MediaConnectClient", "ListRouterOutputsCommand")    .sc(schemas_0.ListRouterOutputs$)    .build() {} class ListTagsForGlobalResourceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "ListTagsForGlobalResource", {})    .n("MediaConnectClient", "ListTagsForGlobalResourceCommand")    .sc(schemas_0.ListTagsForGlobalResource$)    .build() {} class ListTagsForResourceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "ListTagsForResource", {})    .n("MediaConnectClient", "ListTagsForResourceCommand")    .sc(schemas_0.ListTagsForResource$)    .build() {} class PurchaseOfferingCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "PurchaseOffering", {})    .n("MediaConnectClient", "PurchaseOfferingCommand")    .sc(schemas_0.PurchaseOffering$)    .build() {} class RemoveBridgeOutputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "RemoveBridgeOutput", {})    .n("MediaConnectClient", "RemoveBridgeOutputCommand")    .sc(schemas_0.RemoveBridgeOutput$)    .build() {} class RemoveBridgeSourceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "RemoveBridgeSource", {})    .n("MediaConnectClient", "RemoveBridgeSourceCommand")    .sc(schemas_0.RemoveBridgeSource$)    .build() {} class RemoveFlowMediaStreamCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "RemoveFlowMediaStream", {})    .n("MediaConnectClient", "RemoveFlowMediaStreamCommand")    .sc(schemas_0.RemoveFlowMediaStream$)    .build() {} class RemoveFlowOutputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "RemoveFlowOutput", {})    .n("MediaConnectClient", "RemoveFlowOutputCommand")    .sc(schemas_0.RemoveFlowOutput$)    .build() {} class RemoveFlowSourceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "RemoveFlowSource", {})    .n("MediaConnectClient", "RemoveFlowSourceCommand")    .sc(schemas_0.RemoveFlowSource$)    .build() {} class RemoveFlowVpcInterfaceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "RemoveFlowVpcInterface", {})    .n("MediaConnectClient", "RemoveFlowVpcInterfaceCommand")    .sc(schemas_0.RemoveFlowVpcInterface$)    .build() {} class RestartRouterInputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "RestartRouterInput", {})    .n("MediaConnectClient", "RestartRouterInputCommand")    .sc(schemas_0.RestartRouterInput$)    .build() {} class RestartRouterOutputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "RestartRouterOutput", {})    .n("MediaConnectClient", "RestartRouterOutputCommand")    .sc(schemas_0.RestartRouterOutput$)    .build() {} class RevokeFlowEntitlementCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "RevokeFlowEntitlement", {})    .n("MediaConnectClient", "RevokeFlowEntitlementCommand")    .sc(schemas_0.RevokeFlowEntitlement$)    .build() {} class StartFlowCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "StartFlow", {})    .n("MediaConnectClient", "StartFlowCommand")    .sc(schemas_0.StartFlow$)    .build() {} class StartRouterInputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "StartRouterInput", {})    .n("MediaConnectClient", "StartRouterInputCommand")    .sc(schemas_0.StartRouterInput$)    .build() {} class StartRouterOutputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "StartRouterOutput", {})    .n("MediaConnectClient", "StartRouterOutputCommand")    .sc(schemas_0.StartRouterOutput$)    .build() {} class StopFlowCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "StopFlow", {})    .n("MediaConnectClient", "StopFlowCommand")    .sc(schemas_0.StopFlow$)    .build() {} class StopRouterInputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "StopRouterInput", {})    .n("MediaConnectClient", "StopRouterInputCommand")    .sc(schemas_0.StopRouterInput$)    .build() {} class StopRouterOutputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "StopRouterOutput", {})    .n("MediaConnectClient", "StopRouterOutputCommand")    .sc(schemas_0.StopRouterOutput$)    .build() {} class TagGlobalResourceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "TagGlobalResource", {})    .n("MediaConnectClient", "TagGlobalResourceCommand")    .sc(schemas_0.TagGlobalResource$)    .build() {} class TagResourceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "TagResource", {})    .n("MediaConnectClient", "TagResourceCommand")    .sc(schemas_0.TagResource$)    .build() {} class TakeRouterInputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "TakeRouterInput", {})    .n("MediaConnectClient", "TakeRouterInputCommand")    .sc(schemas_0.TakeRouterInput$)    .build() {} class UntagGlobalResourceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UntagGlobalResource", {})    .n("MediaConnectClient", "UntagGlobalResourceCommand")    .sc(schemas_0.UntagGlobalResource$)    .build() {} class UntagResourceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UntagResource", {})    .n("MediaConnectClient", "UntagResourceCommand")    .sc(schemas_0.UntagResource$)    .build() {} class UpdateBridgeCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateBridge", {})    .n("MediaConnectClient", "UpdateBridgeCommand")    .sc(schemas_0.UpdateBridge$)    .build() {} class UpdateBridgeOutputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateBridgeOutput", {})    .n("MediaConnectClient", "UpdateBridgeOutputCommand")    .sc(schemas_0.UpdateBridgeOutput$)    .build() {} class UpdateBridgeSourceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateBridgeSource", {})    .n("MediaConnectClient", "UpdateBridgeSourceCommand")    .sc(schemas_0.UpdateBridgeSource$)    .build() {} class UpdateBridgeStateCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateBridgeState", {})    .n("MediaConnectClient", "UpdateBridgeStateCommand")    .sc(schemas_0.UpdateBridgeState$)    .build() {} class UpdateFlowCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateFlow", {})    .n("MediaConnectClient", "UpdateFlowCommand")    .sc(schemas_0.UpdateFlow$)    .build() {} class UpdateFlowEntitlementCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateFlowEntitlement", {})    .n("MediaConnectClient", "UpdateFlowEntitlementCommand")    .sc(schemas_0.UpdateFlowEntitlement$)    .build() {} class UpdateFlowMediaStreamCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateFlowMediaStream", {})    .n("MediaConnectClient", "UpdateFlowMediaStreamCommand")    .sc(schemas_0.UpdateFlowMediaStream$)    .build() {} class UpdateFlowOutputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateFlowOutput", {})    .n("MediaConnectClient", "UpdateFlowOutputCommand")    .sc(schemas_0.UpdateFlowOutput$)    .build() {} class UpdateFlowSourceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateFlowSource", {})    .n("MediaConnectClient", "UpdateFlowSourceCommand")    .sc(schemas_0.UpdateFlowSource$)    .build() {} class UpdateGatewayInstanceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateGatewayInstance", {})    .n("MediaConnectClient", "UpdateGatewayInstanceCommand")    .sc(schemas_0.UpdateGatewayInstance$)    .build() {} class UpdateRouterInputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateRouterInput", {})    .n("MediaConnectClient", "UpdateRouterInputCommand")    .sc(schemas_0.UpdateRouterInput$)    .build() {} class UpdateRouterNetworkInterfaceCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateRouterNetworkInterface", {})    .n("MediaConnectClient", "UpdateRouterNetworkInterfaceCommand")    .sc(schemas_0.UpdateRouterNetworkInterface$)    .build() {} class UpdateRouterOutputCommand extends client.Command    .classBuilder()    .ep(commonParams)    .m(function (Command, cs, config, o) {    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];})    .s("MediaConnect", "UpdateRouterOutput", {})    .n("MediaConnectClient", "UpdateRouterOutputCommand")    .sc(schemas_0.UpdateRouterOutput$)    .build() {} const paginateListBridges = core.createPaginator(MediaConnectClient, ListBridgesCommand, "NextToken", "NextToken", "MaxResults"); const paginateListEntitlements = core.createPaginator(MediaConnectClient, ListEntitlementsCommand, "NextToken", "NextToken", "MaxResults"); const paginateListFlows = core.createPaginator(MediaConnectClient, ListFlowsCommand, "NextToken", "NextToken", "MaxResults"); const paginateListGatewayInstances = core.createPaginator(MediaConnectClient, ListGatewayInstancesCommand, "NextToken", "NextToken", "MaxResults"); const paginateListGateways = core.createPaginator(MediaConnectClient, ListGatewaysCommand, "NextToken", "NextToken", "MaxResults"); const paginateListOfferings = core.createPaginator(MediaConnectClient, ListOfferingsCommand, "NextToken", "NextToken", "MaxResults"); const paginateListReservations = core.createPaginator(MediaConnectClient, ListReservationsCommand, "NextToken", "NextToken", "MaxResults"); const paginateListRouterInputs = core.createPaginator(MediaConnectClient, ListRouterInputsCommand, "NextToken", "NextToken", "MaxResults"); const paginateListRouterNetworkInterfaces = core.createPaginator(MediaConnectClient, ListRouterNetworkInterfacesCommand, "NextToken", "NextToken", "MaxResults"); const paginateListRouterOutputs = core.createPaginator(MediaConnectClient, ListRouterOutputsCommand, "NextToken", "NextToken", "MaxResults"); const checkState$a = async (client$1, input) => {    let reason;    try {        let result = await client$1.send(new DescribeFlowCommand(input));        reason = result;        try {            const returnComparator = () => {                return result.Flow.Status;            };            if (returnComparator() === "ACTIVE") {                return { state: client.WaiterState.SUCCESS, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.Flow.Status;            };            if (returnComparator() === "STARTING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.Flow.Status;            };            if (returnComparator() === "UPDATING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.Flow.Status;            };            if (returnComparator() === "STANDBY") {                return { state: client.WaiterState.FAILURE, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.Flow.Status;            };            if (returnComparator() === "ERROR") {                return { state: client.WaiterState.FAILURE, reason };            }        }        catch (e) { }    }    catch (exception) {        reason = exception;        if (exception.name === "InternalServerErrorException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "ServiceUnavailableException") {            return { state: client.WaiterState.RETRY, reason };        }    }    return { state: client.WaiterState.RETRY, reason };};const waitForFlowActive = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);};const waitUntilFlowActive = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);    return client.checkExceptions(result);}; const checkState$9 = async (client$1, input) => {    let reason;    try {        let result = await client$1.send(new DescribeFlowCommand(input));        reason = result;        try {            const returnComparator = () => {                return result.Flow.Status;            };            if (returnComparator() === "DELETING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.Flow.Status;            };            if (returnComparator() === "ERROR") {                return { state: client.WaiterState.FAILURE, reason };            }        }        catch (e) { }    }    catch (exception) {        reason = exception;        if (exception.name === "NotFoundException") {            return { state: client.WaiterState.SUCCESS, reason };        }        if (exception.name === "InternalServerErrorException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "ServiceUnavailableException") {            return { state: client.WaiterState.RETRY, reason };        }    }    return { state: client.WaiterState.RETRY, reason };};const waitForFlowDeleted = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);};const waitUntilFlowDeleted = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);    return client.checkExceptions(result);}; const checkState$8 = async (client$1, input) => {    let reason;    try {        let result = await client$1.send(new DescribeFlowCommand(input));        reason = result;        try {            const returnComparator = () => {                return result.Flow.Status;            };            if (returnComparator() === "STANDBY") {                return { state: client.WaiterState.SUCCESS, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.Flow.Status;            };            if (returnComparator() === "STOPPING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.Flow.Status;            };            if (returnComparator() === "ERROR") {                return { state: client.WaiterState.FAILURE, reason };            }        }        catch (e) { }    }    catch (exception) {        reason = exception;        if (exception.name === "InternalServerErrorException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "ServiceUnavailableException") {            return { state: client.WaiterState.RETRY, reason };        }    }    return { state: client.WaiterState.RETRY, reason };};const waitForFlowStandby = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);};const waitUntilFlowStandby = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);    return client.checkExceptions(result);}; const checkState$7 = async (client$1, input) => {    let reason;    try {        let result = await client$1.send(new GetRouterInputCommand(input));        reason = result;        try {            const returnComparator = () => {                return result.RouterInput.State;            };            if (returnComparator() === "ACTIVE") {                return { state: client.WaiterState.SUCCESS, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterInput.State;            };            if (returnComparator() === "STARTING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterInput.State;            };            if (returnComparator() === "UPDATING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterInput.State;            };            if (returnComparator() === "MIGRATING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterInput.State;            };            if (returnComparator() === "ERROR") {                return { state: client.WaiterState.FAILURE, reason };            }        }        catch (e) { }    }    catch (exception) {        reason = exception;        if (exception.name === "InternalServerErrorException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "ServiceUnavailableException") {            return { state: client.WaiterState.RETRY, reason };        }    }    return { state: client.WaiterState.RETRY, reason };};const waitForInputActive = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);};const waitUntilInputActive = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);    return client.checkExceptions(result);}; const checkState$6 = async (client$1, input) => {    let reason;    try {        let result = await client$1.send(new GetRouterInputCommand(input));        reason = result;        try {            const returnComparator = () => {                return result.RouterInput.State;            };            if (returnComparator() === "DELETING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterInput.State;            };            if (returnComparator() === "ERROR") {                return { state: client.WaiterState.FAILURE, reason };            }        }        catch (e) { }    }    catch (exception) {        reason = exception;        if (exception.name === "InternalServerErrorException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "ServiceUnavailableException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "NotFoundException") {            return { state: client.WaiterState.SUCCESS, reason };        }    }    return { state: client.WaiterState.RETRY, reason };};const waitForInputDeleted = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);};const waitUntilInputDeleted = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);    return client.checkExceptions(result);}; const checkState$5 = async (client$1, input) => {    let reason;    try {        let result = await client$1.send(new GetRouterInputCommand(input));        reason = result;        try {            const returnComparator = () => {                return result.RouterInput.State;            };            if (returnComparator() === "STANDBY") {                return { state: client.WaiterState.SUCCESS, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterInput.State;            };            if (returnComparator() === "STOPPING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterInput.State;            };            if (returnComparator() === "ERROR") {                return { state: client.WaiterState.FAILURE, reason };            }        }        catch (e) { }    }    catch (exception) {        reason = exception;        if (exception.name === "InternalServerErrorException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "ServiceUnavailableException") {            return { state: client.WaiterState.RETRY, reason };        }    }    return { state: client.WaiterState.RETRY, reason };};const waitForInputStandby = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);};const waitUntilInputStandby = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);    return client.checkExceptions(result);}; const checkState$4 = async (client$1, input) => {    let reason;    try {        let result = await client$1.send(new GetRouterOutputCommand(input));        reason = result;        try {            const returnComparator = () => {                return result.RouterOutput.State;            };            if (returnComparator() === "ACTIVE") {                return { state: client.WaiterState.SUCCESS, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterOutput.State;            };            if (returnComparator() === "STARTING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterOutput.State;            };            if (returnComparator() === "UPDATING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterOutput.State;            };            if (returnComparator() === "MIGRATING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterOutput.State;            };            if (returnComparator() === "ERROR") {                return { state: client.WaiterState.FAILURE, reason };            }        }        catch (e) { }    }    catch (exception) {        reason = exception;        if (exception.name === "InternalServerErrorException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "ServiceUnavailableException") {            return { state: client.WaiterState.RETRY, reason };        }    }    return { state: client.WaiterState.RETRY, reason };};const waitForOutputActive = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);};const waitUntilOutputActive = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);    return client.checkExceptions(result);}; const checkState$3 = async (client$1, input) => {    let reason;    try {        let result = await client$1.send(new GetRouterOutputCommand(input));        reason = result;        try {            const returnComparator = () => {                return result.RouterOutput.State;            };            if (returnComparator() === "DELETING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterOutput.State;            };            if (returnComparator() === "ERROR") {                return { state: client.WaiterState.FAILURE, reason };            }        }        catch (e) { }    }    catch (exception) {        reason = exception;        if (exception.name === "InternalServerErrorException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "ServiceUnavailableException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "NotFoundException") {            return { state: client.WaiterState.SUCCESS, reason };        }    }    return { state: client.WaiterState.RETRY, reason };};const waitForOutputDeleted = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);};const waitUntilOutputDeleted = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);    return client.checkExceptions(result);}; const checkState$2 = async (client$1, input) => {    let reason;    try {        let result = await client$1.send(new GetRouterOutputCommand(input));        reason = result;        try {            const returnComparator = () => {                return result.RouterOutput.RoutedState;            };            if (returnComparator() === "ROUTED") {                return { state: client.WaiterState.SUCCESS, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterOutput.RoutedState;            };            if (returnComparator() === "ROUTING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }    }    catch (exception) {        reason = exception;        if (exception.name === "InternalServerErrorException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "ServiceUnavailableException") {            return { state: client.WaiterState.RETRY, reason };        }    }    return { state: client.WaiterState.RETRY, reason };};const waitForOutputRouted = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);};const waitUntilOutputRouted = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);    return client.checkExceptions(result);}; const checkState$1 = async (client$1, input) => {    let reason;    try {        let result = await client$1.send(new GetRouterOutputCommand(input));        reason = result;        try {            const returnComparator = () => {                return result.RouterOutput.State;            };            if (returnComparator() === "STANDBY") {                return { state: client.WaiterState.SUCCESS, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterOutput.State;            };            if (returnComparator() === "STOPPING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterOutput.State;            };            if (returnComparator() === "ERROR") {                return { state: client.WaiterState.FAILURE, reason };            }        }        catch (e) { }    }    catch (exception) {        reason = exception;        if (exception.name === "InternalServerErrorException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "ServiceUnavailableException") {            return { state: client.WaiterState.RETRY, reason };        }    }    return { state: client.WaiterState.RETRY, reason };};const waitForOutputStandby = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);};const waitUntilOutputStandby = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);    return client.checkExceptions(result);}; const checkState = async (client$1, input) => {    let reason;    try {        let result = await client$1.send(new GetRouterOutputCommand(input));        reason = result;        try {            const returnComparator = () => {                return result.RouterOutput.RoutedState;            };            if (returnComparator() === "UNROUTED") {                return { state: client.WaiterState.SUCCESS, reason };            }        }        catch (e) { }        try {            const returnComparator = () => {                return result.RouterOutput.RoutedState;            };            if (returnComparator() === "ROUTING") {                return { state: client.WaiterState.RETRY, reason };            }        }        catch (e) { }    }    catch (exception) {        reason = exception;        if (exception.name === "InternalServerErrorException") {            return { state: client.WaiterState.RETRY, reason };        }        if (exception.name === "ServiceUnavailableException") {            return { state: client.WaiterState.RETRY, reason };        }    }    return { state: client.WaiterState.RETRY, reason };};const waitForOutputUnrouted = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);};const waitUntilOutputUnrouted = async (params, input) => {    const serviceDefaults = { minDelay: 3, maxDelay: 120 };    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);    return client.checkExceptions(result);}; const commands = {    AddBridgeOutputsCommand,    AddBridgeSourcesCommand,    AddFlowMediaStreamsCommand,    AddFlowOutputsCommand,    AddFlowSourcesCommand,    AddFlowVpcInterfacesCommand,    BatchGetRouterInputCommand,    BatchGetRouterNetworkInterfaceCommand,    BatchGetRouterOutputCommand,    CreateBridgeCommand,    CreateFlowCommand,    CreateGatewayCommand,    CreateRouterInputCommand,    CreateRouterNetworkInterfaceCommand,    CreateRouterOutputCommand,    DeleteBridgeCommand,    DeleteFlowCommand,    DeleteGatewayCommand,    DeleteRouterInputCommand,    DeleteRouterNetworkInterfaceCommand,    DeleteRouterOutputCommand,    DeregisterGatewayInstanceCommand,    DescribeBridgeCommand,    DescribeFlowCommand,    DescribeFlowSourceMetadataCommand,    DescribeFlowSourceThumbnailCommand,    DescribeGatewayCommand,    DescribeGatewayInstanceCommand,    DescribeOfferingCommand,    DescribeReservationCommand,    GetRouterInputCommand,    GetRouterInputSourceMetadataCommand,    GetRouterInputThumbnailCommand,    GetRouterNetworkInterfaceCommand,    GetRouterOutputCommand,    GrantFlowEntitlementsCommand,    ListBridgesCommand,    ListEntitlementsCommand,    ListFlowsCommand,    ListGatewayInstancesCommand,    ListGatewaysCommand,    ListOfferingsCommand,    ListReservationsCommand,    ListRouterInputsCommand,    ListRouterNetworkInterfacesCommand,    ListRouterOutputsCommand,    ListTagsForGlobalResourceCommand,    ListTagsForResourceCommand,    PurchaseOfferingCommand,    RemoveBridgeOutputCommand,    RemoveBridgeSourceCommand,    RemoveFlowMediaStreamCommand,    RemoveFlowOutputCommand,    RemoveFlowSourceCommand,    RemoveFlowVpcInterfaceCommand,    RestartRouterInputCommand,    RestartRouterOutputCommand,    RevokeFlowEntitlementCommand,    StartFlowCommand,    StartRouterInputCommand,    StartRouterOutputCommand,    StopFlowCommand,    StopRouterInputCommand,    StopRouterOutputCommand,    TagGlobalResourceCommand,    TagResourceCommand,    TakeRouterInputCommand,    UntagGlobalResourceCommand,    UntagResourceCommand,    UpdateBridgeCommand,    UpdateBridgeOutputCommand,    UpdateBridgeSourceCommand,    UpdateBridgeStateCommand,    UpdateFlowCommand,    UpdateFlowEntitlementCommand,    UpdateFlowMediaStreamCommand,    UpdateFlowOutputCommand,    UpdateFlowSourceCommand,    UpdateGatewayInstanceCommand,    UpdateRouterInputCommand,    UpdateRouterNetworkInterfaceCommand,    UpdateRouterOutputCommand,};const paginators = {    paginateListBridges,    paginateListEntitlements,    paginateListFlows,    paginateListGatewayInstances,    paginateListGateways,    paginateListOfferings,    paginateListReservations,    paginateListRouterInputs,    paginateListRouterNetworkInterfaces,    paginateListRouterOutputs,};const waiters = {    waitUntilFlowActive,    waitUntilFlowStandby,    waitUntilFlowDeleted,    waitUntilInputActive,    waitUntilInputStandby,    waitUntilInputDeleted,    waitUntilOutputActive,    waitUntilOutputDeleted,    waitUntilOutputRouted,    waitUntilOutputStandby,    waitUntilOutputUnrouted,};class MediaConnect extends MediaConnectClient {}client.createAggregatedClient(commands, MediaConnect, { paginators, waiters }); const Protocol = {    cdi: "cdi",    fujitsu_qos: "fujitsu-qos",    ndi_speed_hq: "ndi-speed-hq",    rist: "rist",    rtp: "rtp",    rtp_fec: "rtp-fec",    srt_caller: "srt-caller",    srt_listener: "srt-listener",    st2110_jpegxs: "st2110-jpegxs",    udp: "udp",    zixi_pull: "zixi-pull",    zixi_push: "zixi-push",};const Colorimetry = {    BT2020: "BT2020",    BT2100: "BT2100",    BT601: "BT601",    BT709: "BT709",    ST2065_1: "ST2065-1",    ST2065_3: "ST2065-3",    XYZ: "XYZ",};const Range = {    FULL: "FULL",    FULLPROTECT: "FULLPROTECT",    NARROW: "NARROW",};const ScanMode = {    interlace: "interlace",    progressive: "progressive",    progressive_segmented_frame: "progressive-segmented-frame",};const Tcs = {    BT2100LINHLG: "BT2100LINHLG",    BT2100LINPQ: "BT2100LINPQ",    DENSITY: "DENSITY",    HLG: "HLG",    LINEAR: "LINEAR",    PQ: "PQ",    SDR: "SDR",    ST2065_1: "ST2065-1",    ST428_1: "ST428-1",};const MediaStreamType = {    ancillary_data: "ancillary-data",    audio: "audio",    video: "video",};const Algorithm = {    aes128: "aes128",    aes192: "aes192",    aes256: "aes256",};const KeyType = {    speke: "speke",    srt_password: "srt-password",    static_key: "static-key",};const EncodingName = {    jxsv: "jxsv",    pcm: "pcm",    raw: "raw",    smpte291: "smpte291",};const EncoderProfile = {    high: "high",    main: "main",};const OutputStatus = {    DISABLED: "DISABLED",    ENABLED: "ENABLED",};const State = {    DISABLED: "DISABLED",    ENABLED: "ENABLED",};const FlowTransitEncryptionKeyType = {    AUTOMATIC: "AUTOMATIC",    SECRETS_MANAGER: "SECRETS_MANAGER",};const EntitlementStatus = {    DISABLED: "DISABLED",    ENABLED: "ENABLED",};const BridgeState = {    ACTIVE: "ACTIVE",    CREATING: "CREATING",    DELETED: "DELETED",    DELETING: "DELETING",    DEPLOYING: "DEPLOYING",    STANDBY: "STANDBY",    STARTING: "STARTING",    START_FAILED: "START_FAILED",    START_PENDING: "START_PENDING",    STOPPING: "STOPPING",    STOP_FAILED: "STOP_FAILED",    UPDATING: "UPDATING",};const MaintenanceDay = {    Friday: "Friday",    Monday: "Monday",    Saturday: "Saturday",    Sunday: "Sunday",    Thursday: "Thursday",    Tuesday: "Tuesday",    Wednesday: "Wednesday",};const SourceType = {    ENTITLED: "ENTITLED",    OWNED: "OWNED",};const Status = {    ACTIVE: "ACTIVE",    DELETING: "DELETING",    ERROR: "ERROR",    STANDBY: "STANDBY",    STARTING: "STARTING",    STOPPING: "STOPPING",    UPDATING: "UPDATING",};const GatewayState = {    ACTIVE: "ACTIVE",    CREATING: "CREATING",    DELETED: "DELETED",    DELETING: "DELETING",    ERROR: "ERROR",    UPDATING: "UPDATING",};const InstanceState = {    ACTIVE: "ACTIVE",    DEREGISTERED: "DEREGISTERED",    DEREGISTERING: "DEREGISTERING",    DEREGISTRATION_ERROR: "DEREGISTRATION_ERROR",    REGISTERING: "REGISTERING",    REGISTRATION_ERROR: "REGISTRATION_ERROR",};const DurationUnits = {    MONTHS: "MONTHS",};const PriceUnits = {    HOURLY: "HOURLY",};const ResourceType = {    Mbps_Outbound_Bandwidth: "Mbps_Outbound_Bandwidth",};const ReservationState = {    ACTIVE: "ACTIVE",    CANCELED: "CANCELED",    EXPIRED: "EXPIRED",    PROCESSING: "PROCESSING",};const NetworkInterfaceType = {    efa: "efa",    ena: "ena",};const ForwardErrorCorrectionState = {    DISABLED: "DISABLED",    ENABLED: "ENABLED",};const FailoverInputSourcePriorityMode = {    NO_PRIORITY: "NO_PRIORITY",    PRIMARY_SECONDARY: "PRIMARY_SECONDARY",};const MediaLiveChannelPipelineId = {    PIPELINE_0: "PIPELINE_0",    PIPELINE_1: "PIPELINE_1",};const MediaLiveTransitEncryptionKeyType = {    AUTOMATIC: "AUTOMATIC",    SECRETS_MANAGER: "SECRETS_MANAGER",};const RouterInputProtocol = {    RIST: "RIST",    RTP: "RTP",    SRT_CALLER: "SRT_CALLER",    SRT_LISTENER: "SRT_LISTENER",};const RouterInputType = {    FAILOVER: "FAILOVER",    MEDIACONNECT_FLOW: "MEDIACONNECT_FLOW",    MEDIALIVE_CHANNEL: "MEDIALIVE_CHANNEL",    MERGE: "MERGE",    STANDARD: "STANDARD",};const Day = {    FRIDAY: "FRIDAY",    MONDAY: "MONDAY",    SATURDAY: "SATURDAY",    SUNDAY: "SUNDAY",    THURSDAY: "THURSDAY",    TUESDAY: "TUESDAY",    WEDNESDAY: "WEDNESDAY",};const MaintenanceScheduleType = {    WINDOW: "WINDOW",};const MaintenanceType = {    DEFAULT: "DEFAULT",    PREFERRED_DAY_TIME: "PREFERRED_DAY_TIME",};const RoutingScope = {    GLOBAL: "GLOBAL",    REGIONAL: "REGIONAL",};const RouterInputState = {    ACTIVE: "ACTIVE",    CREATING: "CREATING",    DELETING: "DELETING",    ERROR: "ERROR",    MIGRATING: "MIGRATING",    RECOVERING: "RECOVERING",    STANDBY: "STANDBY",    STARTING: "STARTING",    STOPPING: "STOPPING",    UPDATING: "UPDATING",};const RouterInputTier = {    INPUT_100: "INPUT_100",    INPUT_20: "INPUT_20",    INPUT_50: "INPUT_50",};const RouterInputTransitEncryptionKeyType = {    AUTOMATIC: "AUTOMATIC",    SECRETS_MANAGER: "SECRETS_MANAGER",};const RouterNetworkInterfaceType = {    PUBLIC: "PUBLIC",    VPC: "VPC",};const RouterNetworkInterfaceState = {    ACTIVE: "ACTIVE",    CREATING: "CREATING",    DELETING: "DELETING",    ERROR: "ERROR",    RECOVERING: "RECOVERING",    UPDATING: "UPDATING",};const MediaLiveInputPipelineId = {    PIPELINE_0: "PIPELINE_0",    PIPELINE_1: "PIPELINE_1",};const RouterOutputProtocol = {    RIST: "RIST",    RTP: "RTP",    SRT_CALLER: "SRT_CALLER",    SRT_LISTENER: "SRT_LISTENER",};const RouterOutputType = {    MEDIACONNECT_FLOW: "MEDIACONNECT_FLOW",    MEDIALIVE_INPUT: "MEDIALIVE_INPUT",    STANDARD: "STANDARD",};const RouterOutputRoutedState = {    ROUTED: "ROUTED",    ROUTING: "ROUTING",    UNROUTED: "UNROUTED",};const RouterOutputState = {    ACTIVE: "ACTIVE",    CREATING: "CREATING",    DELETING: "DELETING",    ERROR: "ERROR",    MIGRATING: "MIGRATING",    RECOVERING: "RECOVERING",    STANDBY: "STANDBY",    STARTING: "STARTING",    STOPPING: "STOPPING",    UPDATING: "UPDATING",};const RouterOutputTier = {    OUTPUT_100: "OUTPUT_100",    OUTPUT_20: "OUTPUT_20",    OUTPUT_50: "OUTPUT_50",};const FailoverMode = {    FAILOVER: "FAILOVER",    MERGE: "MERGE",};const BridgePlacement = {    AVAILABLE: "AVAILABLE",    LOCKED: "LOCKED",};const DesiredState = {    ACTIVE: "ACTIVE",    DELETED: "DELETED",    STANDBY: "STANDBY",};const ConnectionStatus = {    CONNECTED: "CONNECTED",    DISCONNECTED: "DISCONNECTED",};const ContentQualityAnalysisState = {    DISABLED: "DISABLED",    ENABLED: "ENABLED",};const EncodingProfile = {    CONTRIBUTION_H264_DEFAULT: "CONTRIBUTION_H264_DEFAULT",    DISTRIBUTION_H264_DEFAULT: "DISTRIBUTION_H264_DEFAULT",};const FlowSize = {    LARGE: "LARGE",    LARGE_4X: "LARGE_4X",    MEDIUM: "MEDIUM",};const NdiState = {    DISABLED: "DISABLED",    ENABLED: "ENABLED",};const ThumbnailState = {    DISABLED: "DISABLED",    ENABLED: "ENABLED",}; exports.$Command = client.Command;exports.__Client = client.Client;exports.MediaConnectServiceException = MediaConnectServiceException.MediaConnectServiceException;exports.AddBridgeOutputsCommand = AddBridgeOutputsCommand;exports.AddBridgeSourcesCommand = AddBridgeSourcesCommand;exports.AddFlowMediaStreamsCommand = AddFlowMediaStreamsCommand;exports.AddFlowOutputsCommand = AddFlowOutputsCommand;exports.AddFlowSourcesCommand = AddFlowSourcesCommand;exports.AddFlowVpcInterfacesCommand = AddFlowVpcInterfacesCommand;exports.Algorithm = Algorithm;exports.BatchGetRouterInputCommand = BatchGetRouterInputCommand;exports.BatchGetRouterNetworkInterfaceCommand = BatchGetRouterNetworkInterfaceCommand;exports.BatchGetRouterOutputCommand = BatchGetRouterOutputCommand;exports.BridgePlacement = BridgePlacement;exports.BridgeState = BridgeState;exports.Colorimetry = Colorimetry;exports.ConnectionStatus = ConnectionStatus;exports.ContentQualityAnalysisState = ContentQualityAnalysisState;exports.CreateBridgeCommand = CreateBridgeCommand;exports.CreateFlowCommand = CreateFlowCommand;exports.CreateGatewayCommand = CreateGatewayCommand;exports.CreateRouterInputCommand = CreateRouterInputCommand;exports.CreateRouterNetworkInterfaceCommand = CreateRouterNetworkInterfaceCommand;exports.CreateRouterOutputCommand = CreateRouterOutputCommand;exports.Day = Day;exports.DeleteBridgeCommand = DeleteBridgeCommand;exports.DeleteFlowCommand = DeleteFlowCommand;exports.DeleteGatewayCommand = DeleteGatewayCommand;exports.DeleteRouterInputCommand = DeleteRouterInputCommand;exports.DeleteRouterNetworkInterfaceCommand = DeleteRouterNetworkInterfaceCommand;exports.DeleteRouterOutputCommand = DeleteRouterOutputCommand;exports.DeregisterGatewayInstanceCommand = DeregisterGatewayInstanceCommand;exports.DescribeBridgeCommand = DescribeBridgeCommand;exports.DescribeFlowCommand = DescribeFlowCommand;exports.DescribeFlowSourceMetadataCommand = DescribeFlowSourceMetadataCommand;exports.DescribeFlowSourceThumbnailCommand = DescribeFlowSourceThumbnailCommand;exports.DescribeGatewayCommand = DescribeGatewayCommand;exports.DescribeGatewayInstanceCommand = DescribeGatewayInstanceCommand;exports.DescribeOfferingCommand = DescribeOfferingCommand;exports.DescribeReservationCommand = DescribeReservationCommand;exports.DesiredState = DesiredState;exports.DurationUnits = DurationUnits;exports.EncoderProfile = EncoderProfile;exports.EncodingName = EncodingName;exports.EncodingProfile = EncodingProfile;exports.EntitlementStatus = EntitlementStatus;exports.FailoverInputSourcePriorityMode = FailoverInputSourcePriorityMode;exports.FailoverMode = FailoverMode;exports.FlowSize = FlowSize;exports.FlowTransitEncryptionKeyType = FlowTransitEncryptionKeyType;exports.ForwardErrorCorrectionState = ForwardErrorCorrectionState;exports.GatewayState = GatewayState;exports.GetRouterInputCommand = GetRouterInputCommand;exports.GetRouterInputSourceMetadataCommand = GetRouterInputSourceMetadataCommand;exports.GetRouterInputThumbnailCommand = GetRouterInputThumbnailCommand;exports.GetRouterNetworkInterfaceCommand = GetRouterNetworkInterfaceCommand;exports.GetRouterOutputCommand = GetRouterOutputCommand;exports.GrantFlowEntitlementsCommand = GrantFlowEntitlementsCommand;exports.InstanceState = InstanceState;exports.KeyType = KeyType;exports.ListBridgesCommand = ListBridgesCommand;exports.ListEntitlementsCommand = ListEntitlementsCommand;exports.ListFlowsCommand = ListFlowsCommand;exports.ListGatewayInstancesCommand = ListGatewayInstancesCommand;exports.ListGatewaysCommand = ListGatewaysCommand;exports.ListOfferingsCommand = ListOfferingsCommand;exports.ListReservationsCommand = ListReservationsCommand;exports.ListRouterInputsCommand = ListRouterInputsCommand;exports.ListRouterNetworkInterfacesCommand = ListRouterNetworkInterfacesCommand;exports.ListRouterOutputsCommand = ListRouterOutputsCommand;exports.ListTagsForGlobalResourceCommand = ListTagsForGlobalResourceCommand;exports.ListTagsForResourceCommand = ListTagsForResourceCommand;exports.MaintenanceDay = MaintenanceDay;exports.MaintenanceScheduleType = MaintenanceScheduleType;exports.MaintenanceType = MaintenanceType;exports.MediaConnect = MediaConnect;exports.MediaConnectClient = MediaConnectClient;exports.MediaLiveChannelPipelineId = MediaLiveChannelPipelineId;exports.MediaLiveInputPipelineId = MediaLiveInputPipelineId;exports.MediaLiveTransitEncryptionKeyType = MediaLiveTransitEncryptionKeyType;exports.MediaStreamType = MediaStreamType;exports.NdiState = NdiState;exports.NetworkInterfaceType = NetworkInterfaceType;exports.OutputStatus = OutputStatus;exports.PriceUnits = PriceUnits;exports.Protocol = Protocol;exports.PurchaseOfferingCommand = PurchaseOfferingCommand;exports.Range = Range;exports.RemoveBridgeOutputCommand = RemoveBridgeOutputCommand;exports.RemoveBridgeSourceCommand = RemoveBridgeSourceCommand;exports.RemoveFlowMediaStreamCommand = RemoveFlowMediaStreamCommand;exports.RemoveFlowOutputCommand = RemoveFlowOutputCommand;exports.RemoveFlowSourceCommand = RemoveFlowSourceCommand;exports.RemoveFlowVpcInterfaceCommand = RemoveFlowVpcInterfaceCommand;exports.ReservationState = ReservationState;exports.ResourceType = ResourceType;exports.RestartRouterInputCommand = RestartRouterInputCommand;exports.RestartRouterOutputCommand = RestartRouterOutputCommand;exports.RevokeFlowEntitlementCommand = RevokeFlowEntitlementCommand;exports.RouterInputProtocol = RouterInputProtocol;exports.RouterInputState = RouterInputState;exports.RouterInputTier = RouterInputTier;exports.RouterInputTransitEncryptionKeyType = RouterInputTransitEncryptionKeyType;exports.RouterInputType = RouterInputType;exports.RouterNetworkInterfaceState = RouterNetworkInterfaceState;exports.RouterNetworkInterfaceType = RouterNetworkInterfaceType;exports.RouterOutputProtocol = RouterOutputProtocol;exports.RouterOutputRoutedState = RouterOutputRoutedState;exports.RouterOutputState = RouterOutputState;exports.RouterOutputTier = RouterOutputTier;exports.RouterOutputType = RouterOutputType;exports.RoutingScope = RoutingScope;exports.ScanMode = ScanMode;exports.SourceType = SourceType;exports.StartFlowCommand = StartFlowCommand;exports.StartRouterInputCommand = StartRouterInputCommand;exports.StartRouterOutputCommand = StartRouterOutputCommand;exports.State = State;exports.Status = Status;exports.StopFlowCommand = StopFlowCommand;exports.StopRouterInputCommand = StopRouterInputCommand;exports.StopRouterOutputCommand = StopRouterOutputCommand;exports.TagGlobalResourceCommand = TagGlobalResourceCommand;exports.TagResourceCommand = TagResourceCommand;exports.TakeRouterInputCommand = TakeRouterInputCommand;exports.Tcs = Tcs;exports.ThumbnailState = ThumbnailState;exports.UntagGlobalResourceCommand = UntagGlobalResourceCommand;exports.UntagResourceCommand = UntagResourceCommand;exports.UpdateBridgeCommand = UpdateBridgeCommand;exports.UpdateBridgeOutputCommand = UpdateBridgeOutputCommand;exports.UpdateBridgeSourceCommand = UpdateBridgeSourceCommand;exports.UpdateBridgeStateCommand = UpdateBridgeStateCommand;exports.UpdateFlowCommand = UpdateFlowCommand;exports.UpdateFlowEntitlementCommand = UpdateFlowEntitlementCommand;exports.UpdateFlowMediaStreamCommand = UpdateFlowMediaStreamCommand;exports.UpdateFlowOutputCommand = UpdateFlowOutputCommand;exports.UpdateFlowSourceCommand = UpdateFlowSourceCommand;exports.UpdateGatewayInstanceCommand = UpdateGatewayInstanceCommand;exports.UpdateRouterInputCommand = UpdateRouterInputCommand;exports.UpdateRouterNetworkInterfaceCommand = UpdateRouterNetworkInterfaceCommand;exports.UpdateRouterOutputCommand = UpdateRouterOutputCommand;exports.paginateListBridges = paginateListBridges;exports.paginateListEntitlements = paginateListEntitlements;exports.paginateListFlows = paginateListFlows;exports.paginateListGatewayInstances = paginateListGatewayInstances;exports.paginateListGateways = paginateListGateways;exports.paginateListOfferings = paginateListOfferings;exports.paginateListReservations = paginateListReservations;exports.paginateListRouterInputs = paginateListRouterInputs;exports.paginateListRouterNetworkInterfaces = paginateListRouterNetworkInterfaces;exports.paginateListRouterOutputs = paginateListRouterOutputs;exports.waitForFlowActive = waitForFlowActive;exports.waitForFlowDeleted = waitForFlowDeleted;exports.waitForFlowStandby = waitForFlowStandby;exports.waitForInputActive = waitForInputActive;exports.waitForInputDeleted = waitForInputDeleted;exports.waitForInputStandby = waitForInputStandby;exports.waitForOutputActive = waitForOutputActive;exports.waitForOutputDeleted = waitForOutputDeleted;exports.waitForOutputRouted = waitForOutputRouted;exports.waitForOutputStandby = waitForOutputStandby;exports.waitForOutputUnrouted = waitForOutputUnrouted;exports.waitUntilFlowActive = waitUntilFlowActive;exports.waitUntilFlowDeleted = waitUntilFlowDeleted;exports.waitUntilFlowStandby = waitUntilFlowStandby;exports.waitUntilInputActive = waitUntilInputActive;exports.waitUntilInputDeleted = waitUntilInputDeleted;exports.waitUntilInputStandby = waitUntilInputStandby;exports.waitUntilOutputActive = waitUntilOutputActive;exports.waitUntilOutputDeleted = waitUntilOutputDeleted;exports.waitUntilOutputRouted = waitUntilOutputRouted;exports.waitUntilOutputStandby = waitUntilOutputStandby;exports.waitUntilOutputUnrouted = waitUntilOutputUnrouted;Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&    Object.defineProperty(exports, '__proto__', {        enumerable: true,        value: schemas_0['__proto__']    }); Object.keys(schemas_0).forEach(function (k) {    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];});Object.prototype.hasOwnProperty.call(errors, '__proto__') &&    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&    Object.defineProperty(exports, '__proto__', {        enumerable: true,        value: errors['__proto__']    }); Object.keys(errors).forEach(function (k) {    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];});