@aws-sdk/client-kinesis-video 3.1075.0 → 3.1076.0

package/dist-cjs/index.js

@@ -1,21 +1,57 @@
-var __exportStar = (m, e) => { Object.assign(e, m); };
-const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
 const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
-const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
+const { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
 exports.$Command = Command;
 exports.__Client = Client;
-const { resolveRegionConfig } = require("@smithy/core/config");
-const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
-const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
-const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
-const { getSchemaSerdePlugin } = require("@smithy/core/schema");
-const { resolveHttpAuthSchemeConfig, defaultKinesisVideoHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
-const { getRuntimeConfig } = require("./runtimeConfig");
-const { CreateSignalingChannel$, CreateStream$, DeleteEdgeConfiguration$, DeleteSignalingChannel$, DeleteStream$, DescribeEdgeConfiguration$, DescribeImageGenerationConfiguration$, DescribeMappedResourceConfiguration$, DescribeMediaStorageConfiguration$, DescribeNotificationConfiguration$, DescribeSignalingChannel$, DescribeStream$, DescribeStreamStorageConfiguration$, GetDataEndpoint$, GetSignalingChannelEndpoint$, ListEdgeAgentConfigurations$, ListSignalingChannels$, ListStreams$, ListTagsForResource$, ListTagsForStream$, StartEdgeConfigurationUpdate$, TagResource$, TagStream$, UntagResource$, UntagStream$, UpdateDataRetention$, UpdateImageGenerationConfiguration$, UpdateMediaStorageConfiguration$, UpdateNotificationConfiguration$, UpdateSignalingChannel$, UpdateStream$, UpdateStreamStorageConfiguration$ } = require("./schemas/schemas_0");
-__exportStar(require("./schemas/schemas_0"), exports);
-__exportStar(require("./models/errors"), exports);
-const { KinesisVideoServiceException } = require("./models/KinesisVideoServiceException");
-exports.KinesisVideoServiceException = KinesisVideoServiceException;
+const { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require("@smithy/core/config");
+const { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { TypeRegistry, getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require("@aws-sdk/core/httpAuthSchemes");
+const { defaultProvider } = require("@aws-sdk/credential-provider-node");
+const { toUtf8, fromUtf8, toBase64, fromBase64, Hash, calculateBodyLength } = require("@smithy/core/serde");
+const { streamCollector, NodeHttpHandler } = require("@smithy/node-http-handler");
+const { AwsRestJsonProtocol } = require("@aws-sdk/core/protocols");
+
+const defaultKinesisVideoHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    return {
+        operation: getSmithyContext(context).operation,
+        region: await normalizeProvider(config.region)() || (() => {
+            throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+        })(),
+    };
+};
+function createAwsAuthSigv4HttpAuthOption(authParameters) {
+    return {
+        schemeId: "aws.auth#sigv4",
+        signingProperties: {
+            name: "kinesisvideo",
+            region: authParameters.region,
+        },
+        propertiesExtractor: (config, context) => ({
+            signingProperties: {
+                config,
+                context,
+            },
+        }),
+    };
+}
+const defaultKinesisVideoHttpAuthSchemeProvider = (authParameters) => {
+    const options = [];
+    switch (authParameters.operation) {
+        default: {
+            options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
+        }
+    }
+    return options;
+};
+const resolveHttpAuthSchemeConfig = (config) => {
+    const config_0 = resolveAwsSdkSigV4Config(config);
+    return Object.assign(config_0, {
+        authSchemePreference: normalizeProvider(config.authSchemePreference ?? []),
+    });
+};
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -31,6 +67,1233 @@ const commonParams = {
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
+var version = "3.1075.0";
+var packageInfo = {
+	version: version};
+
+const k = "ref";
+const a = -1, b = true, c = "isSet", d = "PartitionResult", e = "booleanEquals", f = "getAttr", g = { [k]: "Endpoint" }, h = { [k]: d }, i = {}, j = [{ [k]: "Region" }];
+const _data = {
+    conditions: [
+        [c, [g]],
+        [c, j],
+        ["aws.partition", j, d],
+        [e, [{ [k]: "UseFIPS" }, b]],
+        [e, [{ [k]: "UseDualStack" }, b]],
+        [e, [{ fn: f, argv: [h, "supportsDualStack"] }, b]],
+        [e, [{ fn: f, argv: [h, "supportsFIPS"] }, b]]
+    ],
+    results: [
+        [a],
+        [a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
+        [a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
+        [g, i],
+        ["https://kinesisvideo-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
+        ["https://kinesisvideo-fips.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "FIPS is enabled but this partition does not support FIPS"],
+        ["https://kinesisvideo.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "DualStack is enabled but this partition does not support DualStack"],
+        ["https://kinesisvideo.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "Invalid Configuration: Missing Region"]
+    ]
+};
+const root = 2;
+const r = 100_000_000;
+const nodes = new Int32Array([
+    -1, 1, -1,
+    0, 12, 3,
+    1, 4, r + 11,
+    2, 5, r + 11,
+    3, 8, 6,
+    4, 7, r + 10,
+    5, r + 8, r + 9,
+    4, 10, 9,
+    6, r + 6, r + 7,
+    5, 11, r + 5,
+    6, r + 4, r + 5,
+    3, r + 1, 13,
+    4, r + 2, r + 3,
+]);
+const bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
+
+const cache = new EndpointCache({
+    size: 50,
+    params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"],
+});
+const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return cache.get(endpointParams, () => decideEndpoint(bdd, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    }));
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+class KinesisVideoServiceException extends ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, KinesisVideoServiceException.prototype);
+    }
+}
+
+class AccessDeniedException extends KinesisVideoServiceException {
+    name = "AccessDeniedException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class AccountChannelLimitExceededException extends KinesisVideoServiceException {
+    name = "AccountChannelLimitExceededException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "AccountChannelLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AccountChannelLimitExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class AccountStreamLimitExceededException extends KinesisVideoServiceException {
+    name = "AccountStreamLimitExceededException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "AccountStreamLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AccountStreamLimitExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ClientLimitExceededException extends KinesisVideoServiceException {
+    name = "ClientLimitExceededException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ClientLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ClientLimitExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class InvalidArgumentException extends KinesisVideoServiceException {
+    name = "InvalidArgumentException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "InvalidArgumentException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidArgumentException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ResourceInUseException extends KinesisVideoServiceException {
+    name = "ResourceInUseException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ResourceInUseException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceInUseException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class TagsPerResourceExceededLimitException extends KinesisVideoServiceException {
+    name = "TagsPerResourceExceededLimitException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "TagsPerResourceExceededLimitException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TagsPerResourceExceededLimitException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class DeviceStreamLimitExceededException extends KinesisVideoServiceException {
+    name = "DeviceStreamLimitExceededException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "DeviceStreamLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DeviceStreamLimitExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class InvalidDeviceException extends KinesisVideoServiceException {
+    name = "InvalidDeviceException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "InvalidDeviceException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDeviceException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ResourceNotFoundException extends KinesisVideoServiceException {
+    name = "ResourceNotFoundException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class StreamEdgeConfigurationNotFoundException extends KinesisVideoServiceException {
+    name = "StreamEdgeConfigurationNotFoundException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "StreamEdgeConfigurationNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, StreamEdgeConfigurationNotFoundException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class VersionMismatchException extends KinesisVideoServiceException {
+    name = "VersionMismatchException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "VersionMismatchException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, VersionMismatchException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class NotAuthorizedException extends KinesisVideoServiceException {
+    name = "NotAuthorizedException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "NotAuthorizedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NotAuthorizedException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class InvalidResourceFormatException extends KinesisVideoServiceException {
+    name = "InvalidResourceFormatException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "InvalidResourceFormatException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidResourceFormatException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class NoDataRetentionException extends KinesisVideoServiceException {
+    name = "NoDataRetentionException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "NoDataRetentionException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NoDataRetentionException.prototype);
+        this.Message = opts.Message;
+    }
+}
+
+const _ACLEE = "AccountChannelLimitExceededException";
+const _ADE = "AccessDeniedException";
+const _APIN = "APIName";
+const _ARN = "ARN";
+const _ASLEE = "AccountStreamLimitExceededException";
+const _CARN = "ChannelARN";
+const _CI = "ChannelInfo";
+const _CIL = "ChannelInfoList";
+const _CLEE = "ClientLimitExceededException";
+const _CN = "ChannelName";
+const _CNC = "ChannelNameCondition";
+const _CO = "ComparisonOperator";
+const _CS = "ChannelStatus";
+const _CSC = "CreateSignalingChannel";
+const _CSCI = "CreateSignalingChannelInput";
+const _CSCO = "CreateSignalingChannelOutput";
+const _CSI = "CreateStreamInput";
+const _CSO = "CreateStreamOutput";
+const _CSr = "CreateStream";
+const _CT = "ChannelType";
+const _CTr = "CreationTime";
+const _CV = "ComparisonValue";
+const _CVu = "CurrentVersion";
+const _DAU = "DeleteAfterUpload";
+const _DC = "DeletionConfig";
+const _DCe = "DestinationConfig";
+const _DE = "DataEndpoint";
+const _DEC = "DeleteEdgeConfiguration";
+const _DECI = "DeleteEdgeConfigurationInput";
+const _DECIe = "DescribeEdgeConfigurationInput";
+const _DECO = "DeleteEdgeConfigurationOutput";
+const _DECOe = "DescribeEdgeConfigurationOutput";
+const _DECe = "DescribeEdgeConfiguration";
+const _DIGC = "DescribeImageGenerationConfiguration";
+const _DIGCI = "DescribeImageGenerationConfigurationInput";
+const _DIGCO = "DescribeImageGenerationConfigurationOutput";
+const _DIS = "DurationInSeconds";
+const _DMRC = "DescribeMappedResourceConfiguration";
+const _DMRCI = "DescribeMappedResourceConfigurationInput";
+const _DMRCO = "DescribeMappedResourceConfigurationOutput";
+const _DMSC = "DescribeMediaStorageConfiguration";
+const _DMSCI = "DescribeMediaStorageConfigurationInput";
+const _DMSCO = "DescribeMediaStorageConfigurationOutput";
+const _DN = "DeviceName";
+const _DNC = "DescribeNotificationConfiguration";
+const _DNCI = "DescribeNotificationConfigurationInput";
+const _DNCO = "DescribeNotificationConfigurationOutput";
+const _DR = "DestinationRegion";
+const _DRCIH = "DataRetentionChangeInHours";
+const _DRIH = "DataRetentionInHours";
+const _DS = "DeleteStream";
+const _DSC = "DeleteSignalingChannel";
+const _DSCI = "DeleteSignalingChannelInput";
+const _DSCIe = "DescribeSignalingChannelInput";
+const _DSCO = "DeleteSignalingChannelOutput";
+const _DSCOe = "DescribeSignalingChannelOutput";
+const _DSCe = "DescribeSignalingChannel";
+const _DSI = "DeleteStreamInput";
+const _DSIe = "DescribeStreamInput";
+const _DSLEE = "DeviceStreamLimitExceededException";
+const _DSO = "DeleteStreamOutput";
+const _DSOe = "DescribeStreamOutput";
+const _DSSC = "DescribeStreamStorageConfiguration";
+const _DSSCI = "DescribeStreamStorageConfigurationInput";
+const _DSSCO = "DescribeStreamStorageConfigurationOutput";
+const _DST = "DefaultStorageTier";
+const _DSe = "DescribeStream";
+const _EAS = "EdgeAgentStatus";
+const _EC = "EdgeConfig";
+const _ECd = "EdgeConfigs";
+const _ERIH = "EdgeRetentionInHours";
+const _F = "Format";
+const _FC = "FormatConfig";
+const _FSD = "FailedStatusDetails";
+const _GDE = "GetDataEndpoint";
+const _GDEI = "GetDataEndpointInput";
+const _GDEO = "GetDataEndpointOutput";
+const _GSCE = "GetSignalingChannelEndpoint";
+const _GSCEI = "GetSignalingChannelEndpointInput";
+const _GSCEO = "GetSignalingChannelEndpointOutput";
+const _HDA = "HubDeviceArn";
+const _HP = "HeightPixels";
+const _IAE = "InvalidArgumentException";
+const _IDE = "InvalidDeviceException";
+const _IGC = "ImageGenerationConfiguration";
+const _IGDC = "ImageGenerationDestinationConfig";
+const _IRFE = "InvalidResourceFormatException";
+const _IST = "ImageSelectorType";
+const _JSD = "JobStatusDetails";
+const _K = "Key";
+const _KKI = "KmsKeyId";
+const _LCT = "LastCollectedTime";
+const _LEAC = "ListEdgeAgentConfigurations";
+const _LEACEC = "ListEdgeAgentConfigurationsEdgeConfig";
+const _LEACECL = "ListEdgeAgentConfigurationsEdgeConfigList";
+const _LEACI = "ListEdgeAgentConfigurationsInput";
+const _LEACO = "ListEdgeAgentConfigurationsOutput";
+const _LRS = "LastRecorderStatus";
+const _LS = "ListStreams";
+const _LSC = "LocalSizeConfig";
+const _LSCI = "ListSignalingChannelsInput";
+const _LSCO = "ListSignalingChannelsOutput";
+const _LSCi = "ListSignalingChannels";
+const _LSI = "ListStreamsInput";
+const _LSO = "ListStreamsOutput";
+const _LTFR = "ListTagsForResource";
+const _LTFRI = "ListTagsForResourceInput";
+const _LTFRO = "ListTagsForResourceOutput";
+const _LTFS = "ListTagsForStream";
+const _LTFSI = "ListTagsForStreamInput";
+const _LTFSO = "ListTagsForStreamOutput";
+const _LUS = "LastUploaderStatus";
+const _LUT = "LastUpdatedTime";
+const _M = "Message";
+const _MLMSIMB = "MaxLocalMediaSizeInMB";
+const _MR = "MaxResults";
+const _MRCL = "MappedResourceConfigurationList";
+const _MRCLI = "MappedResourceConfigurationListItem";
+const _MSC = "MediaStorageConfiguration";
+const _MSCe = "MediaSourceConfig";
+const _MT = "MediaType";
+const _MTS = "MessageTtlSeconds";
+const _MUSA = "MediaUriSecretArn";
+const _MUT = "MediaUriType";
+const _NAE = "NotAuthorizedException";
+const _NC = "NotificationConfiguration";
+const _NDC = "NotificationDestinationConfig";
+const _NDRE = "NoDataRetentionException";
+const _NT = "NextToken";
+const _O = "Operation";
+const _P = "Protocol";
+const _Pr = "Protocols";
+const _R = "Role";
+const _RARN = "ResourceARN";
+const _RC = "RecorderConfig";
+const _RE = "ResourceEndpoint";
+const _REL = "ResourceEndpointList";
+const _RELI = "ResourceEndpointListItem";
+const _RIUE = "ResourceInUseException";
+const _RNFE = "ResourceNotFoundException";
+const _RS = "RecorderStatus";
+const _S = "Status";
+const _SARN = "StreamARN";
+const _SC = "ScheduleConfig";
+const _SE = "ScheduleExpression";
+const _SECNFE = "StreamEdgeConfigurationNotFoundException";
+const _SECU = "StartEdgeConfigurationUpdate";
+const _SECUI = "StartEdgeConfigurationUpdateInput";
+const _SECUO = "StartEdgeConfigurationUpdateOutput";
+const _SI = "StreamInfo";
+const _SIL = "StreamInfoList";
+const _SIa = "SamplingInterval";
+const _SMC = "SingleMasterConfiguration";
+const _SMCEC = "SingleMasterChannelEndpointConfiguration";
+const _SN = "StreamName";
+const _SNC = "StreamNameCondition";
+const _SOFS = "StrategyOnFullSize";
+const _SS = "SyncStatus";
+const _SSC = "StreamStorageConfiguration";
+const _T = "Tags";
+const _TKL = "TagKeyList";
+const _TL = "TagList";
+const _TOCL = "TagOnCreateList";
+const _TPRELE = "TagsPerResourceExceededLimitException";
+const _TR = "TagResource";
+const _TRI = "TagResourceInput";
+const _TRO = "TagResourceOutput";
+const _TS = "TagStream";
+const _TSI = "TagStreamInput";
+const _TSO = "TagStreamOutput";
+const _Ta = "Tag";
+const _Ty = "Type";
+const _U = "Uri";
+const _UC = "UploaderConfig";
+const _UDR = "UpdateDataRetention";
+const _UDRI = "UpdateDataRetentionInput";
+const _UDRO = "UpdateDataRetentionOutput";
+const _UIGC = "UpdateImageGenerationConfiguration";
+const _UIGCI = "UpdateImageGenerationConfigurationInput";
+const _UIGCO = "UpdateImageGenerationConfigurationOutput";
+const _UMSC = "UpdateMediaStorageConfiguration";
+const _UMSCI = "UpdateMediaStorageConfigurationInput";
+const _UMSCO = "UpdateMediaStorageConfigurationOutput";
+const _UNC = "UpdateNotificationConfiguration";
+const _UNCI = "UpdateNotificationConfigurationInput";
+const _UNCO = "UpdateNotificationConfigurationOutput";
+const _UR = "UntagResource";
+const _URI = "UntagResourceInput";
+const _URO = "UntagResourceOutput";
+const _US = "UploaderStatus";
+const _USC = "UpdateSignalingChannel";
+const _USCI = "UpdateSignalingChannelInput";
+const _USCO = "UpdateSignalingChannelOutput";
+const _USI = "UntagStreamInput";
+const _USIp = "UpdateStreamInput";
+const _USO = "UntagStreamOutput";
+const _USOp = "UpdateStreamOutput";
+const _USSC = "UpdateStreamStorageConfiguration";
+const _USSCI = "UpdateStreamStorageConfigurationInput";
+const _USSCO = "UpdateStreamStorageConfigurationOutput";
+const _USn = "UntagStream";
+const _USp = "UpdateStream";
+const _V = "Version";
+const _VME = "VersionMismatchException";
+const _Va = "Value";
+const _WP = "WidthPixels";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.kinesisvideo";
+const n0 = "com.amazonaws.kinesisvideo";
+const _s_registry = TypeRegistry.for(_s);
+var KinesisVideoServiceException$ = [-3, _s, "KinesisVideoServiceException", 0, [], []];
+_s_registry.registerError(KinesisVideoServiceException$, KinesisVideoServiceException);
+const n0_registry = TypeRegistry.for(n0);
+var AccessDeniedException$ = [-3, n0, _ADE,
+    { [_e]: _c, [_hE]: 401 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(AccessDeniedException$, AccessDeniedException);
+var AccountChannelLimitExceededException$ = [-3, n0, _ACLEE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(AccountChannelLimitExceededException$, AccountChannelLimitExceededException);
+var AccountStreamLimitExceededException$ = [-3, n0, _ASLEE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(AccountStreamLimitExceededException$, AccountStreamLimitExceededException);
+var ClientLimitExceededException$ = [-3, n0, _CLEE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(ClientLimitExceededException$, ClientLimitExceededException);
+var DeviceStreamLimitExceededException$ = [-3, n0, _DSLEE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(DeviceStreamLimitExceededException$, DeviceStreamLimitExceededException);
+var InvalidArgumentException$ = [-3, n0, _IAE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(InvalidArgumentException$, InvalidArgumentException);
+var InvalidDeviceException$ = [-3, n0, _IDE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(InvalidDeviceException$, InvalidDeviceException);
+var InvalidResourceFormatException$ = [-3, n0, _IRFE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(InvalidResourceFormatException$, InvalidResourceFormatException);
+var NoDataRetentionException$ = [-3, n0, _NDRE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(NoDataRetentionException$, NoDataRetentionException);
+var NotAuthorizedException$ = [-3, n0, _NAE,
+    { [_e]: _c, [_hE]: 401 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(NotAuthorizedException$, NotAuthorizedException);
+var ResourceInUseException$ = [-3, n0, _RIUE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(ResourceInUseException$, ResourceInUseException);
+var ResourceNotFoundException$ = [-3, n0, _RNFE,
+    { [_e]: _c, [_hE]: 404 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(ResourceNotFoundException$, ResourceNotFoundException);
+var StreamEdgeConfigurationNotFoundException$ = [-3, n0, _SECNFE,
+    { [_e]: _c, [_hE]: 404 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(StreamEdgeConfigurationNotFoundException$, StreamEdgeConfigurationNotFoundException);
+var TagsPerResourceExceededLimitException$ = [-3, n0, _TPRELE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(TagsPerResourceExceededLimitException$, TagsPerResourceExceededLimitException);
+var VersionMismatchException$ = [-3, n0, _VME,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(VersionMismatchException$, VersionMismatchException);
+const errorTypeRegistries = [
+    _s_registry,
+    n0_registry,
+];
+var MediaUriSecretArn = [0, n0, _MUSA, 8, 0];
+var ChannelInfo$ = [3, n0, _CI,
+    0,
+    [_CN, _CARN, _CT, _CS, _CTr, _SMC, _V],
+    [0, 0, 0, 0, 4, () => SingleMasterConfiguration$, 0]
+];
+var ChannelNameCondition$ = [3, n0, _CNC,
+    0,
+    [_CO, _CV],
+    [0, 0]
+];
+var CreateSignalingChannelInput$ = [3, n0, _CSCI,
+    0,
+    [_CN, _CT, _SMC, _T],
+    [0, 0, () => SingleMasterConfiguration$, () => TagOnCreateList], 1
+];
+var CreateSignalingChannelOutput$ = [3, n0, _CSCO,
+    0,
+    [_CARN],
+    [0]
+];
+var CreateStreamInput$ = [3, n0, _CSI,
+    0,
+    [_SN, _DN, _MT, _KKI, _DRIH, _T, _SSC],
+    [0, 0, 0, 0, 1, 128 | 0, () => StreamStorageConfiguration$], 1
+];
+var CreateStreamOutput$ = [3, n0, _CSO,
+    0,
+    [_SARN],
+    [0]
+];
+var DeleteEdgeConfigurationInput$ = [3, n0, _DECI,
+    0,
+    [_SN, _SARN],
+    [0, 0]
+];
+var DeleteEdgeConfigurationOutput$ = [3, n0, _DECO,
+    0,
+    [],
+    []
+];
+var DeleteSignalingChannelInput$ = [3, n0, _DSCI,
+    0,
+    [_CARN, _CVu],
+    [0, 0], 1
+];
+var DeleteSignalingChannelOutput$ = [3, n0, _DSCO,
+    0,
+    [],
+    []
+];
+var DeleteStreamInput$ = [3, n0, _DSI,
+    0,
+    [_SARN, _CVu],
+    [0, 0], 1
+];
+var DeleteStreamOutput$ = [3, n0, _DSO,
+    0,
+    [],
+    []
+];
+var DeletionConfig$ = [3, n0, _DC,
+    0,
+    [_ERIH, _LSC, _DAU],
+    [1, () => LocalSizeConfig$, 2]
+];
+var DescribeEdgeConfigurationInput$ = [3, n0, _DECIe,
+    0,
+    [_SN, _SARN],
+    [0, 0]
+];
+var DescribeEdgeConfigurationOutput$ = [3, n0, _DECOe,
+    0,
+    [_SN, _SARN, _CTr, _LUT, _SS, _FSD, _EC, _EAS],
+    [0, 0, 4, 4, 0, 0, [() => EdgeConfig$, 0], () => EdgeAgentStatus$]
+];
+var DescribeImageGenerationConfigurationInput$ = [3, n0, _DIGCI,
+    0,
+    [_SN, _SARN],
+    [0, 0]
+];
+var DescribeImageGenerationConfigurationOutput$ = [3, n0, _DIGCO,
+    0,
+    [_IGC],
+    [() => ImageGenerationConfiguration$]
+];
+var DescribeMappedResourceConfigurationInput$ = [3, n0, _DMRCI,
+    0,
+    [_SN, _SARN, _MR, _NT],
+    [0, 0, 1, 0]
+];
+var DescribeMappedResourceConfigurationOutput$ = [3, n0, _DMRCO,
+    0,
+    [_MRCL, _NT],
+    [() => MappedResourceConfigurationList, 0]
+];
+var DescribeMediaStorageConfigurationInput$ = [3, n0, _DMSCI,
+    0,
+    [_CN, _CARN],
+    [0, 0]
+];
+var DescribeMediaStorageConfigurationOutput$ = [3, n0, _DMSCO,
+    0,
+    [_MSC],
+    [() => MediaStorageConfiguration$]
+];
+var DescribeNotificationConfigurationInput$ = [3, n0, _DNCI,
+    0,
+    [_SN, _SARN],
+    [0, 0]
+];
+var DescribeNotificationConfigurationOutput$ = [3, n0, _DNCO,
+    0,
+    [_NC],
+    [() => NotificationConfiguration$]
+];
+var DescribeSignalingChannelInput$ = [3, n0, _DSCIe,
+    0,
+    [_CN, _CARN],
+    [0, 0]
+];
+var DescribeSignalingChannelOutput$ = [3, n0, _DSCOe,
+    0,
+    [_CI],
+    [() => ChannelInfo$]
+];
+var DescribeStreamInput$ = [3, n0, _DSIe,
+    0,
+    [_SN, _SARN],
+    [0, 0]
+];
+var DescribeStreamOutput$ = [3, n0, _DSOe,
+    0,
+    [_SI],
+    [() => StreamInfo$]
+];
+var DescribeStreamStorageConfigurationInput$ = [3, n0, _DSSCI,
+    0,
+    [_SN, _SARN],
+    [0, 0]
+];
+var DescribeStreamStorageConfigurationOutput$ = [3, n0, _DSSCO,
+    0,
+    [_SN, _SARN, _SSC],
+    [0, 0, () => StreamStorageConfiguration$]
+];
+var EdgeAgentStatus$ = [3, n0, _EAS,
+    0,
+    [_LRS, _LUS],
+    [() => LastRecorderStatus$, () => LastUploaderStatus$]
+];
+var EdgeConfig$ = [3, n0, _EC,
+    0,
+    [_HDA, _RC, _UC, _DC],
+    [0, [() => RecorderConfig$, 0], () => UploaderConfig$, () => DeletionConfig$], 2
+];
+var GetDataEndpointInput$ = [3, n0, _GDEI,
+    0,
+    [_APIN, _SN, _SARN],
+    [0, 0, 0], 1
+];
+var GetDataEndpointOutput$ = [3, n0, _GDEO,
+    0,
+    [_DE],
+    [0]
+];
+var GetSignalingChannelEndpointInput$ = [3, n0, _GSCEI,
+    0,
+    [_CARN, _SMCEC],
+    [0, () => SingleMasterChannelEndpointConfiguration$], 1
+];
+var GetSignalingChannelEndpointOutput$ = [3, n0, _GSCEO,
+    0,
+    [_REL],
+    [() => ResourceEndpointList]
+];
+var ImageGenerationConfiguration$ = [3, n0, _IGC,
+    0,
+    [_S, _IST, _DCe, _SIa, _F, _FC, _WP, _HP],
+    [0, 0, () => ImageGenerationDestinationConfig$, 1, 0, 128 | 0, 1, 1], 5
+];
+var ImageGenerationDestinationConfig$ = [3, n0, _IGDC,
+    0,
+    [_U, _DR],
+    [0, 0], 2
+];
+var LastRecorderStatus$ = [3, n0, _LRS,
+    0,
+    [_JSD, _LCT, _LUT, _RS],
+    [0, 4, 4, 0]
+];
+var LastUploaderStatus$ = [3, n0, _LUS,
+    0,
+    [_JSD, _LCT, _LUT, _US],
+    [0, 4, 4, 0]
+];
+var ListEdgeAgentConfigurationsEdgeConfig$ = [3, n0, _LEACEC,
+    0,
+    [_SN, _SARN, _CTr, _LUT, _SS, _FSD, _EC],
+    [0, 0, 4, 4, 0, 0, [() => EdgeConfig$, 0]]
+];
+var ListEdgeAgentConfigurationsInput$ = [3, n0, _LEACI,
+    0,
+    [_HDA, _MR, _NT],
+    [0, 1, 0], 1
+];
+var ListEdgeAgentConfigurationsOutput$ = [3, n0, _LEACO,
+    0,
+    [_ECd, _NT],
+    [[() => ListEdgeAgentConfigurationsEdgeConfigList, 0], 0]
+];
+var ListSignalingChannelsInput$ = [3, n0, _LSCI,
+    0,
+    [_MR, _NT, _CNC],
+    [1, 0, () => ChannelNameCondition$]
+];
+var ListSignalingChannelsOutput$ = [3, n0, _LSCO,
+    0,
+    [_CIL, _NT],
+    [() => ChannelInfoList, 0]
+];
+var ListStreamsInput$ = [3, n0, _LSI,
+    0,
+    [_MR, _NT, _SNC],
+    [1, 0, () => StreamNameCondition$]
+];
+var ListStreamsOutput$ = [3, n0, _LSO,
+    0,
+    [_SIL, _NT],
+    [() => StreamInfoList, 0]
+];
+var ListTagsForResourceInput$ = [3, n0, _LTFRI,
+    0,
+    [_RARN, _NT],
+    [0, 0], 1
+];
+var ListTagsForResourceOutput$ = [3, n0, _LTFRO,
+    0,
+    [_NT, _T],
+    [0, 128 | 0]
+];
+var ListTagsForStreamInput$ = [3, n0, _LTFSI,
+    0,
+    [_NT, _SARN, _SN],
+    [0, 0, 0]
+];
+var ListTagsForStreamOutput$ = [3, n0, _LTFSO,
+    0,
+    [_NT, _T],
+    [0, 128 | 0]
+];
+var LocalSizeConfig$ = [3, n0, _LSC,
+    0,
+    [_MLMSIMB, _SOFS],
+    [1, 0]
+];
+var MappedResourceConfigurationListItem$ = [3, n0, _MRCLI,
+    0,
+    [_Ty, _ARN],
+    [0, 0]
+];
+var MediaSourceConfig$ = [3, n0, _MSCe,
+    0,
+    [_MUSA, _MUT],
+    [[() => MediaUriSecretArn, 0], 0], 2
+];
+var MediaStorageConfiguration$ = [3, n0, _MSC,
+    0,
+    [_S, _SARN],
+    [0, 0], 1
+];
+var NotificationConfiguration$ = [3, n0, _NC,
+    0,
+    [_S, _DCe],
+    [0, () => NotificationDestinationConfig$], 2
+];
+var NotificationDestinationConfig$ = [3, n0, _NDC,
+    0,
+    [_U],
+    [0], 1
+];
+var RecorderConfig$ = [3, n0, _RC,
+    0,
+    [_MSCe, _SC],
+    [[() => MediaSourceConfig$, 0], () => ScheduleConfig$], 1
+];
+var ResourceEndpointListItem$ = [3, n0, _RELI,
+    0,
+    [_P, _RE],
+    [0, 0]
+];
+var ScheduleConfig$ = [3, n0, _SC,
+    0,
+    [_SE, _DIS],
+    [0, 1], 2
+];
+var SingleMasterChannelEndpointConfiguration$ = [3, n0, _SMCEC,
+    0,
+    [_Pr, _R],
+    [64 | 0, 0]
+];
+var SingleMasterConfiguration$ = [3, n0, _SMC,
+    0,
+    [_MTS],
+    [1]
+];
+var StartEdgeConfigurationUpdateInput$ = [3, n0, _SECUI,
+    0,
+    [_EC, _SN, _SARN],
+    [[() => EdgeConfig$, 0], 0, 0], 1
+];
+var StartEdgeConfigurationUpdateOutput$ = [3, n0, _SECUO,
+    0,
+    [_SN, _SARN, _CTr, _LUT, _SS, _FSD, _EC],
+    [0, 0, 4, 4, 0, 0, [() => EdgeConfig$, 0]]
+];
+var StreamInfo$ = [3, n0, _SI,
+    0,
+    [_DN, _SN, _SARN, _MT, _KKI, _V, _S, _CTr, _DRIH],
+    [0, 0, 0, 0, 0, 0, 0, 4, 1]
+];
+var StreamNameCondition$ = [3, n0, _SNC,
+    0,
+    [_CO, _CV],
+    [0, 0]
+];
+var StreamStorageConfiguration$ = [3, n0, _SSC,
+    0,
+    [_DST],
+    [0], 1
+];
+var Tag$ = [3, n0, _Ta,
+    0,
+    [_K, _Va],
+    [0, 0], 2
+];
+var TagResourceInput$ = [3, n0, _TRI,
+    0,
+    [_RARN, _T],
+    [0, () => TagList], 2
+];
+var TagResourceOutput$ = [3, n0, _TRO,
+    0,
+    [],
+    []
+];
+var TagStreamInput$ = [3, n0, _TSI,
+    0,
+    [_T, _SARN, _SN],
+    [128 | 0, 0, 0], 1
+];
+var TagStreamOutput$ = [3, n0, _TSO,
+    0,
+    [],
+    []
+];
+var UntagResourceInput$ = [3, n0, _URI,
+    0,
+    [_RARN, _TKL],
+    [0, 64 | 0], 2
+];
+var UntagResourceOutput$ = [3, n0, _URO,
+    0,
+    [],
+    []
+];
+var UntagStreamInput$ = [3, n0, _USI,
+    0,
+    [_TKL, _SARN, _SN],
+    [64 | 0, 0, 0], 1
+];
+var UntagStreamOutput$ = [3, n0, _USO,
+    0,
+    [],
+    []
+];
+var UpdateDataRetentionInput$ = [3, n0, _UDRI,
+    0,
+    [_CVu, _O, _DRCIH, _SN, _SARN],
+    [0, 0, 1, 0, 0], 3
+];
+var UpdateDataRetentionOutput$ = [3, n0, _UDRO,
+    0,
+    [],
+    []
+];
+var UpdateImageGenerationConfigurationInput$ = [3, n0, _UIGCI,
+    0,
+    [_SN, _SARN, _IGC],
+    [0, 0, () => ImageGenerationConfiguration$]
+];
+var UpdateImageGenerationConfigurationOutput$ = [3, n0, _UIGCO,
+    0,
+    [],
+    []
+];
+var UpdateMediaStorageConfigurationInput$ = [3, n0, _UMSCI,
+    0,
+    [_CARN, _MSC],
+    [0, () => MediaStorageConfiguration$], 2
+];
+var UpdateMediaStorageConfigurationOutput$ = [3, n0, _UMSCO,
+    0,
+    [],
+    []
+];
+var UpdateNotificationConfigurationInput$ = [3, n0, _UNCI,
+    0,
+    [_SN, _SARN, _NC],
+    [0, 0, () => NotificationConfiguration$]
+];
+var UpdateNotificationConfigurationOutput$ = [3, n0, _UNCO,
+    0,
+    [],
+    []
+];
+var UpdateSignalingChannelInput$ = [3, n0, _USCI,
+    0,
+    [_CARN, _CVu, _SMC],
+    [0, 0, () => SingleMasterConfiguration$], 2
+];
+var UpdateSignalingChannelOutput$ = [3, n0, _USCO,
+    0,
+    [],
+    []
+];
+var UpdateStreamInput$ = [3, n0, _USIp,
+    0,
+    [_CVu, _SN, _SARN, _DN, _MT],
+    [0, 0, 0, 0, 0], 1
+];
+var UpdateStreamOutput$ = [3, n0, _USOp,
+    0,
+    [],
+    []
+];
+var UpdateStreamStorageConfigurationInput$ = [3, n0, _USSCI,
+    0,
+    [_CVu, _SSC, _SN, _SARN],
+    [0, () => StreamStorageConfiguration$, 0, 0], 2
+];
+var UpdateStreamStorageConfigurationOutput$ = [3, n0, _USSCO,
+    0,
+    [],
+    []
+];
+var UploaderConfig$ = [3, n0, _UC,
+    0,
+    [_SC],
+    [() => ScheduleConfig$], 1
+];
+var ChannelInfoList = [1, n0, _CIL,
+    0, () => ChannelInfo$
+];
+var ListEdgeAgentConfigurationsEdgeConfigList = [1, n0, _LEACECL,
+    0, [() => ListEdgeAgentConfigurationsEdgeConfig$,
+        0]
+];
+var MappedResourceConfigurationList = [1, n0, _MRCL,
+    0, () => MappedResourceConfigurationListItem$
+];
+var ResourceEndpointList = [1, n0, _REL,
+    0, () => ResourceEndpointListItem$
+];
+var StreamInfoList = [1, n0, _SIL,
+    0, () => StreamInfo$
+];
+var TagList = [1, n0, _TL,
+    0, () => Tag$
+];
+var TagOnCreateList = [1, n0, _TOCL,
+    0, () => Tag$
+];
+var CreateSignalingChannel$ = [9, n0, _CSC,
+    { [_h]: ["POST", "/createSignalingChannel", 200] }, () => CreateSignalingChannelInput$, () => CreateSignalingChannelOutput$
+];
+var CreateStream$ = [9, n0, _CSr,
+    { [_h]: ["POST", "/createStream", 200] }, () => CreateStreamInput$, () => CreateStreamOutput$
+];
+var DeleteEdgeConfiguration$ = [9, n0, _DEC,
+    { [_h]: ["POST", "/deleteEdgeConfiguration", 200] }, () => DeleteEdgeConfigurationInput$, () => DeleteEdgeConfigurationOutput$
+];
+var DeleteSignalingChannel$ = [9, n0, _DSC,
+    { [_h]: ["POST", "/deleteSignalingChannel", 200] }, () => DeleteSignalingChannelInput$, () => DeleteSignalingChannelOutput$
+];
+var DeleteStream$ = [9, n0, _DS,
+    { [_h]: ["POST", "/deleteStream", 200] }, () => DeleteStreamInput$, () => DeleteStreamOutput$
+];
+var DescribeEdgeConfiguration$ = [9, n0, _DECe,
+    { [_h]: ["POST", "/describeEdgeConfiguration", 200] }, () => DescribeEdgeConfigurationInput$, () => DescribeEdgeConfigurationOutput$
+];
+var DescribeImageGenerationConfiguration$ = [9, n0, _DIGC,
+    { [_h]: ["POST", "/describeImageGenerationConfiguration", 200] }, () => DescribeImageGenerationConfigurationInput$, () => DescribeImageGenerationConfigurationOutput$
+];
+var DescribeMappedResourceConfiguration$ = [9, n0, _DMRC,
+    { [_h]: ["POST", "/describeMappedResourceConfiguration", 200] }, () => DescribeMappedResourceConfigurationInput$, () => DescribeMappedResourceConfigurationOutput$
+];
+var DescribeMediaStorageConfiguration$ = [9, n0, _DMSC,
+    { [_h]: ["POST", "/describeMediaStorageConfiguration", 200] }, () => DescribeMediaStorageConfigurationInput$, () => DescribeMediaStorageConfigurationOutput$
+];
+var DescribeNotificationConfiguration$ = [9, n0, _DNC,
+    { [_h]: ["POST", "/describeNotificationConfiguration", 200] }, () => DescribeNotificationConfigurationInput$, () => DescribeNotificationConfigurationOutput$
+];
+var DescribeSignalingChannel$ = [9, n0, _DSCe,
+    { [_h]: ["POST", "/describeSignalingChannel", 200] }, () => DescribeSignalingChannelInput$, () => DescribeSignalingChannelOutput$
+];
+var DescribeStream$ = [9, n0, _DSe,
+    { [_h]: ["POST", "/describeStream", 200] }, () => DescribeStreamInput$, () => DescribeStreamOutput$
+];
+var DescribeStreamStorageConfiguration$ = [9, n0, _DSSC,
+    { [_h]: ["POST", "/describeStreamStorageConfiguration", 200] }, () => DescribeStreamStorageConfigurationInput$, () => DescribeStreamStorageConfigurationOutput$
+];
+var GetDataEndpoint$ = [9, n0, _GDE,
+    { [_h]: ["POST", "/getDataEndpoint", 200] }, () => GetDataEndpointInput$, () => GetDataEndpointOutput$
+];
+var GetSignalingChannelEndpoint$ = [9, n0, _GSCE,
+    { [_h]: ["POST", "/getSignalingChannelEndpoint", 200] }, () => GetSignalingChannelEndpointInput$, () => GetSignalingChannelEndpointOutput$
+];
+var ListEdgeAgentConfigurations$ = [9, n0, _LEAC,
+    { [_h]: ["POST", "/listEdgeAgentConfigurations", 200] }, () => ListEdgeAgentConfigurationsInput$, () => ListEdgeAgentConfigurationsOutput$
+];
+var ListSignalingChannels$ = [9, n0, _LSCi,
+    { [_h]: ["POST", "/listSignalingChannels", 200] }, () => ListSignalingChannelsInput$, () => ListSignalingChannelsOutput$
+];
+var ListStreams$ = [9, n0, _LS,
+    { [_h]: ["POST", "/listStreams", 200] }, () => ListStreamsInput$, () => ListStreamsOutput$
+];
+var ListTagsForResource$ = [9, n0, _LTFR,
+    { [_h]: ["POST", "/ListTagsForResource", 200] }, () => ListTagsForResourceInput$, () => ListTagsForResourceOutput$
+];
+var ListTagsForStream$ = [9, n0, _LTFS,
+    { [_h]: ["POST", "/listTagsForStream", 200] }, () => ListTagsForStreamInput$, () => ListTagsForStreamOutput$
+];
+var StartEdgeConfigurationUpdate$ = [9, n0, _SECU,
+    { [_h]: ["POST", "/startEdgeConfigurationUpdate", 200] }, () => StartEdgeConfigurationUpdateInput$, () => StartEdgeConfigurationUpdateOutput$
+];
+var TagResource$ = [9, n0, _TR,
+    { [_h]: ["POST", "/TagResource", 200] }, () => TagResourceInput$, () => TagResourceOutput$
+];
+var TagStream$ = [9, n0, _TS,
+    { [_h]: ["POST", "/tagStream", 200] }, () => TagStreamInput$, () => TagStreamOutput$
+];
+var UntagResource$ = [9, n0, _UR,
+    { [_h]: ["POST", "/UntagResource", 200] }, () => UntagResourceInput$, () => UntagResourceOutput$
+];
+var UntagStream$ = [9, n0, _USn,
+    { [_h]: ["POST", "/untagStream", 200] }, () => UntagStreamInput$, () => UntagStreamOutput$
+];
+var UpdateDataRetention$ = [9, n0, _UDR,
+    { [_h]: ["POST", "/updateDataRetention", 200] }, () => UpdateDataRetentionInput$, () => UpdateDataRetentionOutput$
+];
+var UpdateImageGenerationConfiguration$ = [9, n0, _UIGC,
+    { [_h]: ["POST", "/updateImageGenerationConfiguration", 200] }, () => UpdateImageGenerationConfigurationInput$, () => UpdateImageGenerationConfigurationOutput$
+];
+var UpdateMediaStorageConfiguration$ = [9, n0, _UMSC,
+    { [_h]: ["POST", "/updateMediaStorageConfiguration", 200] }, () => UpdateMediaStorageConfigurationInput$, () => UpdateMediaStorageConfigurationOutput$
+];
+var UpdateNotificationConfiguration$ = [9, n0, _UNC,
+    { [_h]: ["POST", "/updateNotificationConfiguration", 200] }, () => UpdateNotificationConfigurationInput$, () => UpdateNotificationConfigurationOutput$
+];
+var UpdateSignalingChannel$ = [9, n0, _USC,
+    { [_h]: ["POST", "/updateSignalingChannel", 200] }, () => UpdateSignalingChannelInput$, () => UpdateSignalingChannelOutput$
+];
+var UpdateStream$ = [9, n0, _USp,
+    { [_h]: ["POST", "/updateStream", 200] }, () => UpdateStreamInput$, () => UpdateStreamOutput$
+];
+var UpdateStreamStorageConfiguration$ = [9, n0, _USSC,
+    { [_h]: ["POST", "/updateStreamStorageConfiguration", 200] }, () => UpdateStreamStorageConfigurationInput$, () => UpdateStreamStorageConfigurationOutput$
+];
+
+const getRuntimeConfig$1 = (config) => {
+    return {
+        apiVersion: "2017-09-30",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultKinesisVideoHttpAuthSchemeProvider,
+        httpAuthSchemes: config?.httpAuthSchemes ?? [
+            {
+                schemeId: "aws.auth#sigv4",
+                identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
+                signer: new AwsSdkSigV4Signer(),
+            },
+        ],
+        logger: config?.logger ?? new NoOpLogger(),
+        protocol: config?.protocol ?? AwsRestJsonProtocol,
+        protocolSettings: config?.protocolSettings ?? {
+            defaultNamespace: "com.amazonaws.kinesisvideo",
+            errorTypeRegistries,
+            xmlNamespace: "https://kinesisvideo.amazonaws.com/doc/2017-09-30/",
+            version: "2017-09-30",
+            serviceTarget: "KinesisVideo_20170930",
+        },
+        serviceId: config?.serviceId ?? "Kinesis Video",
+        urlParser: config?.urlParser ?? parseUrl,
+        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? toUtf8,
+    };
+};
+
+const getRuntimeConfig = (config) => {
+    emitWarningIfUnsupportedVersion(process.version);
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getRuntimeConfig$1(config);
+    emitWarningIfUnsupportedVersion$1(process.version);
+    const loaderConfig = {
+        profile: config?.profile,
+        logger: clientSharedValues.logger,
+    };
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
+        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
+        retryMode: config?.retryMode ??
+            loadConfig({
+                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
+            }, config),
+        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig),
+    };
+};
+
 const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
     const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
     let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
@@ -635,57 +1898,212 @@ const UpdateDataRetentionOperation = {
 };
 
 exports.APIName = APIName;
+exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException$ = AccessDeniedException$;
+exports.AccountChannelLimitExceededException = AccountChannelLimitExceededException;
+exports.AccountChannelLimitExceededException$ = AccountChannelLimitExceededException$;
+exports.AccountStreamLimitExceededException = AccountStreamLimitExceededException;
+exports.AccountStreamLimitExceededException$ = AccountStreamLimitExceededException$;
+exports.ChannelInfo$ = ChannelInfo$;
+exports.ChannelNameCondition$ = ChannelNameCondition$;
 exports.ChannelProtocol = ChannelProtocol;
 exports.ChannelRole = ChannelRole;
 exports.ChannelType = ChannelType;
+exports.ClientLimitExceededException = ClientLimitExceededException;
+exports.ClientLimitExceededException$ = ClientLimitExceededException$;
 exports.ComparisonOperator = ComparisonOperator;
 exports.ConfigurationStatus = ConfigurationStatus;
+exports.CreateSignalingChannel$ = CreateSignalingChannel$;
 exports.CreateSignalingChannelCommand = CreateSignalingChannelCommand;
+exports.CreateSignalingChannelInput$ = CreateSignalingChannelInput$;
+exports.CreateSignalingChannelOutput$ = CreateSignalingChannelOutput$;
+exports.CreateStream$ = CreateStream$;
 exports.CreateStreamCommand = CreateStreamCommand;
+exports.CreateStreamInput$ = CreateStreamInput$;
+exports.CreateStreamOutput$ = CreateStreamOutput$;
 exports.DefaultStorageTier = DefaultStorageTier;
+exports.DeleteEdgeConfiguration$ = DeleteEdgeConfiguration$;
 exports.DeleteEdgeConfigurationCommand = DeleteEdgeConfigurationCommand;
+exports.DeleteEdgeConfigurationInput$ = DeleteEdgeConfigurationInput$;
+exports.DeleteEdgeConfigurationOutput$ = DeleteEdgeConfigurationOutput$;
+exports.DeleteSignalingChannel$ = DeleteSignalingChannel$;
 exports.DeleteSignalingChannelCommand = DeleteSignalingChannelCommand;
+exports.DeleteSignalingChannelInput$ = DeleteSignalingChannelInput$;
+exports.DeleteSignalingChannelOutput$ = DeleteSignalingChannelOutput$;
+exports.DeleteStream$ = DeleteStream$;
 exports.DeleteStreamCommand = DeleteStreamCommand;
+exports.DeleteStreamInput$ = DeleteStreamInput$;
+exports.DeleteStreamOutput$ = DeleteStreamOutput$;
+exports.DeletionConfig$ = DeletionConfig$;
+exports.DescribeEdgeConfiguration$ = DescribeEdgeConfiguration$;
 exports.DescribeEdgeConfigurationCommand = DescribeEdgeConfigurationCommand;
+exports.DescribeEdgeConfigurationInput$ = DescribeEdgeConfigurationInput$;
+exports.DescribeEdgeConfigurationOutput$ = DescribeEdgeConfigurationOutput$;
+exports.DescribeImageGenerationConfiguration$ = DescribeImageGenerationConfiguration$;
 exports.DescribeImageGenerationConfigurationCommand = DescribeImageGenerationConfigurationCommand;
+exports.DescribeImageGenerationConfigurationInput$ = DescribeImageGenerationConfigurationInput$;
+exports.DescribeImageGenerationConfigurationOutput$ = DescribeImageGenerationConfigurationOutput$;
+exports.DescribeMappedResourceConfiguration$ = DescribeMappedResourceConfiguration$;
 exports.DescribeMappedResourceConfigurationCommand = DescribeMappedResourceConfigurationCommand;
+exports.DescribeMappedResourceConfigurationInput$ = DescribeMappedResourceConfigurationInput$;
+exports.DescribeMappedResourceConfigurationOutput$ = DescribeMappedResourceConfigurationOutput$;
+exports.DescribeMediaStorageConfiguration$ = DescribeMediaStorageConfiguration$;
 exports.DescribeMediaStorageConfigurationCommand = DescribeMediaStorageConfigurationCommand;
+exports.DescribeMediaStorageConfigurationInput$ = DescribeMediaStorageConfigurationInput$;
+exports.DescribeMediaStorageConfigurationOutput$ = DescribeMediaStorageConfigurationOutput$;
+exports.DescribeNotificationConfiguration$ = DescribeNotificationConfiguration$;
 exports.DescribeNotificationConfigurationCommand = DescribeNotificationConfigurationCommand;
+exports.DescribeNotificationConfigurationInput$ = DescribeNotificationConfigurationInput$;
+exports.DescribeNotificationConfigurationOutput$ = DescribeNotificationConfigurationOutput$;
+exports.DescribeSignalingChannel$ = DescribeSignalingChannel$;
 exports.DescribeSignalingChannelCommand = DescribeSignalingChannelCommand;
+exports.DescribeSignalingChannelInput$ = DescribeSignalingChannelInput$;
+exports.DescribeSignalingChannelOutput$ = DescribeSignalingChannelOutput$;
+exports.DescribeStream$ = DescribeStream$;
 exports.DescribeStreamCommand = DescribeStreamCommand;
+exports.DescribeStreamInput$ = DescribeStreamInput$;
+exports.DescribeStreamOutput$ = DescribeStreamOutput$;
+exports.DescribeStreamStorageConfiguration$ = DescribeStreamStorageConfiguration$;
 exports.DescribeStreamStorageConfigurationCommand = DescribeStreamStorageConfigurationCommand;
+exports.DescribeStreamStorageConfigurationInput$ = DescribeStreamStorageConfigurationInput$;
+exports.DescribeStreamStorageConfigurationOutput$ = DescribeStreamStorageConfigurationOutput$;
+exports.DeviceStreamLimitExceededException = DeviceStreamLimitExceededException;
+exports.DeviceStreamLimitExceededException$ = DeviceStreamLimitExceededException$;
+exports.EdgeAgentStatus$ = EdgeAgentStatus$;
+exports.EdgeConfig$ = EdgeConfig$;
 exports.Format = Format;
 exports.FormatConfigKey = FormatConfigKey;
+exports.GetDataEndpoint$ = GetDataEndpoint$;
 exports.GetDataEndpointCommand = GetDataEndpointCommand;
+exports.GetDataEndpointInput$ = GetDataEndpointInput$;
+exports.GetDataEndpointOutput$ = GetDataEndpointOutput$;
+exports.GetSignalingChannelEndpoint$ = GetSignalingChannelEndpoint$;
 exports.GetSignalingChannelEndpointCommand = GetSignalingChannelEndpointCommand;
+exports.GetSignalingChannelEndpointInput$ = GetSignalingChannelEndpointInput$;
+exports.GetSignalingChannelEndpointOutput$ = GetSignalingChannelEndpointOutput$;
+exports.ImageGenerationConfiguration$ = ImageGenerationConfiguration$;
+exports.ImageGenerationDestinationConfig$ = ImageGenerationDestinationConfig$;
 exports.ImageSelectorType = ImageSelectorType;
+exports.InvalidArgumentException = InvalidArgumentException;
+exports.InvalidArgumentException$ = InvalidArgumentException$;
+exports.InvalidDeviceException = InvalidDeviceException;
+exports.InvalidDeviceException$ = InvalidDeviceException$;
+exports.InvalidResourceFormatException = InvalidResourceFormatException;
+exports.InvalidResourceFormatException$ = InvalidResourceFormatException$;
 exports.KinesisVideo = KinesisVideo;
 exports.KinesisVideoClient = KinesisVideoClient;
+exports.KinesisVideoServiceException = KinesisVideoServiceException;
+exports.KinesisVideoServiceException$ = KinesisVideoServiceException$;
+exports.LastRecorderStatus$ = LastRecorderStatus$;
+exports.LastUploaderStatus$ = LastUploaderStatus$;
+exports.ListEdgeAgentConfigurations$ = ListEdgeAgentConfigurations$;
 exports.ListEdgeAgentConfigurationsCommand = ListEdgeAgentConfigurationsCommand;
+exports.ListEdgeAgentConfigurationsEdgeConfig$ = ListEdgeAgentConfigurationsEdgeConfig$;
+exports.ListEdgeAgentConfigurationsInput$ = ListEdgeAgentConfigurationsInput$;
+exports.ListEdgeAgentConfigurationsOutput$ = ListEdgeAgentConfigurationsOutput$;
+exports.ListSignalingChannels$ = ListSignalingChannels$;
 exports.ListSignalingChannelsCommand = ListSignalingChannelsCommand;
+exports.ListSignalingChannelsInput$ = ListSignalingChannelsInput$;
+exports.ListSignalingChannelsOutput$ = ListSignalingChannelsOutput$;
+exports.ListStreams$ = ListStreams$;
 exports.ListStreamsCommand = ListStreamsCommand;
+exports.ListStreamsInput$ = ListStreamsInput$;
+exports.ListStreamsOutput$ = ListStreamsOutput$;
+exports.ListTagsForResource$ = ListTagsForResource$;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
+exports.ListTagsForResourceInput$ = ListTagsForResourceInput$;
+exports.ListTagsForResourceOutput$ = ListTagsForResourceOutput$;
+exports.ListTagsForStream$ = ListTagsForStream$;
 exports.ListTagsForStreamCommand = ListTagsForStreamCommand;
+exports.ListTagsForStreamInput$ = ListTagsForStreamInput$;
+exports.ListTagsForStreamOutput$ = ListTagsForStreamOutput$;
+exports.LocalSizeConfig$ = LocalSizeConfig$;
+exports.MappedResourceConfigurationListItem$ = MappedResourceConfigurationListItem$;
+exports.MediaSourceConfig$ = MediaSourceConfig$;
+exports.MediaStorageConfiguration$ = MediaStorageConfiguration$;
 exports.MediaStorageConfigurationStatus = MediaStorageConfigurationStatus;
 exports.MediaUriType = MediaUriType;
+exports.NoDataRetentionException = NoDataRetentionException;
+exports.NoDataRetentionException$ = NoDataRetentionException$;
+exports.NotAuthorizedException = NotAuthorizedException;
+exports.NotAuthorizedException$ = NotAuthorizedException$;
+exports.NotificationConfiguration$ = NotificationConfiguration$;
+exports.NotificationDestinationConfig$ = NotificationDestinationConfig$;
+exports.RecorderConfig$ = RecorderConfig$;
 exports.RecorderStatus = RecorderStatus;
+exports.ResourceEndpointListItem$ = ResourceEndpointListItem$;
+exports.ResourceInUseException = ResourceInUseException;
+exports.ResourceInUseException$ = ResourceInUseException$;
+exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException$ = ResourceNotFoundException$;
+exports.ScheduleConfig$ = ScheduleConfig$;
+exports.SingleMasterChannelEndpointConfiguration$ = SingleMasterChannelEndpointConfiguration$;
+exports.SingleMasterConfiguration$ = SingleMasterConfiguration$;
+exports.StartEdgeConfigurationUpdate$ = StartEdgeConfigurationUpdate$;
 exports.StartEdgeConfigurationUpdateCommand = StartEdgeConfigurationUpdateCommand;
+exports.StartEdgeConfigurationUpdateInput$ = StartEdgeConfigurationUpdateInput$;
+exports.StartEdgeConfigurationUpdateOutput$ = StartEdgeConfigurationUpdateOutput$;
 exports.Status = Status;
 exports.StrategyOnFullSize = StrategyOnFullSize;
+exports.StreamEdgeConfigurationNotFoundException = StreamEdgeConfigurationNotFoundException;
+exports.StreamEdgeConfigurationNotFoundException$ = StreamEdgeConfigurationNotFoundException$;
+exports.StreamInfo$ = StreamInfo$;
+exports.StreamNameCondition$ = StreamNameCondition$;
+exports.StreamStorageConfiguration$ = StreamStorageConfiguration$;
 exports.SyncStatus = SyncStatus;
+exports.Tag$ = Tag$;
+exports.TagResource$ = TagResource$;
 exports.TagResourceCommand = TagResourceCommand;
+exports.TagResourceInput$ = TagResourceInput$;
+exports.TagResourceOutput$ = TagResourceOutput$;
+exports.TagStream$ = TagStream$;
 exports.TagStreamCommand = TagStreamCommand;
+exports.TagStreamInput$ = TagStreamInput$;
+exports.TagStreamOutput$ = TagStreamOutput$;
+exports.TagsPerResourceExceededLimitException = TagsPerResourceExceededLimitException;
+exports.TagsPerResourceExceededLimitException$ = TagsPerResourceExceededLimitException$;
+exports.UntagResource$ = UntagResource$;
 exports.UntagResourceCommand = UntagResourceCommand;
+exports.UntagResourceInput$ = UntagResourceInput$;
+exports.UntagResourceOutput$ = UntagResourceOutput$;
+exports.UntagStream$ = UntagStream$;
 exports.UntagStreamCommand = UntagStreamCommand;
+exports.UntagStreamInput$ = UntagStreamInput$;
+exports.UntagStreamOutput$ = UntagStreamOutput$;
+exports.UpdateDataRetention$ = UpdateDataRetention$;
 exports.UpdateDataRetentionCommand = UpdateDataRetentionCommand;
+exports.UpdateDataRetentionInput$ = UpdateDataRetentionInput$;
 exports.UpdateDataRetentionOperation = UpdateDataRetentionOperation;
+exports.UpdateDataRetentionOutput$ = UpdateDataRetentionOutput$;
+exports.UpdateImageGenerationConfiguration$ = UpdateImageGenerationConfiguration$;
 exports.UpdateImageGenerationConfigurationCommand = UpdateImageGenerationConfigurationCommand;
+exports.UpdateImageGenerationConfigurationInput$ = UpdateImageGenerationConfigurationInput$;
+exports.UpdateImageGenerationConfigurationOutput$ = UpdateImageGenerationConfigurationOutput$;
+exports.UpdateMediaStorageConfiguration$ = UpdateMediaStorageConfiguration$;
 exports.UpdateMediaStorageConfigurationCommand = UpdateMediaStorageConfigurationCommand;
+exports.UpdateMediaStorageConfigurationInput$ = UpdateMediaStorageConfigurationInput$;
+exports.UpdateMediaStorageConfigurationOutput$ = UpdateMediaStorageConfigurationOutput$;
+exports.UpdateNotificationConfiguration$ = UpdateNotificationConfiguration$;
 exports.UpdateNotificationConfigurationCommand = UpdateNotificationConfigurationCommand;
+exports.UpdateNotificationConfigurationInput$ = UpdateNotificationConfigurationInput$;
+exports.UpdateNotificationConfigurationOutput$ = UpdateNotificationConfigurationOutput$;
+exports.UpdateSignalingChannel$ = UpdateSignalingChannel$;
 exports.UpdateSignalingChannelCommand = UpdateSignalingChannelCommand;
+exports.UpdateSignalingChannelInput$ = UpdateSignalingChannelInput$;
+exports.UpdateSignalingChannelOutput$ = UpdateSignalingChannelOutput$;
+exports.UpdateStream$ = UpdateStream$;
 exports.UpdateStreamCommand = UpdateStreamCommand;
+exports.UpdateStreamInput$ = UpdateStreamInput$;
+exports.UpdateStreamOutput$ = UpdateStreamOutput$;
+exports.UpdateStreamStorageConfiguration$ = UpdateStreamStorageConfiguration$;
 exports.UpdateStreamStorageConfigurationCommand = UpdateStreamStorageConfigurationCommand;
+exports.UpdateStreamStorageConfigurationInput$ = UpdateStreamStorageConfigurationInput$;
+exports.UpdateStreamStorageConfigurationOutput$ = UpdateStreamStorageConfigurationOutput$;
+exports.UploaderConfig$ = UploaderConfig$;
 exports.UploaderStatus = UploaderStatus;
+exports.VersionMismatchException = VersionMismatchException;
+exports.VersionMismatchException$ = VersionMismatchException$;
+exports.errorTypeRegistries = errorTypeRegistries;
 exports.paginateDescribeMappedResourceConfiguration = paginateDescribeMappedResourceConfiguration;
 exports.paginateListEdgeAgentConfigurations = paginateListEdgeAgentConfigurations;
 exports.paginateListSignalingChannels = paginateListSignalingChannels;