@aws-sdk/client-backupsearch 3.928.0 → 3.930.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -89,6 +88,7 @@ class BackupSearchClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -108,14 +108,14 @@ class BackupSearchClient extends smithyClient.Client {
     }
 }
 
-class BackupSearchServiceException extends smithyClient.ServiceException {
+let BackupSearchServiceException$1 = class BackupSearchServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, BackupSearchServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends BackupSearchServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends BackupSearchServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -126,8 +126,8 @@ class AccessDeniedException extends BackupSearchServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
-class ConflictException extends BackupSearchServiceException {
+};
+let ConflictException$1 = class ConflictException extends BackupSearchServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     resourceId;
@@ -142,8 +142,8 @@ class ConflictException extends BackupSearchServiceException {
         this.resourceId = opts.resourceId;
         this.resourceType = opts.resourceType;
     }
-}
-class InternalServerException extends BackupSearchServiceException {
+};
+let InternalServerException$1 = class InternalServerException extends BackupSearchServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     $retryable = {};
@@ -157,7 +157,7 @@ class InternalServerException extends BackupSearchServiceException {
         Object.setPrototypeOf(this, InternalServerException.prototype);
         this.retryAfterSeconds = opts.retryAfterSeconds;
     }
-}
+};
 const ResourceType = {
     EBS: "EBS",
     S3: "S3",
@@ -169,7 +169,7 @@ const SearchJobState = {
     STOPPED: "STOPPED",
     STOPPING: "STOPPING",
 };
-class ResourceNotFoundException extends BackupSearchServiceException {
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends BackupSearchServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     resourceId;
@@ -184,8 +184,8 @@ class ResourceNotFoundException extends BackupSearchServiceException {
         this.resourceId = opts.resourceId;
         this.resourceType = opts.resourceType;
     }
-}
-class ThrottlingException extends BackupSearchServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends BackupSearchServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     $retryable = {
@@ -205,8 +205,8 @@ class ThrottlingException extends BackupSearchServiceException {
         this.quotaCode = opts.quotaCode;
         this.retryAfterSeconds = opts.retryAfterSeconds;
     }
-}
-class ValidationException extends BackupSearchServiceException {
+};
+let ValidationException$1 = class ValidationException extends BackupSearchServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     constructor(opts) {
@@ -217,17 +217,7 @@ class ValidationException extends BackupSearchServiceException {
         });
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
-}
-exports.ResultItem = void 0;
-(function (ResultItem) {
-    ResultItem.visit = (value, visitor) => {
-        if (value.S3ResultItem !== undefined)
-            return visitor.S3ResultItem(value.S3ResultItem);
-        if (value.EBSResultItem !== undefined)
-            return visitor.EBSResultItem(value.EBSResultItem);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(exports.ResultItem || (exports.ResultItem = {}));
+};
 const TimeConditionOperator = {
     EQUALS_TO: "EQUALS_TO",
     GREATER_THAN_EQUAL_TO: "GREATER_THAN_EQUAL_TO",
@@ -250,7 +240,7 @@ const LongConditionOperator = {
     LESS_THAN_EQUAL_TO: "LESS_THAN_EQUAL_TO",
     NOT_EQUALS_TO: "NOT_EQUALS_TO",
 };
-class ServiceQuotaExceededException extends BackupSearchServiceException {
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends BackupSearchServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     resourceId;
@@ -269,803 +259,717 @@ class ServiceQuotaExceededException extends BackupSearchServiceException {
         this.serviceCode = opts.serviceCode;
         this.quotaCode = opts.quotaCode;
     }
-}
+};
 const ExportJobStatus = {
     COMPLETED: "COMPLETED",
     FAILED: "FAILED",
     RUNNING: "RUNNING",
 };
-exports.ExportSpecification = void 0;
-(function (ExportSpecification) {
-    ExportSpecification.visit = (value, visitor) => {
-        if (value.s3ExportSpecification !== undefined)
-            return visitor.s3ExportSpecification(value.s3ExportSpecification);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(exports.ExportSpecification || (exports.ExportSpecification = {}));
-const EBSResultItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.FilePath && { FilePath: smithyClient.SENSITIVE_STRING }),
-});
-const S3ResultItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ObjectKey && { ObjectKey: smithyClient.SENSITIVE_STRING }),
-});
-const ResultItemFilterSensitiveLog = (obj) => {
-    if (obj.S3ResultItem !== undefined)
-        return { S3ResultItem: S3ResultItemFilterSensitiveLog(obj.S3ResultItem) };
-    if (obj.EBSResultItem !== undefined)
-        return { EBSResultItem: EBSResultItemFilterSensitiveLog(obj.EBSResultItem) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const ListSearchJobResultsOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Results && { Results: obj.Results.map((item) => ResultItemFilterSensitiveLog(item)) }),
-});
 
-const se_GetSearchJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/search-jobs/{SearchJobIdentifier}");
-    b.p("SearchJobIdentifier", () => input.SearchJobIdentifier, "{SearchJobIdentifier}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetSearchResultExportJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/export-search-jobs/{ExportJobIdentifier}");
-    b.p("ExportJobIdentifier", () => input.ExportJobIdentifier, "{ExportJobIdentifier}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_ListSearchJobBackupsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/search-jobs/{SearchJobIdentifier}/backups");
-    b.p("SearchJobIdentifier", () => input.SearchJobIdentifier, "{SearchJobIdentifier}", false);
-    const query = smithyClient.map({
-        [_nT]: [, input[_NT]],
-        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListSearchJobResultsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/search-jobs/{SearchJobIdentifier}/search-results");
-    b.p("SearchJobIdentifier", () => input.SearchJobIdentifier, "{SearchJobIdentifier}", false);
-    const query = smithyClient.map({
-        [_nT]: [, input[_NT]],
-        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListSearchJobsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/search-jobs");
-    const query = smithyClient.map({
-        [_S]: [, input[_BS]],
-        [_NT]: [, input[_NT]],
-        [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListSearchResultExportJobsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/export-search-jobs");
-    const query = smithyClient.map({
-        [_S]: [, input[_S]],
-        [_SJI]: [, input[_SJI]],
-        [_NT]: [, input[_NT]],
-        [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{ResourceArn}");
-    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_StartSearchJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/search-jobs");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ClientToken: [],
-        EncryptionKeyArn: [],
-        ItemFilters: (_) => se_ItemFilters(_),
-        Name: [],
-        SearchScope: (_) => se_SearchScope(_),
-        Tags: (_) => se_TagMap(_),
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_StartSearchResultExportJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/export-search-jobs");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ClientToken: [],
-        ExportSpecification: (_) => smithyClient._json(_),
-        RoleArn: [],
-        SearchJobIdentifier: [],
-        Tags: (_) => se_TagMap(_),
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_StopSearchJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/search-jobs/{SearchJobIdentifier}/actions/cancel");
-    b.p("SearchJobIdentifier", () => input.SearchJobIdentifier, "{SearchJobIdentifier}", false);
-    let body;
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/tags/{ResourceArn}");
-    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Tags: (_) => se_TagMap(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{ResourceArn}");
-    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.TagKeys, `TagKeys`) != null, () => input[_TK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const de_GetSearchJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        CompletionTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CurrentSearchProgress: smithyClient._json,
-        EncryptionKeyArn: smithyClient.expectString,
-        ItemFilters: (_) => de_ItemFilters(_),
-        Name: smithyClient.expectString,
-        SearchJobArn: smithyClient.expectString,
-        SearchJobIdentifier: smithyClient.expectString,
-        SearchScope: (_) => de_SearchScope(_),
-        SearchScopeSummary: smithyClient._json,
-        Status: smithyClient.expectString,
-        StatusMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetSearchResultExportJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        CompletionTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ExportJobArn: smithyClient.expectString,
-        ExportJobIdentifier: smithyClient.expectString,
-        ExportSpecification: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
-        SearchJobArn: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        StatusMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListSearchJobBackupsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        Results: (_) => de_SearchJobBackupsResults(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListSearchJobResultsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        Results: (_) => de_Results(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListSearchJobsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        SearchJobs: (_) => de_SearchJobs(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListSearchResultExportJobsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        ExportJobs: (_) => de_ExportJobSummaries(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Tags: (_) => de_TagMap(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartSearchJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        SearchJobArn: smithyClient.expectString,
-        SearchJobIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartSearchResultExportJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        ExportJobArn: smithyClient.expectString,
-        ExportJobIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StopSearchJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.backupsearch#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.backupsearch#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.backupsearch#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.backupsearch#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.backupsearch#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.backupsearch#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.backupsearch#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(BackupSearchServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        resourceId: smithyClient.expectString,
-        resourceType: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({
-        [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => smithyClient.strictParseInt32(parsedOutput.headers[_ra])],
-    });
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        resourceId: smithyClient.expectString,
-        resourceType: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        quotaCode: smithyClient.expectString,
-        resourceId: smithyClient.expectString,
-        resourceType: smithyClient.expectString,
-        serviceCode: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({
-        [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => smithyClient.strictParseInt32(parsedOutput.headers[_ra])],
-    });
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        quotaCode: smithyClient.expectString,
-        serviceCode: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_BackupCreationTimeFilter = (input, context) => {
-    return smithyClient.take(input, {
-        CreatedAfter: (_) => _.getTime() / 1_000,
-        CreatedBefore: (_) => _.getTime() / 1_000,
-    });
-};
-const se_EBSItemFilter = (input, context) => {
-    return smithyClient.take(input, {
-        CreationTimes: (_) => se_TimeConditionList(_),
-        FilePaths: smithyClient._json,
-        LastModificationTimes: (_) => se_TimeConditionList(_),
-        Sizes: smithyClient._json,
-    });
-};
-const se_EBSItemFilters = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_EBSItemFilter(entry);
-    });
-};
-const se_ItemFilters = (input, context) => {
-    return smithyClient.take(input, {
-        EBSItemFilters: (_) => se_EBSItemFilters(_),
-        S3ItemFilters: (_) => se_S3ItemFilters(_),
-    });
-};
-const se_S3ItemFilter = (input, context) => {
-    return smithyClient.take(input, {
-        CreationTimes: (_) => se_TimeConditionList(_),
-        ETags: smithyClient._json,
-        ObjectKeys: smithyClient._json,
-        Sizes: smithyClient._json,
-        VersionIds: smithyClient._json,
-    });
-};
-const se_S3ItemFilters = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_S3ItemFilter(entry);
-    });
-};
-const se_SearchScope = (input, context) => {
-    return smithyClient.take(input, {
-        BackupResourceArns: smithyClient._json,
-        BackupResourceCreationTime: (_) => se_BackupCreationTimeFilter(_),
-        BackupResourceTags: (_) => se_TagMap(_),
-        BackupResourceTypes: smithyClient._json,
-        SourceResourceArns: smithyClient._json,
-    });
-};
-const se_TagMap = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
-        if (value === null) {
-            acc[key] = null;
-            return acc;
-        }
-        acc[key] = value;
-        return acc;
-    }, {});
-};
-const se_TimeCondition = (input, context) => {
-    return smithyClient.take(input, {
-        Operator: [],
-        Value: (_) => _.getTime() / 1_000,
-    });
-};
-const se_TimeConditionList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_TimeCondition(entry);
-    });
-};
-const de_BackupCreationTimeFilter = (output, context) => {
-    return smithyClient.take(output, {
-        CreatedAfter: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreatedBefore: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_EBSItemFilter = (output, context) => {
-    return smithyClient.take(output, {
-        CreationTimes: (_) => de_TimeConditionList(_),
-        FilePaths: smithyClient._json,
-        LastModificationTimes: (_) => de_TimeConditionList(_),
-        Sizes: smithyClient._json,
-    });
-};
-const de_EBSItemFilters = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_EBSItemFilter(entry);
-    });
-    return retVal;
-};
-const de_EBSResultItem = (output, context) => {
-    return smithyClient.take(output, {
-        BackupResourceArn: smithyClient.expectString,
-        BackupVaultName: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        FilePath: smithyClient.expectString,
-        FileSize: smithyClient.expectLong,
-        FileSystemIdentifier: smithyClient.expectString,
-        LastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        SourceResourceArn: smithyClient.expectString,
-    });
-};
-const de_ExportJobSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ExportJobSummary(entry);
-    });
-    return retVal;
-};
-const de_ExportJobSummary = (output, context) => {
-    return smithyClient.take(output, {
-        CompletionTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ExportJobArn: smithyClient.expectString,
-        ExportJobIdentifier: smithyClient.expectString,
-        SearchJobArn: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        StatusMessage: smithyClient.expectString,
-    });
-};
-const de_ItemFilters = (output, context) => {
-    return smithyClient.take(output, {
-        EBSItemFilters: (_) => de_EBSItemFilters(_),
-        S3ItemFilters: (_) => de_S3ItemFilters(_),
-    });
-};
-const de_ResultItem = (output, context) => {
-    if (output.EBSResultItem != null) {
-        return {
-            EBSResultItem: de_EBSResultItem(output.EBSResultItem),
-        };
-    }
-    if (output.S3ResultItem != null) {
-        return {
-            S3ResultItem: de_S3ResultItem(output.S3ResultItem),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_Results = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ResultItem(core$1.awsExpectUnion(entry));
-    });
-    return retVal;
-};
-const de_S3ItemFilter = (output, context) => {
-    return smithyClient.take(output, {
-        CreationTimes: (_) => de_TimeConditionList(_),
-        ETags: smithyClient._json,
-        ObjectKeys: smithyClient._json,
-        Sizes: smithyClient._json,
-        VersionIds: smithyClient._json,
-    });
-};
-const de_S3ItemFilters = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_S3ItemFilter(entry);
-    });
-    return retVal;
-};
-const de_S3ResultItem = (output, context) => {
-    return smithyClient.take(output, {
-        BackupResourceArn: smithyClient.expectString,
-        BackupVaultName: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ETag: smithyClient.expectString,
-        ObjectKey: smithyClient.expectString,
-        ObjectSize: smithyClient.expectLong,
-        SourceResourceArn: smithyClient.expectString,
-        VersionId: smithyClient.expectString,
-    });
-};
-const de_SearchJobBackupsResult = (output, context) => {
-    return smithyClient.take(output, {
-        BackupCreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        BackupResourceArn: smithyClient.expectString,
-        IndexCreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ResourceType: smithyClient.expectString,
-        SourceResourceArn: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        StatusMessage: smithyClient.expectString,
-    });
-};
-const de_SearchJobBackupsResults = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SearchJobBackupsResult(entry);
-    });
-    return retVal;
-};
-const de_SearchJobs = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SearchJobSummary(entry);
-    });
-    return retVal;
-};
-const de_SearchJobSummary = (output, context) => {
-    return smithyClient.take(output, {
-        CompletionTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Name: smithyClient.expectString,
-        SearchJobArn: smithyClient.expectString,
-        SearchJobIdentifier: smithyClient.expectString,
-        SearchScopeSummary: smithyClient._json,
-        Status: smithyClient.expectString,
-        StatusMessage: smithyClient.expectString,
-    });
-};
-const de_SearchScope = (output, context) => {
-    return smithyClient.take(output, {
-        BackupResourceArns: smithyClient._json,
-        BackupResourceCreationTime: (_) => de_BackupCreationTimeFilter(_),
-        BackupResourceTags: (_) => de_TagMap(_),
-        BackupResourceTypes: smithyClient._json,
-        SourceResourceArns: smithyClient._json,
-    });
-};
-const de_TagMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            acc[key] = null;
-            return acc;
-        }
-        acc[key] = smithyClient.expectString(value);
-        return acc;
-    }, {});
-};
-const de_TimeCondition = (output, context) => {
-    return smithyClient.take(output, {
-        Operator: smithyClient.expectString,
-        Value: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_TimeConditionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_TimeCondition(entry);
-    });
-    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 _ADE = "AccessDeniedException";
+const _BCT = "BackupCreationTime";
+const _BCTF = "BackupCreationTimeFilter";
+const _BRA = "BackupResourceArn";
+const _BRAa = "BackupResourceArns";
+const _BRCT = "BackupResourceCreationTime";
+const _BRT = "BackupResourceTypes";
+const _BRTa = "BackupResourceTags";
 const _BS = "ByStatus";
+const _BVN = "BackupVaultName";
+const _CA = "CreatedAfter";
+const _CB = "CreatedBefore";
+const _CE = "ConflictException";
+const _CSP = "CurrentSearchProgress";
+const _CT = "CreationTimes";
+const _CTl = "ClientToken";
+const _CTo = "CompletionTime";
+const _CTr = "CreationTime";
+const _DB = "DestinationBucket";
+const _DP = "DestinationPrefix";
+const _EBSIF = "EBSItemFilter";
+const _EBSIFt = "EBSItemFilters";
+const _EBSRI = "EBSResultItem";
+const _EJ = "ExportJobs";
+const _EJA = "ExportJobArn";
+const _EJI = "ExportJobIdentifier";
+const _EJS = "ExportJobSummary";
+const _EJSx = "ExportJobSummaries";
+const _EKA = "EncryptionKeyArn";
+const _ES = "ExportSpecification";
+const _ET = "ETags";
+const _ETa = "ETag";
+const _FP = "FilePath";
+const _FPi = "FilePaths";
+const _FS = "FileSize";
+const _FSI = "FileSystemIdentifier";
+const _GSJ = "GetSearchJob";
+const _GSJI = "GetSearchJobInput";
+const _GSJO = "GetSearchJobOutput";
+const _GSREJ = "GetSearchResultExportJob";
+const _GSREJI = "GetSearchResultExportJobInput";
+const _GSREJO = "GetSearchResultExportJobOutput";
+const _ICT = "IndexCreationTime";
+const _IF = "ItemFilters";
+const _IMC = "ItemsMatchedCount";
+const _ISC = "ItemsScannedCount";
+const _ISE = "InternalServerException";
+const _LC = "LongCondition";
+const _LCL = "LongConditionList";
+const _LMT = "LastModificationTimes";
+const _LMTa = "LastModifiedTime";
+const _LSJ = "ListSearchJobs";
+const _LSJB = "ListSearchJobBackups";
+const _LSJBI = "ListSearchJobBackupsInput";
+const _LSJBO = "ListSearchJobBackupsOutput";
+const _LSJI = "ListSearchJobsInput";
+const _LSJO = "ListSearchJobsOutput";
+const _LSJR = "ListSearchJobResults";
+const _LSJRI = "ListSearchJobResultsInput";
+const _LSJRO = "ListSearchJobResultsOutput";
+const _LSREJ = "ListSearchResultExportJobs";
+const _LSREJI = "ListSearchResultExportJobsInput";
+const _LSREJO = "ListSearchResultExportJobsOutput";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
 const _MR = "MaxResults";
+const _N = "Name";
 const _NT = "NextToken";
-const _S = "Status";
+const _O = "Operator";
+const _OK = "ObjectKey";
+const _OKb = "ObjectKeys";
+const _OS = "ObjectSize";
+const _R = "Results";
+const _RA = "Retry-After";
+const _RAe = "ResourceArn";
+const _RAo = "RoleArn";
+const _RI = "ResultItem";
+const _RNFE = "ResourceNotFoundException";
+const _RPSC = "RecoveryPointsScannedCount";
+const _RT = "ResourceType";
+const _S = "Sizes";
+const _SC = "StringCondition";
+const _SCL = "StringConditionList";
+const _SES = "S3ExportSpecification";
+const _SIF = "S3ItemFilters";
+const _SIFt = "S3ItemFilter";
+const _SJ = "SearchJobs";
+const _SJA = "SearchJobArn";
+const _SJBR = "SearchJobBackupsResult";
+const _SJBRe = "SearchJobBackupsResults";
 const _SJI = "SearchJobIdentifier";
+const _SJS = "SearchJobSummary";
+const _SM = "StatusMessage";
+const _SQEE = "ServiceQuotaExceededException";
+const _SRA = "SourceResourceArn";
+const _SRAo = "SourceResourceArns";
+const _SRI = "S3ResultItem";
+const _SS = "SearchScope";
+const _SSJ = "StartSearchJob";
+const _SSJI = "StartSearchJobInput";
+const _SSJIt = "StopSearchJobInput";
+const _SSJO = "StartSearchJobOutput";
+const _SSJOt = "StopSearchJobOutput";
+const _SSJt = "StopSearchJob";
+const _SSREJ = "StartSearchResultExportJob";
+const _SSREJI = "StartSearchResultExportJobInput";
+const _SSREJO = "StartSearchResultExportJobOutput";
+const _SSS = "SearchScopeSummary";
+const _St = "Status";
+const _T = "Tags";
+const _TC = "TimeCondition";
+const _TCL = "TimeConditionList";
+const _TE = "ThrottlingException";
+const _TITSC = "TotalItemsToScanCount";
 const _TK = "TagKeys";
+const _TM = "TagMap";
+const _TR = "TagResource";
+const _TRPTSC = "TotalRecoveryPointsToScanCount";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _V = "Value";
+const _VE = "ValidationException";
+const _VI = "VersionIds";
+const _VIe = "VersionId";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
+const _m = "message";
 const _mR = "maxResults";
 const _nT = "nextToken";
+const _qC = "quotaCode";
 const _rAS = "retryAfterSeconds";
-const _ra = "retry-after";
+const _rI = "resourceId";
+const _rT = "resourceType";
+const _s = "server";
+const _sC = "serviceCode";
+const _sES = "s3ExportSpecification";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.backupsearch";
+const _sp = "sparse";
 const _tK = "tagKeys";
+const n0 = "com.amazonaws.backupsearch";
+var FilePath = [0, n0, _FP, 8, 0];
+var ObjectKey = [0, n0, _OK, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var BackupCreationTimeFilter = [3, n0, _BCTF, 0, [_CA, _CB], [4, 4]];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m, _rI, _rT],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CurrentSearchProgress = [3, n0, _CSP, 0, [_RPSC, _ISC, _IMC], [1, 1, 1]];
+var EBSItemFilter = [
+    3,
+    n0,
+    _EBSIF,
+    0,
+    [_FPi, _S, _CT, _LMT],
+    [() => StringConditionList, () => LongConditionList, () => TimeConditionList, () => TimeConditionList],
+];
+var EBSResultItem = [
+    3,
+    n0,
+    _EBSRI,
+    0,
+    [_BRA, _SRA, _BVN, _FSI, _FP, _FS, _CTr, _LMTa],
+    [0, 0, 0, 0, [() => FilePath, 0], 1, 4, 4],
+];
+var ExportJobSummary = [
+    3,
+    n0,
+    _EJS,
+    0,
+    [_EJI, _EJA, _St, _CTr, _CTo, _SM, _SJA],
+    [0, 0, 0, 4, 4, 0, 0],
+];
+var GetSearchJobInput = [3, n0, _GSJI, 0, [_SJI], [[0, 1]]];
+var GetSearchJobOutput = [
+    3,
+    n0,
+    _GSJO,
+    0,
+    [_N, _SSS, _CSP, _SM, _EKA, _CTo, _St, _SS, _IF, _CTr, _SJI, _SJA],
+    [
+        0,
+        () => SearchScopeSummary,
+        () => CurrentSearchProgress,
+        0,
+        0,
+        4,
+        0,
+        [() => SearchScope, 0],
+        () => ItemFilters,
+        4,
+        0,
+        0,
+    ],
+];
+var GetSearchResultExportJobInput = [3, n0, _GSREJI, 0, [_EJI], [[0, 1]]];
+var GetSearchResultExportJobOutput = [
+    3,
+    n0,
+    _GSREJO,
+    0,
+    [_EJI, _EJA, _St, _CTr, _CTo, _SM, _ES, _SJA],
+    [0, 0, 0, 4, 4, 0, () => ExportSpecification, 0],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_m, _rAS],
+    [
+        0,
+        [
+            1,
+            {
+                [_hH]: _RA,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ItemFilters = [
+    3,
+    n0,
+    _IF,
+    0,
+    [_SIF, _EBSIFt],
+    [() => S3ItemFilters, () => EBSItemFilters],
+];
+var ListSearchJobBackupsInput = [
+    3,
+    n0,
+    _LSJBI,
+    0,
+    [_SJI, _NT, _MR],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListSearchJobBackupsOutput = [
+    3,
+    n0,
+    _LSJBO,
+    0,
+    [_R, _NT],
+    [() => SearchJobBackupsResults, 0],
+];
+var ListSearchJobResultsInput = [
+    3,
+    n0,
+    _LSJRI,
+    0,
+    [_SJI, _NT, _MR],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListSearchJobResultsOutput = [3, n0, _LSJRO, 0, [_R, _NT], [[() => Results, 0], 0]];
+var ListSearchJobsInput = [
+    3,
+    n0,
+    _LSJI,
+    0,
+    [_BS, _NT, _MR],
+    [
+        [
+            0,
+            {
+                [_hQ]: _St,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _NT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _MR,
+            },
+        ],
+    ],
+];
+var ListSearchJobsOutput = [3, n0, _LSJO, 0, [_SJ, _NT], [() => SearchJobs, 0]];
+var ListSearchResultExportJobsInput = [
+    3,
+    n0,
+    _LSREJI,
+    0,
+    [_St, _SJI, _NT, _MR],
+    [
+        [
+            0,
+            {
+                [_hQ]: _St,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _SJI,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _NT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _MR,
+            },
+        ],
+    ],
+];
+var ListSearchResultExportJobsOutput = [
+    3,
+    n0,
+    _LSREJO,
+    0,
+    [_EJ, _NT],
+    [() => ExportJobSummaries, 0],
+];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_RAe], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_T], [[() => TagMap, 0]]];
+var LongCondition = [3, n0, _LC, 0, [_V, _O], [1, 0]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m, _rI, _rT],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var S3ExportSpecification = [3, n0, _SES, 0, [_DB, _DP], [0, 0]];
+var S3ItemFilter = [
+    3,
+    n0,
+    _SIFt,
+    0,
+    [_OKb, _S, _CT, _VI, _ET],
+    [
+        () => StringConditionList,
+        () => LongConditionList,
+        () => TimeConditionList,
+        () => StringConditionList,
+        () => StringConditionList,
+    ],
+];
+var S3ResultItem = [
+    3,
+    n0,
+    _SRI,
+    0,
+    [_BRA, _SRA, _BVN, _OK, _OS, _CTr, _ETa, _VIe],
+    [0, 0, 0, [() => ObjectKey, 0], 1, 4, 0, 0],
+];
+var SearchJobBackupsResult = [
+    3,
+    n0,
+    _SJBR,
+    0,
+    [_St, _SM, _RT, _BRA, _SRA, _ICT, _BCT],
+    [0, 0, 0, 0, 0, 4, 4],
+];
+var SearchJobSummary = [
+    3,
+    n0,
+    _SJS,
+    0,
+    [_SJI, _SJA, _N, _St, _CTr, _CTo, _SSS, _SM],
+    [0, 0, 0, 0, 4, 4, () => SearchScopeSummary, 0],
+];
+var SearchScope = [
+    3,
+    n0,
+    _SS,
+    0,
+    [_BRT, _BRCT, _SRAo, _BRAa, _BRTa],
+    [64 | 0, () => BackupCreationTimeFilter, 64 | 0, 64 | 0, [() => TagMap, 0]],
+];
+var SearchScopeSummary = [3, n0, _SSS, 0, [_TRPTSC, _TITSC], [1, 1]];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_m, _rI, _rT, _sC, _qC],
+    [0, 0, 0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var StartSearchJobInput = [
+    3,
+    n0,
+    _SSJI,
+    0,
+    [_T, _N, _EKA, _CTl, _SS, _IF],
+    [[() => TagMap, 0], 0, 0, 0, [() => SearchScope, 0], () => ItemFilters],
+];
+var StartSearchJobOutput = [3, n0, _SSJO, 0, [_SJA, _CTr, _SJI], [0, 4, 0]];
+var StartSearchResultExportJobInput = [
+    3,
+    n0,
+    _SSREJI,
+    0,
+    [_SJI, _ES, _CTl, _T, _RAo],
+    [0, () => ExportSpecification, 0, [() => TagMap, 0], 0],
+];
+var StartSearchResultExportJobOutput = [3, n0, _SSREJO, 0, [_EJA, _EJI], [0, 0]];
+var StopSearchJobInput = [3, n0, _SSJIt, 0, [_SJI], [[0, 1]]];
+var StopSearchJobOutput = [3, n0, _SSJOt, 0, [], []];
+var StringCondition = [3, n0, _SC, 0, [_V, _O], [0, 0]];
+var TagResourceRequest = [
+    3,
+    n0,
+    _TRR,
+    0,
+    [_RAe, _T],
+    [
+        [0, 1],
+        [() => TagMap, 0],
+    ],
+];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m, _sC, _qC, _rAS],
+    [
+        0,
+        0,
+        0,
+        [
+            1,
+            {
+                [_hH]: _RA,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var TimeCondition = [3, n0, _TC, 0, [_V, _O], [4, 0]];
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_RAe, _TK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var BackupSearchServiceException = [-3, _sm, "BackupSearchServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(BackupSearchServiceException, BackupSearchServiceException$1);
+var EBSItemFilters = [1, n0, _EBSIFt, 0, () => EBSItemFilter];
+var ExportJobSummaries = [1, n0, _EJSx, 0, () => ExportJobSummary];
+var LongConditionList = [1, n0, _LCL, 0, () => LongCondition];
+var Results = [1, n0, _R, 0, [() => ResultItem, 0]];
+var S3ItemFilters = [1, n0, _SIF, 0, () => S3ItemFilter];
+var SearchJobBackupsResults = [1, n0, _SJBRe, 0, () => SearchJobBackupsResult];
+var SearchJobs = [1, n0, _SJ, 0, () => SearchJobSummary];
+var StringConditionList = [1, n0, _SCL, 0, () => StringCondition];
+var TimeConditionList = [1, n0, _TCL, 0, () => TimeCondition];
+var TagMap = [
+    2,
+    n0,
+    _TM,
+    {
+        [_sp]: 1,
+    },
+    0,
+    0,
+];
+var ExportSpecification = [3, n0, _ES, 0, [_sES], [() => S3ExportSpecification]];
+var ResultItem = [
+    3,
+    n0,
+    _RI,
+    0,
+    [_SRI, _EBSRI],
+    [
+        [() => S3ResultItem, 0],
+        [() => EBSResultItem, 0],
+    ],
+];
+var GetSearchJob = [
+    9,
+    n0,
+    _GSJ,
+    {
+        [_h]: ["GET", "/search-jobs/{SearchJobIdentifier}", 200],
+    },
+    () => GetSearchJobInput,
+    () => GetSearchJobOutput,
+];
+var GetSearchResultExportJob = [
+    9,
+    n0,
+    _GSREJ,
+    {
+        [_h]: ["GET", "/export-search-jobs/{ExportJobIdentifier}", 200],
+    },
+    () => GetSearchResultExportJobInput,
+    () => GetSearchResultExportJobOutput,
+];
+var ListSearchJobBackups = [
+    9,
+    n0,
+    _LSJB,
+    {
+        [_h]: ["GET", "/search-jobs/{SearchJobIdentifier}/backups", 200],
+    },
+    () => ListSearchJobBackupsInput,
+    () => ListSearchJobBackupsOutput,
+];
+var ListSearchJobResults = [
+    9,
+    n0,
+    _LSJR,
+    {
+        [_h]: ["GET", "/search-jobs/{SearchJobIdentifier}/search-results", 200],
+    },
+    () => ListSearchJobResultsInput,
+    () => ListSearchJobResultsOutput,
+];
+var ListSearchJobs = [
+    9,
+    n0,
+    _LSJ,
+    {
+        [_h]: ["GET", "/search-jobs", 200],
+    },
+    () => ListSearchJobsInput,
+    () => ListSearchJobsOutput,
+];
+var ListSearchResultExportJobs = [
+    9,
+    n0,
+    _LSREJ,
+    {
+        [_h]: ["GET", "/export-search-jobs", 200],
+    },
+    () => ListSearchResultExportJobsInput,
+    () => ListSearchResultExportJobsOutput,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags/{ResourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var StartSearchJob = [
+    9,
+    n0,
+    _SSJ,
+    {
+        [_h]: ["PUT", "/search-jobs", 200],
+    },
+    () => StartSearchJobInput,
+    () => StartSearchJobOutput,
+];
+var StartSearchResultExportJob = [
+    9,
+    n0,
+    _SSREJ,
+    {
+        [_h]: ["PUT", "/export-search-jobs", 200],
+    },
+    () => StartSearchResultExportJobInput,
+    () => StartSearchResultExportJobOutput,
+];
+var StopSearchJob = [
+    9,
+    n0,
+    _SSJt,
+    {
+        [_h]: ["PUT", "/search-jobs/{SearchJobIdentifier}/actions/cancel", 200],
+    },
+    () => StopSearchJobInput,
+    () => StopSearchJobOutput,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/tags/{ResourceArn}", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/tags/{ResourceArn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
 
 class GetSearchJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CryoBackupSearchService", "GetSearchJob", {})
     .n("BackupSearchClient", "GetSearchJobCommand")
-    .f(void 0, void 0)
-    .ser(se_GetSearchJobCommand)
-    .de(de_GetSearchJobCommand)
+    .sc(GetSearchJob)
     .build() {
 }
 
@@ -1073,16 +977,11 @@ class GetSearchResultExportJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CryoBackupSearchService", "GetSearchResultExportJob", {})
     .n("BackupSearchClient", "GetSearchResultExportJobCommand")
-    .f(void 0, void 0)
-    .ser(se_GetSearchResultExportJobCommand)
-    .de(de_GetSearchResultExportJobCommand)
+    .sc(GetSearchResultExportJob)
     .build() {
 }
 
@@ -1090,16 +989,11 @@ class ListSearchJobBackupsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CryoBackupSearchService", "ListSearchJobBackups", {})
     .n("BackupSearchClient", "ListSearchJobBackupsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListSearchJobBackupsCommand)
-    .de(de_ListSearchJobBackupsCommand)
+    .sc(ListSearchJobBackups)
     .build() {
 }
 
@@ -1107,16 +1001,11 @@ class ListSearchJobResultsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CryoBackupSearchService", "ListSearchJobResults", {})
     .n("BackupSearchClient", "ListSearchJobResultsCommand")
-    .f(void 0, ListSearchJobResultsOutputFilterSensitiveLog)
-    .ser(se_ListSearchJobResultsCommand)
-    .de(de_ListSearchJobResultsCommand)
+    .sc(ListSearchJobResults)
     .build() {
 }
 
@@ -1124,16 +1013,11 @@ class ListSearchJobsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CryoBackupSearchService", "ListSearchJobs", {})
     .n("BackupSearchClient", "ListSearchJobsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListSearchJobsCommand)
-    .de(de_ListSearchJobsCommand)
+    .sc(ListSearchJobs)
     .build() {
 }
 
@@ -1141,16 +1025,11 @@ class ListSearchResultExportJobsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CryoBackupSearchService", "ListSearchResultExportJobs", {})
     .n("BackupSearchClient", "ListSearchResultExportJobsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListSearchResultExportJobsCommand)
-    .de(de_ListSearchResultExportJobsCommand)
+    .sc(ListSearchResultExportJobs)
     .build() {
 }
 
@@ -1158,16 +1037,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CryoBackupSearchService", "ListTagsForResource", {})
     .n("BackupSearchClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1175,16 +1049,11 @@ class StartSearchJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CryoBackupSearchService", "StartSearchJob", {})
     .n("BackupSearchClient", "StartSearchJobCommand")
-    .f(void 0, void 0)
-    .ser(se_StartSearchJobCommand)
-    .de(de_StartSearchJobCommand)
+    .sc(StartSearchJob)
     .build() {
 }
 
@@ -1192,16 +1061,11 @@ class StartSearchResultExportJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CryoBackupSearchService", "StartSearchResultExportJob", {})
     .n("BackupSearchClient", "StartSearchResultExportJobCommand")
-    .f(void 0, void 0)
-    .ser(se_StartSearchResultExportJobCommand)
-    .de(de_StartSearchResultExportJobCommand)
+    .sc(StartSearchResultExportJob)
     .build() {
 }
 
@@ -1209,16 +1073,11 @@ class StopSearchJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CryoBackupSearchService", "StopSearchJob", {})
     .n("BackupSearchClient", "StopSearchJobCommand")
-    .f(void 0, void 0)
-    .ser(se_StopSearchJobCommand)
-    .de(de_StopSearchJobCommand)
+    .sc(StopSearchJob)
     .build() {
 }
 
@@ -1226,16 +1085,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CryoBackupSearchService", "TagResource", {})
     .n("BackupSearchClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1243,16 +1097,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CryoBackupSearchService", "UntagResource", {})
     .n("BackupSearchClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1290,38 +1139,34 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.BackupSearch = BackupSearch;
 exports.BackupSearchClient = BackupSearchClient;
-exports.BackupSearchServiceException = BackupSearchServiceException;
-exports.ConflictException = ConflictException;
-exports.EBSResultItemFilterSensitiveLog = EBSResultItemFilterSensitiveLog;
+exports.BackupSearchServiceException = BackupSearchServiceException$1;
+exports.ConflictException = ConflictException$1;
 exports.ExportJobStatus = ExportJobStatus;
 exports.GetSearchJobCommand = GetSearchJobCommand;
 exports.GetSearchResultExportJobCommand = GetSearchResultExportJobCommand;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.ListSearchJobBackupsCommand = ListSearchJobBackupsCommand;
 exports.ListSearchJobResultsCommand = ListSearchJobResultsCommand;
-exports.ListSearchJobResultsOutputFilterSensitiveLog = ListSearchJobResultsOutputFilterSensitiveLog;
 exports.ListSearchJobsCommand = ListSearchJobsCommand;
 exports.ListSearchResultExportJobsCommand = ListSearchResultExportJobsCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.LongConditionOperator = LongConditionOperator;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.ResourceType = ResourceType;
-exports.ResultItemFilterSensitiveLog = ResultItemFilterSensitiveLog;
-exports.S3ResultItemFilterSensitiveLog = S3ResultItemFilterSensitiveLog;
 exports.SearchJobState = SearchJobState;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.StartSearchJobCommand = StartSearchJobCommand;
 exports.StartSearchResultExportJobCommand = StartSearchResultExportJobCommand;
 exports.StopSearchJobCommand = StopSearchJobCommand;
 exports.StringConditionOperator = StringConditionOperator;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.TimeConditionOperator = TimeConditionOperator;
 exports.UntagResourceCommand = UntagResourceCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.paginateListSearchJobBackups = paginateListSearchJobBackups;
 exports.paginateListSearchJobResults = paginateListSearchJobResults;
 exports.paginateListSearchJobs = paginateListSearchJobs;