cdk-amazon-chime-resources/node_modules/@aws-sdk/client-kinesis-video/dist-es/protocols/Aws_restJson1.js


import { loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody } from "@aws-sdk/core";
import { requestBuilder as rb } from "@smithy/core";
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
import { KinesisVideoServiceException as __BaseException } from "../models/KinesisVideoServiceException";
import { AccessDeniedException, AccountChannelLimitExceededException, AccountStreamLimitExceededException, ClientLimitExceededException, DeviceStreamLimitExceededException, InvalidArgumentException, InvalidDeviceException, InvalidResourceFormatException, NoDataRetentionException, NotAuthorizedException, ResourceInUseException, ResourceNotFoundException, StreamEdgeConfigurationNotFoundException, TagsPerResourceExceededLimitException, VersionMismatchException, } from "../models/models_0";
export const se_CreateSignalingChannelCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/createSignalingChannel");
    let body;
    body = JSON.stringify(take(input, {
        ChannelName: [],
        ChannelType: [],
        SingleMasterConfiguration: (_) => _json(_),
        Tags: (_) => _json(_),
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_CreateStreamCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/createStream");
    let body;
    body = JSON.stringify(take(input, {
        DataRetentionInHours: [],
        DeviceName: [],
        KmsKeyId: [],
        MediaType: [],
        StreamName: [],
        Tags: (_) => _json(_),
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_DeleteEdgeConfigurationCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/deleteEdgeConfiguration");
    let body;
    body = JSON.stringify(take(input, {
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_DeleteSignalingChannelCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/deleteSignalingChannel");
    let body;
    body = JSON.stringify(take(input, {
        ChannelARN: [],
        CurrentVersion: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_DeleteStreamCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/deleteStream");
    let body;
    body = JSON.stringify(take(input, {
        CurrentVersion: [],
        StreamARN: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_DescribeEdgeConfigurationCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/describeEdgeConfiguration");
    let body;
    body = JSON.stringify(take(input, {
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_DescribeImageGenerationConfigurationCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/describeImageGenerationConfiguration");
    let body;
    body = JSON.stringify(take(input, {
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_DescribeMappedResourceConfigurationCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/describeMappedResourceConfiguration");
    let body;
    body = JSON.stringify(take(input, {
        MaxResults: [],
        NextToken: [],
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_DescribeMediaStorageConfigurationCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/describeMediaStorageConfiguration");
    let body;
    body = JSON.stringify(take(input, {
        ChannelARN: [],
        ChannelName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_DescribeNotificationConfigurationCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/describeNotificationConfiguration");
    let body;
    body = JSON.stringify(take(input, {
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_DescribeSignalingChannelCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/describeSignalingChannel");
    let body;
    body = JSON.stringify(take(input, {
        ChannelARN: [],
        ChannelName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_DescribeStreamCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/describeStream");
    let body;
    body = JSON.stringify(take(input, {
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_GetDataEndpointCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/getDataEndpoint");
    let body;
    body = JSON.stringify(take(input, {
        APIName: [],
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_GetSignalingChannelEndpointCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/getSignalingChannelEndpoint");
    let body;
    body = JSON.stringify(take(input, {
        ChannelARN: [],
        SingleMasterChannelEndpointConfiguration: (_) => _json(_),
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_ListEdgeAgentConfigurationsCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/listEdgeAgentConfigurations");
    let body;
    body = JSON.stringify(take(input, {
        HubDeviceArn: [],
        MaxResults: [],
        NextToken: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_ListSignalingChannelsCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/listSignalingChannels");
    let body;
    body = JSON.stringify(take(input, {
        ChannelNameCondition: (_) => _json(_),
        MaxResults: [],
        NextToken: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_ListStreamsCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/listStreams");
    let body;
    body = JSON.stringify(take(input, {
        MaxResults: [],
        NextToken: [],
        StreamNameCondition: (_) => _json(_),
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_ListTagsForResourceCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/ListTagsForResource");
    let body;
    body = JSON.stringify(take(input, {
        NextToken: [],
        ResourceARN: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_ListTagsForStreamCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/listTagsForStream");
    let body;
    body = JSON.stringify(take(input, {
        NextToken: [],
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_StartEdgeConfigurationUpdateCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/startEdgeConfigurationUpdate");
    let body;
    body = JSON.stringify(take(input, {
        EdgeConfig: (_) => _json(_),
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_TagResourceCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/TagResource");
    let body;
    body = JSON.stringify(take(input, {
        ResourceARN: [],
        Tags: (_) => _json(_),
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_TagStreamCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/tagStream");
    let body;
    body = JSON.stringify(take(input, {
        StreamARN: [],
        StreamName: [],
        Tags: (_) => _json(_),
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_UntagResourceCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/UntagResource");
    let body;
    body = JSON.stringify(take(input, {
        ResourceARN: [],
        TagKeyList: (_) => _json(_),
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_UntagStreamCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/untagStream");
    let body;
    body = JSON.stringify(take(input, {
        StreamARN: [],
        StreamName: [],
        TagKeyList: (_) => _json(_),
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_UpdateDataRetentionCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/updateDataRetention");
    let body;
    body = JSON.stringify(take(input, {
        CurrentVersion: [],
        DataRetentionChangeInHours: [],
        Operation: [],
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_UpdateImageGenerationConfigurationCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/updateImageGenerationConfiguration");
    let body;
    body = JSON.stringify(take(input, {
        ImageGenerationConfiguration: (_) => _json(_),
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_UpdateMediaStorageConfigurationCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/updateMediaStorageConfiguration");
    let body;
    body = JSON.stringify(take(input, {
        ChannelARN: [],
        MediaStorageConfiguration: (_) => _json(_),
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_UpdateNotificationConfigurationCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/updateNotificationConfiguration");
    let body;
    body = JSON.stringify(take(input, {
        NotificationConfiguration: (_) => _json(_),
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_UpdateSignalingChannelCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/updateSignalingChannel");
    let body;
    body = JSON.stringify(take(input, {
        ChannelARN: [],
        CurrentVersion: [],
        SingleMasterConfiguration: (_) => _json(_),
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const se_UpdateStreamCommand = async (input, context) => {
    const b = rb(input, context);
    const headers = {
        "content-type": "application/json",
    };
    b.bp("/updateStream");
    let body;
    body = JSON.stringify(take(input, {
        CurrentVersion: [],
        DeviceName: [],
        MediaType: [],
        StreamARN: [],
        StreamName: [],
    }));
    b.m("POST").h(headers).b(body);
    return b.build();
};
export const de_CreateSignalingChannelCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        ChannelARN: __expectString,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_CreateStreamCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        StreamARN: __expectString,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_DeleteEdgeConfigurationCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
export const de_DeleteSignalingChannelCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
export const de_DeleteStreamCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
export const de_DescribeEdgeConfigurationCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        CreationTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        EdgeAgentStatus: (_) => de_EdgeAgentStatus(_, context),
        EdgeConfig: _json,
        FailedStatusDetails: __expectString,
        LastUpdatedTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        StreamARN: __expectString,
        StreamName: __expectString,
        SyncStatus: __expectString,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_DescribeImageGenerationConfigurationCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        ImageGenerationConfiguration: _json,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_DescribeMappedResourceConfigurationCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        MappedResourceConfigurationList: _json,
        NextToken: __expectString,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_DescribeMediaStorageConfigurationCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        MediaStorageConfiguration: _json,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_DescribeNotificationConfigurationCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        NotificationConfiguration: _json,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_DescribeSignalingChannelCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        ChannelInfo: (_) => de_ChannelInfo(_, context),
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_DescribeStreamCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        StreamInfo: (_) => de_StreamInfo(_, context),
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_GetDataEndpointCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        DataEndpoint: __expectString,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_GetSignalingChannelEndpointCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        ResourceEndpointList: _json,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_ListEdgeAgentConfigurationsCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        EdgeConfigs: (_) => de_ListEdgeAgentConfigurationsEdgeConfigList(_, context),
        NextToken: __expectString,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_ListSignalingChannelsCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        ChannelInfoList: (_) => de_ChannelInfoList(_, context),
        NextToken: __expectString,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_ListStreamsCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        NextToken: __expectString,
        StreamInfoList: (_) => de_StreamInfoList(_, context),
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_ListTagsForResourceCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        NextToken: __expectString,
        Tags: _json,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_ListTagsForStreamCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        NextToken: __expectString,
        Tags: _json,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_StartEdgeConfigurationUpdateCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
    const doc = take(data, {
        CreationTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        EdgeConfig: _json,
        FailedStatusDetails: __expectString,
        LastUpdatedTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        StreamARN: __expectString,
        StreamName: __expectString,
        SyncStatus: __expectString,
    });
    Object.assign(contents, doc);
    return contents;
};
export const de_TagResourceCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
export const de_TagStreamCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
export const de_UntagResourceCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
export const de_UntagStreamCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
export const de_UpdateDataRetentionCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
export const de_UpdateImageGenerationConfigurationCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
export const de_UpdateMediaStorageConfigurationCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
export const de_UpdateNotificationConfigurationCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
export const de_UpdateSignalingChannelCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
export const de_UpdateStreamCommand = async (output, context) => {
    if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const contents = map({
        $metadata: deserializeMetadata(output),
    });
    await collectBody(output.body, context);
    return contents;
};
const de_CommandError = async (output, context) => {
    const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context),
    };
    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
    switch (errorCode) {
        case "AccessDeniedException":
        case "com.amazonaws.kinesisvideo#AccessDeniedException":
            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
        case "AccountChannelLimitExceededException":
        case "com.amazonaws.kinesisvideo#AccountChannelLimitExceededException":
            throw await de_AccountChannelLimitExceededExceptionRes(parsedOutput, context);
        case "ClientLimitExceededException":
        case "com.amazonaws.kinesisvideo#ClientLimitExceededException":
            throw await de_ClientLimitExceededExceptionRes(parsedOutput, context);
        case "InvalidArgumentException":
        case "com.amazonaws.kinesisvideo#InvalidArgumentException":
            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
        case "ResourceInUseException":
        case "com.amazonaws.kinesisvideo#ResourceInUseException":
            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
        case "TagsPerResourceExceededLimitException":
        case "com.amazonaws.kinesisvideo#TagsPerResourceExceededLimitException":
            throw await de_TagsPerResourceExceededLimitExceptionRes(parsedOutput, context);
        case "AccountStreamLimitExceededException":
        case "com.amazonaws.kinesisvideo#AccountStreamLimitExceededException":
            throw await de_AccountStreamLimitExceededExceptionRes(parsedOutput, context);
        case "DeviceStreamLimitExceededException":
        case "com.amazonaws.kinesisvideo#DeviceStreamLimitExceededException":
            throw await de_DeviceStreamLimitExceededExceptionRes(parsedOutput, context);
        case "InvalidDeviceException":
        case "com.amazonaws.kinesisvideo#InvalidDeviceException":
            throw await de_InvalidDeviceExceptionRes(parsedOutput, context);
        case "ResourceNotFoundException":
        case "com.amazonaws.kinesisvideo#ResourceNotFoundException":
            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
        case "StreamEdgeConfigurationNotFoundException":
        case "com.amazonaws.kinesisvideo#StreamEdgeConfigurationNotFoundException":
            throw await de_StreamEdgeConfigurationNotFoundExceptionRes(parsedOutput, context);
        case "VersionMismatchException":
        case "com.amazonaws.kinesisvideo#VersionMismatchException":
            throw await de_VersionMismatchExceptionRes(parsedOutput, context);
        case "NotAuthorizedException":
        case "com.amazonaws.kinesisvideo#NotAuthorizedException":
            throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
        case "InvalidResourceFormatException":
        case "com.amazonaws.kinesisvideo#InvalidResourceFormatException":
            throw await de_InvalidResourceFormatExceptionRes(parsedOutput, context);
        case "NoDataRetentionException":
        case "com.amazonaws.kinesisvideo#NoDataRetentionException":
            throw await de_NoDataRetentionExceptionRes(parsedOutput, context);
        default:
            const parsedBody = parsedOutput.body;
            return throwDefaultError({
                output,
                parsedBody,
                errorCode,
            });
    }
};
const throwDefaultError = withBaseException(__BaseException);
const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new AccessDeniedException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_AccountChannelLimitExceededExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new AccountChannelLimitExceededException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_AccountStreamLimitExceededExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new AccountStreamLimitExceededException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_ClientLimitExceededExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new ClientLimitExceededException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_DeviceStreamLimitExceededExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new DeviceStreamLimitExceededException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_InvalidArgumentExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new InvalidArgumentException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_InvalidDeviceExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new InvalidDeviceException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_InvalidResourceFormatExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new InvalidResourceFormatException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_NoDataRetentionExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new NoDataRetentionException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_NotAuthorizedExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new NotAuthorizedException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_ResourceInUseExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new ResourceInUseException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new ResourceNotFoundException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_StreamEdgeConfigurationNotFoundExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new StreamEdgeConfigurationNotFoundException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_TagsPerResourceExceededLimitExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new TagsPerResourceExceededLimitException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_VersionMismatchExceptionRes = async (parsedOutput, context) => {
    const contents = map({});
    const data = parsedOutput.body;
    const doc = take(data, {
        Message: __expectString,
    });
    Object.assign(contents, doc);
    const exception = new VersionMismatchException({
        $metadata: deserializeMetadata(parsedOutput),
        ...contents,
    });
    return __decorateServiceException(exception, parsedOutput.body);
};
const de_ChannelInfo = (output, context) => {
    return take(output, {
        ChannelARN: __expectString,
        ChannelName: __expectString,
        ChannelStatus: __expectString,
        ChannelType: __expectString,
        CreationTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        SingleMasterConfiguration: _json,
        Version: __expectString,
    });
};
const de_ChannelInfoList = (output, context) => {
    const retVal = (output || [])
        .filter((e) => e != null)
        .map((entry) => {
        return de_ChannelInfo(entry, context);
    });
    return retVal;
};
const de_EdgeAgentStatus = (output, context) => {
    return take(output, {
        LastRecorderStatus: (_) => de_LastRecorderStatus(_, context),
        LastUploaderStatus: (_) => de_LastUploaderStatus(_, context),
    });
};
const de_LastRecorderStatus = (output, context) => {
    return take(output, {
        JobStatusDetails: __expectString,
        LastCollectedTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        LastUpdatedTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        RecorderStatus: __expectString,
    });
};
const de_LastUploaderStatus = (output, context) => {
    return take(output, {
        JobStatusDetails: __expectString,
        LastCollectedTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        LastUpdatedTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        UploaderStatus: __expectString,
    });
};
const de_ListEdgeAgentConfigurationsEdgeConfig = (output, context) => {
    return take(output, {
        CreationTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        EdgeConfig: _json,
        FailedStatusDetails: __expectString,
        LastUpdatedTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        StreamARN: __expectString,
        StreamName: __expectString,
        SyncStatus: __expectString,
    });
};
const de_ListEdgeAgentConfigurationsEdgeConfigList = (output, context) => {
    const retVal = (output || [])
        .filter((e) => e != null)
        .map((entry) => {
        return de_ListEdgeAgentConfigurationsEdgeConfig(entry, context);
    });
    return retVal;
};
const de_StreamInfo = (output, context) => {
    return take(output, {
        CreationTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        DataRetentionInHours: __expectInt32,
        DeviceName: __expectString,
        KmsKeyId: __expectString,
        MediaType: __expectString,
        Status: __expectString,
        StreamARN: __expectString,
        StreamName: __expectString,
        Version: __expectString,
    });
};
const de_StreamInfoList = (output, context) => {
    const retVal = (output || [])
        .filter((e) => e != null)
        .map((entry) => {
        return de_StreamInfo(entry, context);
    });
    return retVal;
};
const deserializeMetadata = (output) => ({
    httpStatusCode: output.statusCode,
    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
    extendedRequestId: output.headers["x-amz-id-2"],
    cfId: output.headers["x-amz-cf-id"],
});
const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
const isSerializableHeaderValue = (value) => value !== undefined &&
    value !== null &&
    value !== "" &&
    (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
    (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);