cdk-amazon-chime-resources
Version:
1,328 lines (1,306 loc) • 106 kB
JavaScript
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var src_exports = {};
__export(src_exports, {
APIName: () => APIName,
AccessDeniedException: () => AccessDeniedException,
AccountChannelLimitExceededException: () => AccountChannelLimitExceededException,
AccountStreamLimitExceededException: () => AccountStreamLimitExceededException,
ChannelProtocol: () => ChannelProtocol,
ChannelRole: () => ChannelRole,
ChannelType: () => ChannelType,
ClientLimitExceededException: () => ClientLimitExceededException,
ComparisonOperator: () => ComparisonOperator,
ConfigurationStatus: () => ConfigurationStatus,
CreateSignalingChannelCommand: () => CreateSignalingChannelCommand,
CreateStreamCommand: () => CreateStreamCommand,
DeleteEdgeConfigurationCommand: () => DeleteEdgeConfigurationCommand,
DeleteSignalingChannelCommand: () => DeleteSignalingChannelCommand,
DeleteStreamCommand: () => DeleteStreamCommand,
DescribeEdgeConfigurationCommand: () => DescribeEdgeConfigurationCommand,
DescribeEdgeConfigurationOutputFilterSensitiveLog: () => DescribeEdgeConfigurationOutputFilterSensitiveLog,
DescribeImageGenerationConfigurationCommand: () => DescribeImageGenerationConfigurationCommand,
DescribeMappedResourceConfigurationCommand: () => DescribeMappedResourceConfigurationCommand,
DescribeMediaStorageConfigurationCommand: () => DescribeMediaStorageConfigurationCommand,
DescribeNotificationConfigurationCommand: () => DescribeNotificationConfigurationCommand,
DescribeSignalingChannelCommand: () => DescribeSignalingChannelCommand,
DescribeStreamCommand: () => DescribeStreamCommand,
DeviceStreamLimitExceededException: () => DeviceStreamLimitExceededException,
EdgeConfigFilterSensitiveLog: () => EdgeConfigFilterSensitiveLog,
Format: () => Format,
FormatConfigKey: () => FormatConfigKey,
GetDataEndpointCommand: () => GetDataEndpointCommand,
GetSignalingChannelEndpointCommand: () => GetSignalingChannelEndpointCommand,
ImageSelectorType: () => ImageSelectorType,
InvalidArgumentException: () => InvalidArgumentException,
InvalidDeviceException: () => InvalidDeviceException,
InvalidResourceFormatException: () => InvalidResourceFormatException,
KinesisVideo: () => KinesisVideo,
KinesisVideoClient: () => KinesisVideoClient,
KinesisVideoServiceException: () => KinesisVideoServiceException,
ListEdgeAgentConfigurationsCommand: () => ListEdgeAgentConfigurationsCommand,
ListEdgeAgentConfigurationsEdgeConfigFilterSensitiveLog: () => ListEdgeAgentConfigurationsEdgeConfigFilterSensitiveLog,
ListEdgeAgentConfigurationsOutputFilterSensitiveLog: () => ListEdgeAgentConfigurationsOutputFilterSensitiveLog,
ListSignalingChannelsCommand: () => ListSignalingChannelsCommand,
ListStreamsCommand: () => ListStreamsCommand,
ListTagsForResourceCommand: () => ListTagsForResourceCommand,
ListTagsForStreamCommand: () => ListTagsForStreamCommand,
MediaSourceConfigFilterSensitiveLog: () => MediaSourceConfigFilterSensitiveLog,
MediaStorageConfigurationStatus: () => MediaStorageConfigurationStatus,
MediaUriType: () => MediaUriType,
NoDataRetentionException: () => NoDataRetentionException,
NotAuthorizedException: () => NotAuthorizedException,
RecorderConfigFilterSensitiveLog: () => RecorderConfigFilterSensitiveLog,
RecorderStatus: () => RecorderStatus,
ResourceInUseException: () => ResourceInUseException,
ResourceNotFoundException: () => ResourceNotFoundException,
StartEdgeConfigurationUpdateCommand: () => StartEdgeConfigurationUpdateCommand,
StartEdgeConfigurationUpdateInputFilterSensitiveLog: () => StartEdgeConfigurationUpdateInputFilterSensitiveLog,
StartEdgeConfigurationUpdateOutputFilterSensitiveLog: () => StartEdgeConfigurationUpdateOutputFilterSensitiveLog,
Status: () => Status,
StrategyOnFullSize: () => StrategyOnFullSize,
StreamEdgeConfigurationNotFoundException: () => StreamEdgeConfigurationNotFoundException,
SyncStatus: () => SyncStatus,
TagResourceCommand: () => TagResourceCommand,
TagStreamCommand: () => TagStreamCommand,
TagsPerResourceExceededLimitException: () => TagsPerResourceExceededLimitException,
UntagResourceCommand: () => UntagResourceCommand,
UntagStreamCommand: () => UntagStreamCommand,
UpdateDataRetentionCommand: () => UpdateDataRetentionCommand,
UpdateDataRetentionOperation: () => UpdateDataRetentionOperation,
UpdateImageGenerationConfigurationCommand: () => UpdateImageGenerationConfigurationCommand,
UpdateMediaStorageConfigurationCommand: () => UpdateMediaStorageConfigurationCommand,
UpdateNotificationConfigurationCommand: () => UpdateNotificationConfigurationCommand,
UpdateSignalingChannelCommand: () => UpdateSignalingChannelCommand,
UpdateStreamCommand: () => UpdateStreamCommand,
UploaderStatus: () => UploaderStatus,
VersionMismatchException: () => VersionMismatchException,
__Client: () => import_smithy_client.Client,
paginateDescribeMappedResourceConfiguration: () => paginateDescribeMappedResourceConfiguration,
paginateListEdgeAgentConfigurations: () => paginateListEdgeAgentConfigurations,
paginateListSignalingChannels: () => paginateListSignalingChannels,
paginateListStreams: () => paginateListStreams
});
module.exports = __toCommonJS(src_exports);
// src/KinesisVideoClient.ts
var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
var import_middleware_logger = require("@aws-sdk/middleware-logger");
var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
var import_config_resolver = require("@smithy/config-resolver");
var import_core = require("@smithy/core");
var import_middleware_content_length = require("@smithy/middleware-content-length");
var import_middleware_endpoint = require("@smithy/middleware-endpoint");
var import_middleware_retry = require("@smithy/middleware-retry");
var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
// src/endpoint/EndpointParameters.ts
var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
return {
...options,
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "kinesisvideo"
};
}, "resolveClientEndpointParameters");
var commonParams = {
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
// src/KinesisVideoClient.ts
var import_runtimeConfig = require("././runtimeConfig");
// src/runtimeExtensions.ts
var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
var import_protocol_http = require("@smithy/protocol-http");
var import_smithy_client = require("@smithy/smithy-client");
// src/auth/httpAuthExtensionConfiguration.ts
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((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;
}
};
}, "getHttpAuthExtensionConfiguration");
var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
}, "resolveHttpAuthRuntimeConfig");
// src/runtimeExtensions.ts
var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
const extensionConfiguration = {
...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig)),
...asPartial(getHttpAuthExtensionConfiguration(runtimeConfig))
};
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return {
...runtimeConfig,
...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
...resolveHttpAuthRuntimeConfig(extensionConfiguration)
};
}, "resolveRuntimeExtensions");
// src/KinesisVideoClient.ts
var _KinesisVideoClient = class _KinesisVideoClient extends import_smithy_client.Client {
constructor(...[configuration]) {
const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
const _config_1 = resolveClientEndpointParameters(_config_0);
const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
super(_config_8);
this.config = _config_8;
this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
this.middlewareStack.use(
(0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultKinesisVideoHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new import_core.DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
})
);
this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
}
/**
* Destroy underlying resources, like sockets. It's usually not necessary to do this.
* However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
* Otherwise, sockets might stay open for quite a long time before the server terminates them.
*/
destroy() {
super.destroy();
}
};
__name(_KinesisVideoClient, "KinesisVideoClient");
var KinesisVideoClient = _KinesisVideoClient;
// src/KinesisVideo.ts
// src/commands/CreateSignalingChannelCommand.ts
var import_middleware_serde = require("@smithy/middleware-serde");
// src/protocols/Aws_restJson1.ts
var import_core2 = require("@aws-sdk/core");
// src/models/KinesisVideoServiceException.ts
var _KinesisVideoServiceException = class _KinesisVideoServiceException extends import_smithy_client.ServiceException {
/**
* @internal
*/
constructor(options) {
super(options);
Object.setPrototypeOf(this, _KinesisVideoServiceException.prototype);
}
};
__name(_KinesisVideoServiceException, "KinesisVideoServiceException");
var KinesisVideoServiceException = _KinesisVideoServiceException;
// src/models/models_0.ts
var _AccessDeniedException = class _AccessDeniedException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "AccessDeniedException",
$fault: "client",
...opts
});
this.name = "AccessDeniedException";
this.$fault = "client";
Object.setPrototypeOf(this, _AccessDeniedException.prototype);
this.Message = opts.Message;
}
};
__name(_AccessDeniedException, "AccessDeniedException");
var AccessDeniedException = _AccessDeniedException;
var _AccountChannelLimitExceededException = class _AccountChannelLimitExceededException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "AccountChannelLimitExceededException",
$fault: "client",
...opts
});
this.name = "AccountChannelLimitExceededException";
this.$fault = "client";
Object.setPrototypeOf(this, _AccountChannelLimitExceededException.prototype);
this.Message = opts.Message;
}
};
__name(_AccountChannelLimitExceededException, "AccountChannelLimitExceededException");
var AccountChannelLimitExceededException = _AccountChannelLimitExceededException;
var _AccountStreamLimitExceededException = class _AccountStreamLimitExceededException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "AccountStreamLimitExceededException",
$fault: "client",
...opts
});
this.name = "AccountStreamLimitExceededException";
this.$fault = "client";
Object.setPrototypeOf(this, _AccountStreamLimitExceededException.prototype);
this.Message = opts.Message;
}
};
__name(_AccountStreamLimitExceededException, "AccountStreamLimitExceededException");
var AccountStreamLimitExceededException = _AccountStreamLimitExceededException;
var APIName = {
GET_CLIP: "GET_CLIP",
GET_DASH_STREAMING_SESSION_URL: "GET_DASH_STREAMING_SESSION_URL",
GET_HLS_STREAMING_SESSION_URL: "GET_HLS_STREAMING_SESSION_URL",
GET_IMAGES: "GET_IMAGES",
GET_MEDIA: "GET_MEDIA",
GET_MEDIA_FOR_FRAGMENT_LIST: "GET_MEDIA_FOR_FRAGMENT_LIST",
LIST_FRAGMENTS: "LIST_FRAGMENTS",
PUT_MEDIA: "PUT_MEDIA"
};
var Status = {
ACTIVE: "ACTIVE",
CREATING: "CREATING",
DELETING: "DELETING",
UPDATING: "UPDATING"
};
var ChannelType = {
FULL_MESH: "FULL_MESH",
SINGLE_MASTER: "SINGLE_MASTER"
};
var ComparisonOperator = {
BEGINS_WITH: "BEGINS_WITH"
};
var ChannelProtocol = {
HTTPS: "HTTPS",
WEBRTC: "WEBRTC",
WSS: "WSS"
};
var ChannelRole = {
MASTER: "MASTER",
VIEWER: "VIEWER"
};
var _ClientLimitExceededException = class _ClientLimitExceededException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "ClientLimitExceededException",
$fault: "client",
...opts
});
this.name = "ClientLimitExceededException";
this.$fault = "client";
Object.setPrototypeOf(this, _ClientLimitExceededException.prototype);
this.Message = opts.Message;
}
};
__name(_ClientLimitExceededException, "ClientLimitExceededException");
var ClientLimitExceededException = _ClientLimitExceededException;
var ConfigurationStatus = {
DISABLED: "DISABLED",
ENABLED: "ENABLED"
};
var _InvalidArgumentException = class _InvalidArgumentException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "InvalidArgumentException",
$fault: "client",
...opts
});
this.name = "InvalidArgumentException";
this.$fault = "client";
Object.setPrototypeOf(this, _InvalidArgumentException.prototype);
this.Message = opts.Message;
}
};
__name(_InvalidArgumentException, "InvalidArgumentException");
var InvalidArgumentException = _InvalidArgumentException;
var _ResourceInUseException = class _ResourceInUseException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "ResourceInUseException",
$fault: "client",
...opts
});
this.name = "ResourceInUseException";
this.$fault = "client";
Object.setPrototypeOf(this, _ResourceInUseException.prototype);
this.Message = opts.Message;
}
};
__name(_ResourceInUseException, "ResourceInUseException");
var ResourceInUseException = _ResourceInUseException;
var _TagsPerResourceExceededLimitException = class _TagsPerResourceExceededLimitException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "TagsPerResourceExceededLimitException",
$fault: "client",
...opts
});
this.name = "TagsPerResourceExceededLimitException";
this.$fault = "client";
Object.setPrototypeOf(this, _TagsPerResourceExceededLimitException.prototype);
this.Message = opts.Message;
}
};
__name(_TagsPerResourceExceededLimitException, "TagsPerResourceExceededLimitException");
var TagsPerResourceExceededLimitException = _TagsPerResourceExceededLimitException;
var _DeviceStreamLimitExceededException = class _DeviceStreamLimitExceededException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "DeviceStreamLimitExceededException",
$fault: "client",
...opts
});
this.name = "DeviceStreamLimitExceededException";
this.$fault = "client";
Object.setPrototypeOf(this, _DeviceStreamLimitExceededException.prototype);
this.Message = opts.Message;
}
};
__name(_DeviceStreamLimitExceededException, "DeviceStreamLimitExceededException");
var DeviceStreamLimitExceededException = _DeviceStreamLimitExceededException;
var _InvalidDeviceException = class _InvalidDeviceException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "InvalidDeviceException",
$fault: "client",
...opts
});
this.name = "InvalidDeviceException";
this.$fault = "client";
Object.setPrototypeOf(this, _InvalidDeviceException.prototype);
this.Message = opts.Message;
}
};
__name(_InvalidDeviceException, "InvalidDeviceException");
var InvalidDeviceException = _InvalidDeviceException;
var _ResourceNotFoundException = class _ResourceNotFoundException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "ResourceNotFoundException",
$fault: "client",
...opts
});
this.name = "ResourceNotFoundException";
this.$fault = "client";
Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
this.Message = opts.Message;
}
};
__name(_ResourceNotFoundException, "ResourceNotFoundException");
var ResourceNotFoundException = _ResourceNotFoundException;
var _StreamEdgeConfigurationNotFoundException = class _StreamEdgeConfigurationNotFoundException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "StreamEdgeConfigurationNotFoundException",
$fault: "client",
...opts
});
this.name = "StreamEdgeConfigurationNotFoundException";
this.$fault = "client";
Object.setPrototypeOf(this, _StreamEdgeConfigurationNotFoundException.prototype);
this.Message = opts.Message;
}
};
__name(_StreamEdgeConfigurationNotFoundException, "StreamEdgeConfigurationNotFoundException");
var StreamEdgeConfigurationNotFoundException = _StreamEdgeConfigurationNotFoundException;
var _VersionMismatchException = class _VersionMismatchException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "VersionMismatchException",
$fault: "client",
...opts
});
this.name = "VersionMismatchException";
this.$fault = "client";
Object.setPrototypeOf(this, _VersionMismatchException.prototype);
this.Message = opts.Message;
}
};
__name(_VersionMismatchException, "VersionMismatchException");
var VersionMismatchException = _VersionMismatchException;
var _NotAuthorizedException = class _NotAuthorizedException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "NotAuthorizedException",
$fault: "client",
...opts
});
this.name = "NotAuthorizedException";
this.$fault = "client";
Object.setPrototypeOf(this, _NotAuthorizedException.prototype);
this.Message = opts.Message;
}
};
__name(_NotAuthorizedException, "NotAuthorizedException");
var NotAuthorizedException = _NotAuthorizedException;
var StrategyOnFullSize = {
DELETE_OLDEST_MEDIA: "DELETE_OLDEST_MEDIA",
DENY_NEW_MEDIA: "DENY_NEW_MEDIA"
};
var RecorderStatus = {
SUCCESS: "SUCCESS",
SYSTEM_ERROR: "SYSTEM_ERROR",
USER_ERROR: "USER_ERROR"
};
var UploaderStatus = {
SUCCESS: "SUCCESS",
SYSTEM_ERROR: "SYSTEM_ERROR",
USER_ERROR: "USER_ERROR"
};
var MediaUriType = {
FILE_URI: "FILE_URI",
RTSP_URI: "RTSP_URI"
};
var SyncStatus = {
ACKNOWLEDGED: "ACKNOWLEDGED",
DELETE_FAILED: "DELETE_FAILED",
DELETING: "DELETING",
DELETING_ACKNOWLEDGED: "DELETING_ACKNOWLEDGED",
IN_SYNC: "IN_SYNC",
SYNCING: "SYNCING",
SYNC_FAILED: "SYNC_FAILED"
};
var Format = {
JPEG: "JPEG",
PNG: "PNG"
};
var FormatConfigKey = {
JPEGQuality: "JPEGQuality"
};
var ImageSelectorType = {
PRODUCER_TIMESTAMP: "PRODUCER_TIMESTAMP",
SERVER_TIMESTAMP: "SERVER_TIMESTAMP"
};
var MediaStorageConfigurationStatus = {
DISABLED: "DISABLED",
ENABLED: "ENABLED"
};
var _InvalidResourceFormatException = class _InvalidResourceFormatException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "InvalidResourceFormatException",
$fault: "client",
...opts
});
this.name = "InvalidResourceFormatException";
this.$fault = "client";
Object.setPrototypeOf(this, _InvalidResourceFormatException.prototype);
this.Message = opts.Message;
}
};
__name(_InvalidResourceFormatException, "InvalidResourceFormatException");
var InvalidResourceFormatException = _InvalidResourceFormatException;
var _NoDataRetentionException = class _NoDataRetentionException extends KinesisVideoServiceException {
/**
* @internal
*/
constructor(opts) {
super({
name: "NoDataRetentionException",
$fault: "client",
...opts
});
this.name = "NoDataRetentionException";
this.$fault = "client";
Object.setPrototypeOf(this, _NoDataRetentionException.prototype);
this.Message = opts.Message;
}
};
__name(_NoDataRetentionException, "NoDataRetentionException");
var NoDataRetentionException = _NoDataRetentionException;
var UpdateDataRetentionOperation = {
DECREASE_DATA_RETENTION: "DECREASE_DATA_RETENTION",
INCREASE_DATA_RETENTION: "INCREASE_DATA_RETENTION"
};
var MediaSourceConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
...obj,
...obj.MediaUriSecretArn && { MediaUriSecretArn: import_smithy_client.SENSITIVE_STRING }
}), "MediaSourceConfigFilterSensitiveLog");
var RecorderConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
...obj,
...obj.MediaSourceConfig && { MediaSourceConfig: MediaSourceConfigFilterSensitiveLog(obj.MediaSourceConfig) }
}), "RecorderConfigFilterSensitiveLog");
var EdgeConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
...obj,
...obj.RecorderConfig && { RecorderConfig: RecorderConfigFilterSensitiveLog(obj.RecorderConfig) }
}), "EdgeConfigFilterSensitiveLog");
var DescribeEdgeConfigurationOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
...obj,
...obj.EdgeConfig && { EdgeConfig: EdgeConfigFilterSensitiveLog(obj.EdgeConfig) }
}), "DescribeEdgeConfigurationOutputFilterSensitiveLog");
var ListEdgeAgentConfigurationsEdgeConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
...obj,
...obj.EdgeConfig && { EdgeConfig: EdgeConfigFilterSensitiveLog(obj.EdgeConfig) }
}), "ListEdgeAgentConfigurationsEdgeConfigFilterSensitiveLog");
var ListEdgeAgentConfigurationsOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
...obj,
...obj.EdgeConfigs && {
EdgeConfigs: obj.EdgeConfigs.map((item) => ListEdgeAgentConfigurationsEdgeConfigFilterSensitiveLog(item))
}
}), "ListEdgeAgentConfigurationsOutputFilterSensitiveLog");
var StartEdgeConfigurationUpdateInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
...obj,
...obj.EdgeConfig && { EdgeConfig: EdgeConfigFilterSensitiveLog(obj.EdgeConfig) }
}), "StartEdgeConfigurationUpdateInputFilterSensitiveLog");
var StartEdgeConfigurationUpdateOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
...obj,
...obj.EdgeConfig && { EdgeConfig: EdgeConfigFilterSensitiveLog(obj.EdgeConfig) }
}), "StartEdgeConfigurationUpdateOutputFilterSensitiveLog");
// src/protocols/Aws_restJson1.ts
var se_CreateSignalingChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/createSignalingChannel");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
ChannelName: [],
ChannelType: [],
SingleMasterConfiguration: (_) => (0, import_smithy_client._json)(_),
Tags: (_) => (0, import_smithy_client._json)(_)
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_CreateSignalingChannelCommand");
var se_CreateStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/createStream");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
DataRetentionInHours: [],
DeviceName: [],
KmsKeyId: [],
MediaType: [],
StreamName: [],
Tags: (_) => (0, import_smithy_client._json)(_)
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_CreateStreamCommand");
var se_DeleteEdgeConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/deleteEdgeConfiguration");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_DeleteEdgeConfigurationCommand");
var se_DeleteSignalingChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/deleteSignalingChannel");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
ChannelARN: [],
CurrentVersion: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_DeleteSignalingChannelCommand");
var se_DeleteStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/deleteStream");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
CurrentVersion: [],
StreamARN: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_DeleteStreamCommand");
var se_DescribeEdgeConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/describeEdgeConfiguration");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_DescribeEdgeConfigurationCommand");
var se_DescribeImageGenerationConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/describeImageGenerationConfiguration");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_DescribeImageGenerationConfigurationCommand");
var se_DescribeMappedResourceConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/describeMappedResourceConfiguration");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
MaxResults: [],
NextToken: [],
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_DescribeMappedResourceConfigurationCommand");
var se_DescribeMediaStorageConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/describeMediaStorageConfiguration");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
ChannelARN: [],
ChannelName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_DescribeMediaStorageConfigurationCommand");
var se_DescribeNotificationConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/describeNotificationConfiguration");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_DescribeNotificationConfigurationCommand");
var se_DescribeSignalingChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/describeSignalingChannel");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
ChannelARN: [],
ChannelName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_DescribeSignalingChannelCommand");
var se_DescribeStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/describeStream");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_DescribeStreamCommand");
var se_GetDataEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/getDataEndpoint");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
APIName: [],
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_GetDataEndpointCommand");
var se_GetSignalingChannelEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/getSignalingChannelEndpoint");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
ChannelARN: [],
SingleMasterChannelEndpointConfiguration: (_) => (0, import_smithy_client._json)(_)
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_GetSignalingChannelEndpointCommand");
var se_ListEdgeAgentConfigurationsCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/listEdgeAgentConfigurations");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
HubDeviceArn: [],
MaxResults: [],
NextToken: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_ListEdgeAgentConfigurationsCommand");
var se_ListSignalingChannelsCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/listSignalingChannels");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
ChannelNameCondition: (_) => (0, import_smithy_client._json)(_),
MaxResults: [],
NextToken: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_ListSignalingChannelsCommand");
var se_ListStreamsCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/listStreams");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
MaxResults: [],
NextToken: [],
StreamNameCondition: (_) => (0, import_smithy_client._json)(_)
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_ListStreamsCommand");
var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/ListTagsForResource");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
NextToken: [],
ResourceARN: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_ListTagsForResourceCommand");
var se_ListTagsForStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/listTagsForStream");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
NextToken: [],
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_ListTagsForStreamCommand");
var se_StartEdgeConfigurationUpdateCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/startEdgeConfigurationUpdate");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
EdgeConfig: (_) => (0, import_smithy_client._json)(_),
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_StartEdgeConfigurationUpdateCommand");
var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/TagResource");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
ResourceARN: [],
Tags: (_) => (0, import_smithy_client._json)(_)
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_TagResourceCommand");
var se_TagStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/tagStream");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
StreamARN: [],
StreamName: [],
Tags: (_) => (0, import_smithy_client._json)(_)
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_TagStreamCommand");
var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/UntagResource");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
ResourceARN: [],
TagKeyList: (_) => (0, import_smithy_client._json)(_)
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_UntagResourceCommand");
var se_UntagStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/untagStream");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
StreamARN: [],
StreamName: [],
TagKeyList: (_) => (0, import_smithy_client._json)(_)
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_UntagStreamCommand");
var se_UpdateDataRetentionCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/updateDataRetention");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
CurrentVersion: [],
DataRetentionChangeInHours: [],
Operation: [],
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_UpdateDataRetentionCommand");
var se_UpdateImageGenerationConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/updateImageGenerationConfiguration");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
ImageGenerationConfiguration: (_) => (0, import_smithy_client._json)(_),
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_UpdateImageGenerationConfigurationCommand");
var se_UpdateMediaStorageConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/updateMediaStorageConfiguration");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
ChannelARN: [],
MediaStorageConfiguration: (_) => (0, import_smithy_client._json)(_)
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_UpdateMediaStorageConfigurationCommand");
var se_UpdateNotificationConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/updateNotificationConfiguration");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
NotificationConfiguration: (_) => (0, import_smithy_client._json)(_),
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_UpdateNotificationConfigurationCommand");
var se_UpdateSignalingChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/updateSignalingChannel");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
ChannelARN: [],
CurrentVersion: [],
SingleMasterConfiguration: (_) => (0, import_smithy_client._json)(_)
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_UpdateSignalingChannelCommand");
var se_UpdateStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
const b = (0, import_core.requestBuilder)(input, context);
const headers = {
"content-type": "application/json"
};
b.bp("/updateStream");
let body;
body = JSON.stringify(
(0, import_smithy_client.take)(input, {
CurrentVersion: [],
DeviceName: [],
MediaType: [],
StreamARN: [],
StreamName: []
})
);
b.m("POST").h(headers).b(body);
return b.build();
}, "se_UpdateStreamCommand");
var de_CreateSignalingChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = (0, import_smithy_client.map)({
$metadata: deserializeMetadata(output)
});
const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
const doc = (0, import_smithy_client.take)(data, {
ChannelARN: import_smithy_client.expectString
});
Object.assign(contents, doc);
return contents;
}, "de_CreateSignalingChannelCommand");
var de_CreateStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = (0, import_smithy_client.map)({
$metadata: deserializeMetadata(output)
});
const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
const doc = (0, import_smithy_client.take)(data, {
StreamARN: import_smithy_client.expectString
});
Object.assign(contents, doc);
return contents;
}, "de_CreateStreamCommand");
var de_DeleteEdgeConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = (0, import_smithy_client.map)({
$metadata: deserializeMetadata(output)
});
await (0, import_smithy_client.collectBody)(output.body, context);
return contents;
}, "de_DeleteEdgeConfigurationCommand");
var de_DeleteSignalingChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = (0, import_smithy_client.map)({
$metadata: deserializeMetadata(output)
});
await (0, import_smithy_client.collectBody)(output.body, context);
return contents;
}, "de_DeleteSignalingChannelCommand");
var de_DeleteStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = (0, import_smithy_client.map)({
$metadata: deserializeMetadata(output)
});
await (0, import_smithy_client.collectBody)(output.body, context);
return contents;
}, "de_DeleteStreamCommand");
var de_DescribeEdgeConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = (0, import_smithy_client.map)({
$metadata: deserializeMetadata(output)
});
const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
const doc = (0, import_smithy_client.take)(data, {
CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
EdgeAgentStatus: (_) => de_EdgeAgentStatus(_, context),
EdgeConfig: import_smithy_client._json,
FailedStatusDetails: import_smithy_client.expectString,
LastUpdatedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
StreamARN: import_smithy_client.expectString,
StreamName: import_smithy_client.expectString,
SyncStatus: import_smithy_client.expectString
});
Object.assign(contents, doc);
return contents;
}, "de_DescribeEdgeConfigurationCommand");
var de_DescribeImageGenerationConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = (0, import_smithy_client.map)({
$metadata: deserializeMetadata(output)
});
const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
const doc = (0, import_smithy_client.take)(data, {
ImageGenerationConfiguration: import_smithy_client._json
});
Object.assign(contents, doc);
return contents;
}, "de_DescribeImageGenerationConfigurationCommand");
var de_DescribeMappedResourceConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = (0, import_smithy_client.map)({
$metadata: deserializeMetadata(output)
});
const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
const doc = (0, import_smithy_client.take)(data, {
MappedResourceConfigurationList: import_smithy_client._json,
NextToken: import_smithy_client.expectString
});
Object.assign(contents, doc);
return contents;
}, "de_DescribeMappedResourceConfigurationCommand");
var de_DescribeMediaStorageConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = (0, import_smithy_client.map)({
$metadata: deserializeMetadata(output)
});
const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
const doc = (0, import_smithy_client.take)(data, {
MediaStorageConfiguration: import_smithy_client._json
});
Object.assign(contents, doc);
return contents;
}, "de_DescribeMediaStorageConfigurationCommand");
var de_DescribeNotificationConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = (0, import_smithy_client.map)({
$metadata: deserializeMetadata(output)
});
const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
const doc = (0, import_smithy_client.take)(data, {
NotificationConfiguration: import_smithy_client._json
});
Object.assign(contents, doc);
return contents;
}, "de_DescribeNotificationConfigurationCommand");
var de_DescribeSignalingChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = (0, import_smithy_client.map)({
$metadata: deserializeMetadata(output)
});
const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
const doc = (0, import_smithy_client.take)(data, {
ChannelInfo: (_) => de_ChannelInfo(_, context)
});
Object.assign(contents, doc);
return contents;
}, "de_DescribeSignalingChannelCommand");
var de_DescribeStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = (0, import_smithy_client.map)({
$metadata: deserializeMetadata(output)
});
const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
const doc = (0, import_smithy_client.take)(data, {
StreamInfo: (_) => de_StreamInfo(_, context)
});
Object.assign(contents, doc);
return contents;
}, "de_DescribeStreamCommand");
var de_GetDataEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {