@aws-sdk/client-acm/dist-es/protocols/Aws_json1_1.js

AWS SDK for JavaScript Acm Client for Node.js, Browser and React Native

import { loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody } from "@aws-sdk/core";
import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
import { ACMServiceException as __BaseException } from "../models/ACMServiceException";
import { AccessDeniedException, ConflictException, InvalidArgsException, InvalidArnException, InvalidDomainValidationOptionsException, InvalidParameterException, InvalidStateException, InvalidTagException, LimitExceededException, RequestInProgressException, ResourceInUseException, ResourceNotFoundException, TagPolicyException, ThrottlingException, TooManyTagsException, ValidationException, } from "../models/models_0";
export const se_AddTagsToCertificateCommand = async (input, context) => {
    const headers = sharedHeaders("AddTagsToCertificate");
    let body;
    body = JSON.stringify(_json(input));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DeleteCertificateCommand = async (input, context) => {
    const headers = sharedHeaders("DeleteCertificate");
    let body;
    body = JSON.stringify(_json(input));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeCertificateCommand = async (input, context) => {
    const headers = sharedHeaders("DescribeCertificate");
    let body;
    body = JSON.stringify(_json(input));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ExportCertificateCommand = async (input, context) => {
    const headers = sharedHeaders("ExportCertificate");
    let body;
    body = JSON.stringify(se_ExportCertificateRequest(input, context));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_GetAccountConfigurationCommand = async (input, context) => {
    const headers = sharedHeaders("GetAccountConfiguration");
    const body = "{}";
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_GetCertificateCommand = async (input, context) => {
    const headers = sharedHeaders("GetCertificate");
    let body;
    body = JSON.stringify(_json(input));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ImportCertificateCommand = async (input, context) => {
    const headers = sharedHeaders("ImportCertificate");
    let body;
    body = JSON.stringify(se_ImportCertificateRequest(input, context));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ListCertificatesCommand = async (input, context) => {
    const headers = sharedHeaders("ListCertificates");
    let body;
    body = JSON.stringify(_json(input));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ListTagsForCertificateCommand = async (input, context) => {
    const headers = sharedHeaders("ListTagsForCertificate");
    let body;
    body = JSON.stringify(_json(input));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_PutAccountConfigurationCommand = async (input, context) => {
    const headers = sharedHeaders("PutAccountConfiguration");
    let body;
    body = JSON.stringify(_json(input));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_RemoveTagsFromCertificateCommand = async (input, context) => {
    const headers = sharedHeaders("RemoveTagsFromCertificate");
    let body;
    body = JSON.stringify(_json(input));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_RenewCertificateCommand = async (input, context) => {
    const headers = sharedHeaders("RenewCertificate");
    let body;
    body = JSON.stringify(_json(input));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_RequestCertificateCommand = async (input, context) => {
    const headers = sharedHeaders("RequestCertificate");
    let body;
    body = JSON.stringify(_json(input));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ResendValidationEmailCommand = async (input, context) => {
    const headers = sharedHeaders("ResendValidationEmail");
    let body;
    body = JSON.stringify(_json(input));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_UpdateCertificateOptionsCommand = async (input, context) => {
    const headers = sharedHeaders("UpdateCertificateOptions");
    let body;
    body = JSON.stringify(_json(input));
    return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const de_AddTagsToCertificateCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    await collectBody(output.body, context);
    const response = {
        $metadata: deserializeMetadata(output),
    };
    return response;
};
export const de_DeleteCertificateCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    await collectBody(output.body, context);
    const response = {
        $metadata: deserializeMetadata(output),
    };
    return response;
};
export const de_DescribeCertificateCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const data = await parseBody(output.body, context);
    let contents = {};
    contents = de_DescribeCertificateResponse(data, context);
    const response = {
        $metadata: deserializeMetadata(output),
        ...contents,
    };
    return response;
};
export const de_ExportCertificateCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const data = await parseBody(output.body, context);
    let contents = {};
    contents = _json(data);
    const response = {
        $metadata: deserializeMetadata(output),
        ...contents,
    };
    return response;
};
export const de_GetAccountConfigurationCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const data = await parseBody(output.body, context);
    let contents = {};
    contents = _json(data);
    const response = {
        $metadata: deserializeMetadata(output),
        ...contents,
    };
    return response;
};
export const de_GetCertificateCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const data = await parseBody(output.body, context);
    let contents = {};
    contents = _json(data);
    const response = {
        $metadata: deserializeMetadata(output),
        ...contents,
    };
    return response;
};
export const de_ImportCertificateCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const data = await parseBody(output.body, context);
    let contents = {};
    contents = _json(data);
    const response = {
        $metadata: deserializeMetadata(output),
        ...contents,
    };
    return response;
};
export const de_ListCertificatesCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const data = await parseBody(output.body, context);
    let contents = {};
    contents = de_ListCertificatesResponse(data, context);
    const response = {
        $metadata: deserializeMetadata(output),
        ...contents,
    };
    return response;
};
export const de_ListTagsForCertificateCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const data = await parseBody(output.body, context);
    let contents = {};
    contents = _json(data);
    const response = {
        $metadata: deserializeMetadata(output),
        ...contents,
    };
    return response;
};
export const de_PutAccountConfigurationCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    await collectBody(output.body, context);
    const response = {
        $metadata: deserializeMetadata(output),
    };
    return response;
};
export const de_RemoveTagsFromCertificateCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    await collectBody(output.body, context);
    const response = {
        $metadata: deserializeMetadata(output),
    };
    return response;
};
export const de_RenewCertificateCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    await collectBody(output.body, context);
    const response = {
        $metadata: deserializeMetadata(output),
    };
    return response;
};
export const de_RequestCertificateCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    const data = await parseBody(output.body, context);
    let contents = {};
    contents = _json(data);
    const response = {
        $metadata: deserializeMetadata(output),
        ...contents,
    };
    return response;
};
export const de_ResendValidationEmailCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    await collectBody(output.body, context);
    const response = {
        $metadata: deserializeMetadata(output),
    };
    return response;
};
export const de_UpdateCertificateOptionsCommand = async (output, context) => {
    if (output.statusCode >= 300) {
        return de_CommandError(output, context);
    }
    await collectBody(output.body, context);
    const response = {
        $metadata: deserializeMetadata(output),
    };
    return response;
};
const de_CommandError = async (output, context) => {
    const parsedOutput = {
        ...output,
        body: await parseErrorBody(output.body, context),
    };
    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
    switch (errorCode) {
        case "InvalidArnException":
        case "com.amazonaws.acm#InvalidArnException":
            throw await de_InvalidArnExceptionRes(parsedOutput, context);
        case "InvalidParameterException":
        case "com.amazonaws.acm#InvalidParameterException":
            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
        case "InvalidTagException":
        case "com.amazonaws.acm#InvalidTagException":
            throw await de_InvalidTagExceptionRes(parsedOutput, context);
        case "ResourceNotFoundException":
        case "com.amazonaws.acm#ResourceNotFoundException":
            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
        case "TagPolicyException":
        case "com.amazonaws.acm#TagPolicyException":
            throw await de_TagPolicyExceptionRes(parsedOutput, context);
        case "ThrottlingException":
        case "com.amazonaws.acm#ThrottlingException":
            throw await de_ThrottlingExceptionRes(parsedOutput, context);
        case "TooManyTagsException":
        case "com.amazonaws.acm#TooManyTagsException":
            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
        case "AccessDeniedException":
        case "com.amazonaws.acm#AccessDeniedException":
            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
        case "ConflictException":
        case "com.amazonaws.acm#ConflictException":
            throw await de_ConflictExceptionRes(parsedOutput, context);
        case "ResourceInUseException":
        case "com.amazonaws.acm#ResourceInUseException":
            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
        case "RequestInProgressException":
        case "com.amazonaws.acm#RequestInProgressException":
            throw await de_RequestInProgressExceptionRes(parsedOutput, context);
        case "LimitExceededException":
        case "com.amazonaws.acm#LimitExceededException":
            throw await de_LimitExceededExceptionRes(parsedOutput, context);
        case "InvalidArgsException":
        case "com.amazonaws.acm#InvalidArgsException":
            throw await de_InvalidArgsExceptionRes(parsedOutput, context);
        case "ValidationException":
        case "com.amazonaws.acm#ValidationException":
            throw await de_ValidationExceptionRes(parsedOutput, context);
        case "InvalidDomainValidationOptionsException":
        case "com.amazonaws.acm#InvalidDomainValidationOptionsException":
            throw await de_InvalidDomainValidationOptionsExceptionRes(parsedOutput, context);
        case "InvalidStateException":
        case "com.amazonaws.acm#InvalidStateException":
            throw await de_InvalidStateExceptionRes(parsedOutput, context);
        default:
            const parsedBody = parsedOutput.body;
            return throwDefaultError({
                output,
                parsedBody,
                errorCode,
            });
    }
};
const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new AccessDeniedException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_ConflictExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new ConflictException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_InvalidArgsExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new InvalidArgsException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_InvalidArnExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new InvalidArnException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_InvalidDomainValidationOptionsExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new InvalidDomainValidationOptionsException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_InvalidParameterExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new InvalidParameterException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_InvalidStateExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new InvalidStateException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_InvalidTagExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new InvalidTagException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new LimitExceededException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_RequestInProgressExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new RequestInProgressException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_ResourceInUseExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new ResourceInUseException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new ResourceNotFoundException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_TagPolicyExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new TagPolicyException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new ThrottlingException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new TooManyTagsException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const de_ValidationExceptionRes = async (parsedOutput, context) => {
    const body = parsedOutput.body;
    const deserialized = _json(body);
    const exception = new ValidationException({
        $metadata: deserializeMetadata(parsedOutput),
        ...deserialized,
    });
    return __decorateServiceException(exception, body);
};
const se_ExportCertificateRequest = (input, context) => {
    return take(input, {
        CertificateArn: [],
        Passphrase: context.base64Encoder,
    });
};
const se_ImportCertificateRequest = (input, context) => {
    return take(input, {
        Certificate: context.base64Encoder,
        CertificateArn: [],
        CertificateChain: context.base64Encoder,
        PrivateKey: context.base64Encoder,
        Tags: _json,
    });
};
const de_CertificateDetail = (output, context) => {
    return take(output, {
        CertificateArn: __expectString,
        CertificateAuthorityArn: __expectString,
        CreatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        DomainName: __expectString,
        DomainValidationOptions: _json,
        ExtendedKeyUsages: _json,
        FailureReason: __expectString,
        ImportedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        InUseBy: _json,
        IssuedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        Issuer: __expectString,
        KeyAlgorithm: __expectString,
        KeyUsages: _json,
        NotAfter: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        NotBefore: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        Options: _json,
        RenewalEligibility: __expectString,
        RenewalSummary: (_) => de_RenewalSummary(_, context),
        RevocationReason: __expectString,
        RevokedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        Serial: __expectString,
        SignatureAlgorithm: __expectString,
        Status: __expectString,
        Subject: __expectString,
        SubjectAlternativeNames: _json,
        Type: __expectString,
    });
};
const de_CertificateSummary = (output, context) => {
    return take(output, {
        CertificateArn: __expectString,
        CreatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        DomainName: __expectString,
        Exported: __expectBoolean,
        ExtendedKeyUsages: _json,
        HasAdditionalSubjectAlternativeNames: __expectBoolean,
        ImportedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        InUse: __expectBoolean,
        IssuedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        KeyAlgorithm: __expectString,
        KeyUsages: _json,
        NotAfter: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        NotBefore: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        RenewalEligibility: __expectString,
        RevokedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
        Status: __expectString,
        SubjectAlternativeNameSummaries: _json,
        Type: __expectString,
    });
};
const de_CertificateSummaryList = (output, context) => {
    const retVal = (output || [])
        .filter((e) => e != null)
        .map((entry) => {
        return de_CertificateSummary(entry, context);
    });
    return retVal;
};
const de_DescribeCertificateResponse = (output, context) => {
    return take(output, {
        Certificate: (_) => de_CertificateDetail(_, context),
    });
};
const de_ListCertificatesResponse = (output, context) => {
    return take(output, {
        CertificateSummaryList: (_) => de_CertificateSummaryList(_, context),
        NextToken: __expectString,
    });
};
const de_RenewalSummary = (output, context) => {
    return take(output, {
        DomainValidationOptions: _json,
        RenewalStatus: __expectString,
        RenewalStatusReason: __expectString,
        UpdatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
    });
};
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 throwDefaultError = withBaseException(__BaseException);
const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
    const contents = {
        protocol,
        hostname,
        port,
        method: "POST",
        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
        headers,
    };
    if (resolvedHostname !== undefined) {
        contents.hostname = resolvedHostname;
    }
    if (body !== undefined) {
        contents.body = body;
    }
    return new __HttpRequest(contents);
};
function sharedHeaders(operation) {
    return {
        "content-type": "application/x-amz-json-1.1",
        "x-amz-target": `CertificateManager.${operation}`,
    };
}