@aws-sdk/client-appsync 3.338.0 → 3.341.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,4 +1,4 @@
-import { _json, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, resolvedPath as __resolvedPath, take, withBaseException, } from "@aws-sdk/smithy-client";
+import { _json, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@aws-sdk/smithy-client";
 import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
 import { AppSyncServiceException as __BaseException } from "../models/AppSyncServiceException";
 import { AccessDeniedException, ApiKeyLimitExceededException, ApiKeyValidityOutOfBoundsException, ApiLimitExceededException, BadRequestException, ConcurrentModificationException, GraphQLSchemaException, InternalFailureException, LimitExceededException, NotFoundException, UnauthorizedException, } from "../models/models_0";
@@ -24,6 +24,54 @@ export const se_AssociateApiCommand = async (input, context) => {
         body,
     });
 };
+export const se_AssociateMergedGraphqlApiCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/sourceApis/{sourceApiIdentifier}/mergedApiAssociations";
+    resolvedPath = __resolvedPath(resolvedPath, input, "sourceApiIdentifier", () => input.sourceApiIdentifier, "{sourceApiIdentifier}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        description: [],
+        mergedApiIdentifier: [],
+        sourceApiAssociationConfig: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_AssociateSourceGraphqlApiCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations";
+    resolvedPath = __resolvedPath(resolvedPath, input, "mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        description: [],
+        sourceApiAssociationConfig: (_) => _json(_),
+        sourceApiIdentifier: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_CreateApiCacheCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -163,11 +211,14 @@ export const se_CreateGraphqlApiCommand = async (input, context) => {
     let body;
     body = JSON.stringify(take(input, {
         additionalAuthenticationProviders: (_) => _json(_),
+        apiType: [],
         authenticationType: [],
         lambdaAuthorizerConfig: (_) => _json(_),
         logConfig: (_) => _json(_),
+        mergedApiExecutionRoleArn: [],
         name: [],
         openIDConnectConfig: (_) => _json(_),
+        ownerContact: [],
         tags: (_) => _json(_),
         userPoolConfig: (_) => _json(_),
         visibility: [],
@@ -390,6 +441,42 @@ export const se_DisassociateApiCommand = async (input, context) => {
         body,
     });
 };
+export const se_DisassociateMergedGraphqlApiCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/sourceApis/{sourceApiIdentifier}/mergedApiAssociations/{associationId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "sourceApiIdentifier", () => input.sourceApiIdentifier, "{sourceApiIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "associationId", () => input.associationId, "{associationId}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_DisassociateSourceGraphqlApiCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "associationId", () => input.associationId, "{associationId}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_EvaluateCodeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -605,6 +692,24 @@ export const se_GetSchemaCreationStatusCommand = async (input, context) => {
         body,
     });
 };
+export const se_GetSourceApiAssociationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "associationId", () => input.associationId, "{associationId}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_GetTypeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -716,6 +821,8 @@ export const se_ListGraphqlApisCommand = async (input, context) => {
     const query = map({
         nextToken: [, input.nextToken],
         maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        apiType: [, input.apiType],
+        owner: [, input.owner],
     });
     let body;
     return new __HttpRequest({
@@ -775,6 +882,27 @@ export const se_ListResolversByFunctionCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListSourceApiAssociationsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/sourceApiAssociations";
+    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    const query = map({
+        nextToken: [, input.nextToken],
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_ListTagsForResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -813,6 +941,30 @@ export const se_ListTypesCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListTypesByAssociationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}/types";
+    resolvedPath = __resolvedPath(resolvedPath, input, "mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "associationId", () => input.associationId, "{associationId}", false);
+    const query = map({
+        format: [, __expectNonNull(input.format, `format`)],
+        nextToken: [, input.nextToken],
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_StartSchemaCreationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -834,6 +986,24 @@ export const se_StartSchemaCreationCommand = async (input, context) => {
         body,
     });
 };
+export const se_StartSchemaMergeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}/merge";
+    resolvedPath = __resolvedPath(resolvedPath, input, "associationId", () => input.associationId, "{associationId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_TagResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -1020,8 +1190,10 @@ export const se_UpdateGraphqlApiCommand = async (input, context) => {
         authenticationType: [],
         lambdaAuthorizerConfig: (_) => _json(_),
         logConfig: (_) => _json(_),
+        mergedApiExecutionRoleArn: [],
         name: [],
         openIDConnectConfig: (_) => _json(_),
+        ownerContact: [],
         userPoolConfig: (_) => _json(_),
         xrayEnabled: [],
     }));
@@ -1068,6 +1240,30 @@ export const se_UpdateResolverCommand = async (input, context) => {
         body,
     });
 };
+export const se_UpdateSourceApiAssociationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "associationId", () => input.associationId, "{associationId}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        description: [],
+        sourceApiAssociationConfig: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_UpdateTypeCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -1133,6 +1329,102 @@ const de_AssociateApiCommandError = async (output, context) => {
             });
     }
 };
+export const de_AssociateMergedGraphqlApiCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_AssociateMergedGraphqlApiCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        sourceApiAssociation: (_) => de_SourceApiAssociation(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_AssociateMergedGraphqlApiCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.appsync#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.appsync#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.appsync#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.appsync#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.appsync#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.appsync#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_AssociateSourceGraphqlApiCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_AssociateSourceGraphqlApiCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        sourceApiAssociation: (_) => de_SourceApiAssociation(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_AssociateSourceGraphqlApiCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.appsync#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.appsync#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.appsync#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.appsync#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.appsync#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.appsync#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_CreateApiCacheCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CreateApiCacheCommandError(output, context);
@@ -1859,42 +2151,132 @@ const de_DisassociateApiCommandError = async (output, context) => {
             });
     }
 };
-export const de_EvaluateCodeCommand = async (output, context) => {
+export const de_DisassociateMergedGraphqlApiCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_EvaluateCodeCommandError(output, context);
+        return de_DisassociateMergedGraphqlApiCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        error: _json,
-        evaluationResult: __expectString,
-        logs: _json,
+        sourceApiAssociationStatus: __expectString,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_EvaluateCodeCommandError = async (output, context) => {
+const de_DisassociateMergedGraphqlApiCommandError = 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.appsync#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadRequestException":
         case "com.amazonaws.appsync#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.appsync#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.appsync#InternalFailureException":
             throw await de_InternalFailureExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
+        case "NotFoundException":
+        case "com.amazonaws.appsync#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.appsync#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_DisassociateSourceGraphqlApiCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DisassociateSourceGraphqlApiCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        sourceApiAssociationStatus: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_DisassociateSourceGraphqlApiCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.appsync#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.appsync#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.appsync#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.appsync#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.appsync#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_EvaluateCodeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_EvaluateCodeCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        error: _json,
+        evaluationResult: __expectString,
+        logs: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_EvaluateCodeCommandError = 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.appsync#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.appsync#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.appsync#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
                 parsedBody,
                 errorCode,
             });
@@ -2361,6 +2743,48 @@ const de_GetSchemaCreationStatusCommandError = async (output, context) => {
             });
     }
 };
+export const de_GetSourceApiAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetSourceApiAssociationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        sourceApiAssociation: (_) => de_SourceApiAssociation(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetSourceApiAssociationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.appsync#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.appsync#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.appsync#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.appsync#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_GetTypeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_GetTypeCommandError(output, context);
@@ -2701,6 +3125,49 @@ const de_ListResolversByFunctionCommandError = async (output, context) => {
             });
     }
 };
+export const de_ListSourceApiAssociationsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListSourceApiAssociationsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        nextToken: __expectString,
+        sourceApiAssociationSummaries: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListSourceApiAssociationsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.appsync#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.appsync#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.appsync#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.appsync#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListTagsForResourceCommandError(output, context);
@@ -2795,6 +3262,52 @@ const de_ListTypesCommandError = async (output, context) => {
             });
     }
 };
+export const de_ListTypesByAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListTypesByAssociationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        nextToken: __expectString,
+        types: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListTypesByAssociationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.appsync#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.appsync#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.appsync#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.appsync#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.appsync#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_StartSchemaCreationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_StartSchemaCreationCommandError(output, context);
@@ -2840,6 +3353,51 @@ const de_StartSchemaCreationCommandError = async (output, context) => {
             });
     }
 };
+export const de_StartSchemaMergeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_StartSchemaMergeCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        sourceApiAssociationStatus: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_StartSchemaMergeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.appsync#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.appsync#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.appsync#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.appsync#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.appsync#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_TagResourceCommandError(output, context);
@@ -3246,6 +3804,51 @@ const de_UpdateResolverCommandError = async (output, context) => {
             });
     }
 };
+export const de_UpdateSourceApiAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_UpdateSourceApiAssociationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        sourceApiAssociation: (_) => de_SourceApiAssociation(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateSourceApiAssociationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.appsync#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.appsync#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.appsync#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.appsync#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.appsync#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_UpdateTypeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_UpdateTypeCommandError(output, context);
@@ -3437,6 +4040,21 @@ const de_UnauthorizedExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_SourceApiAssociation = (output, context) => {
+    return take(output, {
+        associationArn: __expectString,
+        associationId: __expectString,
+        description: __expectString,
+        lastSuccessfulMergeDate: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        mergedApiArn: __expectString,
+        mergedApiId: __expectString,
+        sourceApiArn: __expectString,
+        sourceApiAssociationConfig: _json,
+        sourceApiAssociationStatus: __expectString,
+        sourceApiAssociationStatusDetail: __expectString,
+        sourceApiId: __expectString,
+    });
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],