@aws-sdk/client-opensearch 3.460.0 → 3.462.0

package/dist-es/commands/ListDataSourcesCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListDataSourcesCommand, se_ListDataSourcesCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListDataSourcesCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListDataSourcesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchClient";
+        const commandName = "ListDataSourcesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AmazonOpenSearchService",
+                operation: "ListDataSources",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListDataSourcesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListDataSourcesCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateDataSourceCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_UpdateDataSourceCommand, se_UpdateDataSourceCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateDataSourceCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateDataSourceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchClient";
+        const commandName = "UpdateDataSourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AmazonOpenSearchService",
+                operation: "UpdateDataSource",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateDataSourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateDataSourceCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -1,4 +1,5 @@
 export * from "./AcceptInboundConnectionCommand";
+export * from "./AddDataSourceCommand";
 export * from "./AddTagsCommand";
 export * from "./AssociatePackageCommand";
 export * from "./AuthorizeVpcEndpointAccessCommand";
@@ -7,6 +8,7 @@ export * from "./CreateDomainCommand";
 export * from "./CreateOutboundConnectionCommand";
 export * from "./CreatePackageCommand";
 export * from "./CreateVpcEndpointCommand";
+export * from "./DeleteDataSourceCommand";
 export * from "./DeleteDomainCommand";
 export * from "./DeleteInboundConnectionCommand";
 export * from "./DeleteOutboundConnectionCommand";
@@ -29,10 +31,12 @@ export * from "./DescribeReservedInstancesCommand";
 export * from "./DescribeVpcEndpointsCommand";
 export * from "./DissociatePackageCommand";
 export * from "./GetCompatibleVersionsCommand";
+export * from "./GetDataSourceCommand";
 export * from "./GetDomainMaintenanceStatusCommand";
 export * from "./GetPackageVersionHistoryCommand";
 export * from "./GetUpgradeHistoryCommand";
 export * from "./GetUpgradeStatusCommand";
+export * from "./ListDataSourcesCommand";
 export * from "./ListDomainMaintenancesCommand";
 export * from "./ListDomainNamesCommand";
 export * from "./ListDomainsForPackageCommand";
@@ -50,6 +54,7 @@ export * from "./RemoveTagsCommand";
 export * from "./RevokeVpcEndpointAccessCommand";
 export * from "./StartDomainMaintenanceCommand";
 export * from "./StartServiceSoftwareUpdateCommand";
+export * from "./UpdateDataSourceCommand";
 export * from "./UpdateDomainConfigCommand";
 export * from "./UpdatePackageCommand";
 export * from "./UpdateScheduledActionCommand";

package/dist-es/models/models_0.js

@@ -85,6 +85,14 @@ export const ActionType = {
     JVM_YOUNG_GEN_TUNING: "JVM_YOUNG_GEN_TUNING",
     SERVICE_SOFTWARE_UPDATE: "SERVICE_SOFTWARE_UPDATE",
 };
+export var DataSourceType;
+(function (DataSourceType) {
+    DataSourceType.visit = (value, visitor) => {
+        if (value.S3GlueDataCatalog !== undefined)
+            return visitor.S3GlueDataCatalog(value.S3GlueDataCatalog);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(DataSourceType || (DataSourceType = {}));
 export class BaseException extends __BaseException {
     constructor(opts) {
         super({
@@ -97,6 +105,18 @@ export class BaseException extends __BaseException {
         Object.setPrototypeOf(this, BaseException.prototype);
     }
 }
+export class DependencyFailureException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "DependencyFailureException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "DependencyFailureException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, DependencyFailureException.prototype);
+    }
+}
 export class InternalException extends __BaseException {
     constructor(opts) {
         super({
@@ -396,18 +416,6 @@ export const MasterNodeStatus = {
     Available: "Available",
     UnAvailable: "UnAvailable",
 };
-export class DependencyFailureException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "DependencyFailureException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "DependencyFailureException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, DependencyFailureException.prototype);
-    }
-}
 export const NodeStatus = {
     Active: "Active",
     NotAvailable: "NotAvailable",

package/dist-es/protocols/Aws_restJson1.js

@@ -1,3 +1,4 @@
+import { awsExpectUnion as __expectUnion } from "@aws-sdk/core";
 import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
 import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
 import { AccessDeniedException, BaseException, ConflictException, DependencyFailureException, DisabledOperationException, InternalException, InvalidPaginationTokenException, InvalidTypeException, LimitExceededException, ResourceAlreadyExistsException, ResourceNotFoundException, SlotNotAvailableException, ValidationException, } from "../models/models_0";
@@ -19,6 +20,30 @@ export const se_AcceptInboundConnectionCommand = async (input, context) => {
         body,
     });
 };
+export const se_AddDataSourceCommand = 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 || ""}` +
+        "/2021-01-01/opensearch/domain/{DomainName}/dataSource";
+    resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        DataSourceType: (_) => _json(_),
+        Description: [],
+        Name: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_AddTagsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -209,6 +234,24 @@ export const se_CreateVpcEndpointCommand = async (input, context) => {
         body,
     });
 };
+export const se_DeleteDataSourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/2021-01-01/opensearch/domain/{DomainName}/dataSource/{Name}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_DeleteDomainCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -638,6 +681,24 @@ export const se_GetCompatibleVersionsCommand = async (input, context) => {
         body,
     });
 };
+export const se_GetDataSourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/2021-01-01/opensearch/domain/{DomainName}/dataSource/{Name}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_GetDomainMaintenanceStatusCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -719,6 +780,23 @@ export const se_GetUpgradeStatusCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListDataSourcesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/2021-01-01/opensearch/domain/{DomainName}/dataSource";
+    resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_ListDomainMaintenancesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -1080,6 +1158,30 @@ export const se_StartServiceSoftwareUpdateCommand = async (input, context) => {
         body,
     });
 };
+export const se_UpdateDataSourceCommand = 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 || ""}` +
+        "/2021-01-01/opensearch/domain/{DomainName}/dataSource/{Name}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        DataSourceType: (_) => _json(_),
+        Description: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_UpdateDomainConfigCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -1251,6 +1353,57 @@ const de_AcceptInboundConnectionCommandError = async (output, context) => {
             });
     }
 };
+export const de_AddDataSourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_AddDataSourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        Message: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_AddDataSourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BaseException":
+        case "com.amazonaws.opensearch#BaseException":
+            throw await de_BaseExceptionRes(parsedOutput, context);
+        case "DependencyFailureException":
+        case "com.amazonaws.opensearch#DependencyFailureException":
+            throw await de_DependencyFailureExceptionRes(parsedOutput, context);
+        case "DisabledOperationException":
+        case "com.amazonaws.opensearch#DisabledOperationException":
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
+        case "InternalException":
+        case "com.amazonaws.opensearch#InternalException":
+            throw await de_InternalExceptionRes(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.opensearch#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.opensearch#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.opensearch#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_AddTagsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_AddTagsCommandError(output, context);
@@ -1625,6 +1778,54 @@ const de_CreateVpcEndpointCommandError = async (output, context) => {
             });
     }
 };
+export const de_DeleteDataSourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteDataSourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        Message: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_DeleteDataSourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BaseException":
+        case "com.amazonaws.opensearch#BaseException":
+            throw await de_BaseExceptionRes(parsedOutput, context);
+        case "DependencyFailureException":
+        case "com.amazonaws.opensearch#DependencyFailureException":
+            throw await de_DependencyFailureExceptionRes(parsedOutput, context);
+        case "DisabledOperationException":
+        case "com.amazonaws.opensearch#DisabledOperationException":
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
+        case "InternalException":
+        case "com.amazonaws.opensearch#InternalException":
+            throw await de_InternalExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.opensearch#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.opensearch#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_DeleteDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_DeleteDomainCommandError(output, context);
@@ -2579,6 +2780,56 @@ const de_GetCompatibleVersionsCommandError = async (output, context) => {
             });
     }
 };
+export const de_GetDataSourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetDataSourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        DataSourceType: (_) => _json(__expectUnion(_)),
+        Description: __expectString,
+        Name: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetDataSourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BaseException":
+        case "com.amazonaws.opensearch#BaseException":
+            throw await de_BaseExceptionRes(parsedOutput, context);
+        case "DependencyFailureException":
+        case "com.amazonaws.opensearch#DependencyFailureException":
+            throw await de_DependencyFailureExceptionRes(parsedOutput, context);
+        case "DisabledOperationException":
+        case "com.amazonaws.opensearch#DisabledOperationException":
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
+        case "InternalException":
+        case "com.amazonaws.opensearch#InternalException":
+            throw await de_InternalExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.opensearch#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.opensearch#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_GetDomainMaintenanceStatusCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_GetDomainMaintenanceStatusCommandError(output, context);
@@ -2769,6 +3020,54 @@ const de_GetUpgradeStatusCommandError = async (output, context) => {
             });
     }
 };
+export const de_ListDataSourcesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListDataSourcesCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        DataSources: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListDataSourcesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BaseException":
+        case "com.amazonaws.opensearch#BaseException":
+            throw await de_BaseExceptionRes(parsedOutput, context);
+        case "DependencyFailureException":
+        case "com.amazonaws.opensearch#DependencyFailureException":
+            throw await de_DependencyFailureExceptionRes(parsedOutput, context);
+        case "DisabledOperationException":
+        case "com.amazonaws.opensearch#DisabledOperationException":
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
+        case "InternalException":
+        case "com.amazonaws.opensearch#InternalException":
+            throw await de_InternalExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.opensearch#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.opensearch#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListDomainMaintenancesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListDomainMaintenancesCommandError(output, context);
@@ -3491,6 +3790,54 @@ const de_StartServiceSoftwareUpdateCommandError = async (output, context) => {
             });
     }
 };
+export const de_UpdateDataSourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_UpdateDataSourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        Message: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateDataSourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BaseException":
+        case "com.amazonaws.opensearch#BaseException":
+            throw await de_BaseExceptionRes(parsedOutput, context);
+        case "DependencyFailureException":
+        case "com.amazonaws.opensearch#DependencyFailureException":
+            throw await de_DependencyFailureExceptionRes(parsedOutput, context);
+        case "DisabledOperationException":
+        case "com.amazonaws.opensearch#DisabledOperationException":
+            throw await de_DisabledOperationExceptionRes(parsedOutput, context);
+        case "InternalException":
+        case "com.amazonaws.opensearch#InternalException":
+            throw await de_InternalExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.opensearch#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.opensearch#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_UpdateDomainConfigCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_UpdateDomainConfigCommandError(output, context);