@aws-sdk/client-medical-imaging 3.928.0 → 3.929.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,9 +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');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class MedicalImagingClient 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));
@@ -111,14 +110,14 @@ class MedicalImagingClient extends smithyClient.Client {
     }
 }
 
-class MedicalImagingServiceException extends smithyClient.ServiceException {
+let MedicalImagingServiceException$1 = class MedicalImagingServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, MedicalImagingServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends MedicalImagingServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends MedicalImagingServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -129,8 +128,8 @@ class AccessDeniedException extends MedicalImagingServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
-class ConflictException extends MedicalImagingServiceException {
+};
+let ConflictException$1 = class ConflictException extends MedicalImagingServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     constructor(opts) {
@@ -141,7 +140,7 @@ class ConflictException extends MedicalImagingServiceException {
         });
         Object.setPrototypeOf(this, ConflictException.prototype);
     }
-}
+};
 const ImageSetState = {
     ACTIVE: "ACTIVE",
     DELETED: "DELETED",
@@ -162,7 +161,7 @@ const ImageSetWorkflowStatus = {
     UPDATE_FAILED: "UPDATE_FAILED",
     UPDATING: "UPDATING",
 };
-class InternalServerException extends MedicalImagingServiceException {
+let InternalServerException$1 = class InternalServerException extends MedicalImagingServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     constructor(opts) {
@@ -173,8 +172,8 @@ class InternalServerException extends MedicalImagingServiceException {
         });
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
-}
-class ResourceNotFoundException extends MedicalImagingServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends MedicalImagingServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -185,8 +184,8 @@ class ResourceNotFoundException extends MedicalImagingServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
-class ServiceQuotaExceededException extends MedicalImagingServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends MedicalImagingServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     constructor(opts) {
@@ -197,8 +196,8 @@ class ServiceQuotaExceededException extends MedicalImagingServiceException {
         });
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
     }
-}
-class ThrottlingException extends MedicalImagingServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends MedicalImagingServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     constructor(opts) {
@@ -209,8 +208,8 @@ class ThrottlingException extends MedicalImagingServiceException {
         });
         Object.setPrototypeOf(this, ThrottlingException.prototype);
     }
-}
-class ValidationException extends MedicalImagingServiceException {
+};
+let ValidationException$1 = class ValidationException extends MedicalImagingServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     constructor(opts) {
@@ -221,7 +220,11 @@ class ValidationException extends MedicalImagingServiceException {
         });
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
-}
+};
+const LosslessStorageFormat = {
+    HTJ2K: "HTJ2K",
+    JPEG_2000_LOSSLESS: "JPEG_2000_LOSSLESS",
+};
 const DatastoreStatus = {
     ACTIVE: "ACTIVE",
     CREATE_FAILED: "CREATE_FAILED",
@@ -235,6 +238,10 @@ const JobStatus = {
     IN_PROGRESS: "IN_PROGRESS",
     SUBMITTED: "SUBMITTED",
 };
+const StorageTier = {
+    ARCHIVE_INSTANT_ACCESS: "ARCHIVE_INSTANT_ACCESS",
+    FREQUENT_ACCESS: "FREQUENT_ACCESS",
+};
 const Operator = {
     BETWEEN: "BETWEEN",
     EQUAL: "EQUAL",
@@ -282,1063 +289,1066 @@ exports.MetadataUpdates = void 0;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(exports.MetadataUpdates || (exports.MetadataUpdates = {}));
-const MetadataCopiesFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.copiableAttributes && { copiableAttributes: smithyClient.SENSITIVE_STRING }),
-});
-const CopySourceImageSetInformationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.DICOMCopies && { DICOMCopies: MetadataCopiesFilterSensitiveLog(obj.DICOMCopies) }),
-});
-const CopyImageSetInformationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.sourceImageSet && { sourceImageSet: CopySourceImageSetInformationFilterSensitiveLog(obj.sourceImageSet) }),
-});
-const CopyImageSetRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.copyImageSetInformation && {
-        copyImageSetInformation: CopyImageSetInformationFilterSensitiveLog(obj.copyImageSetInformation),
-    }),
-});
-const GetImageFrameResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const GetImageSetMetadataResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const DICOMStudyDateAndTimeFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.DICOMStudyDate && { DICOMStudyDate: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMStudyTime && { DICOMStudyTime: smithyClient.SENSITIVE_STRING }),
-});
-const SearchByAttributeValueFilterSensitiveLog = (obj) => {
-    if (obj.DICOMPatientId !== undefined)
-        return { DICOMPatientId: smithyClient.SENSITIVE_STRING };
-    if (obj.DICOMAccessionNumber !== undefined)
-        return { DICOMAccessionNumber: smithyClient.SENSITIVE_STRING };
-    if (obj.DICOMStudyId !== undefined)
-        return { DICOMStudyId: smithyClient.SENSITIVE_STRING };
-    if (obj.DICOMStudyInstanceUID !== undefined)
-        return { DICOMStudyInstanceUID: smithyClient.SENSITIVE_STRING };
-    if (obj.DICOMSeriesInstanceUID !== undefined)
-        return { DICOMSeriesInstanceUID: smithyClient.SENSITIVE_STRING };
-    if (obj.createdAt !== undefined)
-        return { createdAt: obj.createdAt };
-    if (obj.updatedAt !== undefined)
-        return { updatedAt: obj.updatedAt };
-    if (obj.DICOMStudyDateAndTime !== undefined)
-        return { DICOMStudyDateAndTime: DICOMStudyDateAndTimeFilterSensitiveLog(obj.DICOMStudyDateAndTime) };
-    if (obj.isPrimary !== undefined)
-        return { isPrimary: obj.isPrimary };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const SearchFilterFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.values && { values: obj.values.map((item) => SearchByAttributeValueFilterSensitiveLog(item)) }),
-});
-const SearchCriteriaFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.filters && { filters: obj.filters.map((item) => SearchFilterFilterSensitiveLog(item)) }),
-});
-const SearchImageSetsRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.searchCriteria && { searchCriteria: smithyClient.SENSITIVE_STRING }),
-});
-const DICOMTagsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.DICOMPatientId && { DICOMPatientId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMPatientName && { DICOMPatientName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMPatientBirthDate && { DICOMPatientBirthDate: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMPatientSex && { DICOMPatientSex: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMStudyInstanceUID && { DICOMStudyInstanceUID: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMStudyId && { DICOMStudyId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMStudyDescription && { DICOMStudyDescription: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMAccessionNumber && { DICOMAccessionNumber: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMSeriesInstanceUID && { DICOMSeriesInstanceUID: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMSeriesModality && { DICOMSeriesModality: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMSeriesBodyPart && { DICOMSeriesBodyPart: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMSeriesNumber && { DICOMSeriesNumber: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMStudyDate && { DICOMStudyDate: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DICOMStudyTime && { DICOMStudyTime: smithyClient.SENSITIVE_STRING }),
-});
-const ImageSetsMetadataSummaryFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.DICOMTags && { DICOMTags: DICOMTagsFilterSensitiveLog(obj.DICOMTags) }),
-});
-const SearchImageSetsResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.imageSetsMetadataSummaries && {
-        imageSetsMetadataSummaries: obj.imageSetsMetadataSummaries.map((item) => ImageSetsMetadataSummaryFilterSensitiveLog(item)),
-    }),
-});
-const DICOMUpdatesFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.removableAttributes && { removableAttributes: smithyClient.SENSITIVE_STRING }),
-    ...(obj.updatableAttributes && { updatableAttributes: smithyClient.SENSITIVE_STRING }),
-});
-const MetadataUpdatesFilterSensitiveLog = (obj) => {
-    if (obj.DICOMUpdates !== undefined)
-        return { DICOMUpdates: DICOMUpdatesFilterSensitiveLog(obj.DICOMUpdates) };
-    if (obj.revertToVersionId !== undefined)
-        return { revertToVersionId: obj.revertToVersionId };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const UpdateImageSetMetadataRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.updateImageSetMetadataUpdates && {
-        updateImageSetMetadataUpdates: MetadataUpdatesFilterSensitiveLog(obj.updateImageSetMetadataUpdates),
-    }),
-});
 
-const se_CopyImageSetCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/datastore/{datastoreId}/imageSet/{sourceImageSetId}/copyImageSet");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    b.p("sourceImageSetId", () => input.sourceImageSetId, "{sourceImageSetId}", false);
-    const query = smithyClient.map({
-        [_f]: [() => input.force !== void 0, () => input[_f].toString()],
-        [_pTP]: [() => input.promoteToPrimary !== void 0, () => input[_pTP].toString()],
-    });
-    let body;
-    if (input.copyImageSetInformation !== undefined) {
-        body = smithyClient._json(input.copyImageSetInformation);
-    }
-    if (body === undefined) {
-        body = {};
-    }
-    body = JSON.stringify(body);
-    let { hostname: resolvedHostname } = await context.endpoint();
-    if (context.disableHostPrefix !== true) {
-        resolvedHostname = "runtime-" + resolvedHostname;
-        if (!protocolHttp.isValidHostname(resolvedHostname)) {
-            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
-        }
-    }
-    b.hn(resolvedHostname);
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_CreateDatastoreCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/datastore");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        datastoreName: [],
-        kmsKeyArn: [],
-        lambdaAuthorizerArn: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteDatastoreCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/datastore/{datastoreId}");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteImageSetCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/deleteImageSet");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
-    let body;
-    let { hostname: resolvedHostname } = await context.endpoint();
-    if (context.disableHostPrefix !== true) {
-        resolvedHostname = "runtime-" + resolvedHostname;
-        if (!protocolHttp.isValidHostname(resolvedHostname)) {
-            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
-        }
-    }
-    b.hn(resolvedHostname);
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetDatastoreCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/datastore/{datastoreId}");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetDICOMImportJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/getDICOMImportJob/datastore/{datastoreId}/job/{jobId}");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    b.p("jobId", () => input.jobId, "{jobId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetImageFrameCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/getImageFrame");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
-    let body;
-    if (input.imageFrameInformation !== undefined) {
-        body = smithyClient._json(input.imageFrameInformation);
-    }
-    if (body === undefined) {
-        body = {};
-    }
-    body = JSON.stringify(body);
-    let { hostname: resolvedHostname } = await context.endpoint();
-    if (context.disableHostPrefix !== true) {
-        resolvedHostname = "runtime-" + resolvedHostname;
-        if (!protocolHttp.isValidHostname(resolvedHostname)) {
-            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
-        }
-    }
-    b.hn(resolvedHostname);
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetImageSetCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/getImageSet");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
-    const query = smithyClient.map({
-        [_v]: [, input[_vI]],
-    });
-    let body;
-    let { hostname: resolvedHostname } = await context.endpoint();
-    if (context.disableHostPrefix !== true) {
-        resolvedHostname = "runtime-" + resolvedHostname;
-        if (!protocolHttp.isValidHostname(resolvedHostname)) {
-            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
-        }
-    }
-    b.hn(resolvedHostname);
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_GetImageSetMetadataCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/getImageSetMetadata");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
-    const query = smithyClient.map({
-        [_v]: [, input[_vI]],
-    });
-    let body;
-    let { hostname: resolvedHostname } = await context.endpoint();
-    if (context.disableHostPrefix !== true) {
-        resolvedHostname = "runtime-" + resolvedHostname;
-        if (!protocolHttp.isValidHostname(resolvedHostname)) {
-            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
-        }
-    }
-    b.hn(resolvedHostname);
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListDatastoresCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/datastore");
-    const query = smithyClient.map({
-        [_dS]: [, input[_dS]],
-        [_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_ListDICOMImportJobsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/listDICOMImportJobs/datastore/{datastoreId}");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    const query = smithyClient.map({
-        [_jS]: [, input[_jS]],
-        [_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_ListImageSetVersionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/listImageSetVersions");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
-    const query = smithyClient.map({
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-    });
-    let body;
-    let { hostname: resolvedHostname } = await context.endpoint();
-    if (context.disableHostPrefix !== true) {
-        resolvedHostname = "runtime-" + resolvedHostname;
-        if (!protocolHttp.isValidHostname(resolvedHostname)) {
-            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
-        }
-    }
-    b.hn(resolvedHostname);
-    b.m("POST").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_SearchImageSetsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/datastore/{datastoreId}/searchImageSets");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    const query = smithyClient.map({
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-        [_nT]: [, input[_nT]],
-    });
-    let body;
-    if (input.searchCriteria !== undefined) {
-        body = se_SearchCriteria(input.searchCriteria);
-    }
-    if (body === undefined) {
-        body = {};
-    }
-    body = JSON.stringify(body);
-    let { hostname: resolvedHostname } = await context.endpoint();
-    if (context.disableHostPrefix !== true) {
-        resolvedHostname = "runtime-" + resolvedHostname;
-        if (!protocolHttp.isValidHostname(resolvedHostname)) {
-            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
-        }
-    }
-    b.hn(resolvedHostname);
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_StartDICOMImportJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/startDICOMImportJob/datastore/{datastoreId}");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        dataAccessRoleArn: [],
-        inputOwnerAccountId: [],
-        inputS3Uri: [],
-        jobName: [],
-        outputS3Uri: [],
-    }));
-    b.m("POST").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: (_) => smithyClient._json(_),
-    }));
-    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 se_UpdateImageSetMetadataCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/updateImageSetMetadata");
-    b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
-    b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
-    const query = smithyClient.map({
-        [_lV]: [, smithyClient.expectNonNull(input[_lVI], `latestVersionId`)],
-        [_f]: [() => input.force !== void 0, () => input[_f].toString()],
-    });
-    let body;
-    if (input.updateImageSetMetadataUpdates !== undefined) {
-        body = se_MetadataUpdates(input.updateImageSetMetadataUpdates, context);
-    }
-    if (body === undefined) {
-        body = {};
-    }
-    body = JSON.stringify(body);
-    let { hostname: resolvedHostname } = await context.endpoint();
-    if (context.disableHostPrefix !== true) {
-        resolvedHostname = "runtime-" + resolvedHostname;
-        if (!protocolHttp.isValidHostname(resolvedHostname)) {
-            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
-        }
-    }
-    b.hn(resolvedHostname);
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const de_CopyImageSetCommand = 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, {
-        datastoreId: smithyClient.expectString,
-        destinationImageSetProperties: (_) => de_CopyDestinationImageSetProperties(_),
-        sourceImageSetProperties: (_) => de_CopySourceImageSetProperties(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateDatastoreCommand = 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, {
-        datastoreId: smithyClient.expectString,
-        datastoreStatus: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteDatastoreCommand = 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, {
-        datastoreId: smithyClient.expectString,
-        datastoreStatus: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteImageSetCommand = 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, {
-        datastoreId: smithyClient.expectString,
-        imageSetId: smithyClient.expectString,
-        imageSetState: smithyClient.expectString,
-        imageSetWorkflowStatus: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetDatastoreCommand = 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, {
-        datastoreProperties: (_) => de_DatastoreProperties(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetDICOMImportJobCommand = 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, {
-        jobProperties: (_) => de_DICOMImportJobProperties(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetImageFrameCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_cT]: [, output.headers[_ct]],
-    });
-    const data = output.body;
-    context.sdkStreamMixin(data);
-    contents.imageFrameBlob = data;
-    return contents;
-};
-const de_GetImageSetCommand = 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, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        datastoreId: smithyClient.expectString,
-        deletedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        imageSetArn: smithyClient.expectString,
-        imageSetId: smithyClient.expectString,
-        imageSetState: smithyClient.expectString,
-        imageSetWorkflowStatus: smithyClient.expectString,
-        isPrimary: smithyClient.expectBoolean,
-        message: smithyClient.expectString,
-        overrides: smithyClient._json,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        versionId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetImageSetMetadataCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_cT]: [, output.headers[_ct]],
-        [_cE]: [, output.headers[_ce]],
-    });
-    const data = output.body;
-    context.sdkStreamMixin(data);
-    contents.imageSetMetadataBlob = data;
-    return contents;
-};
-const de_ListDatastoresCommand = 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, {
-        datastoreSummaries: (_) => de_DatastoreSummaries(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListDICOMImportJobsCommand = 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, {
-        jobSummaries: (_) => de_DICOMImportJobSummaries(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListImageSetVersionsCommand = 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, {
-        imageSetPropertiesList: (_) => de_ImageSetPropertiesList(_),
-        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: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_SearchImageSetsCommand = 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, {
-        imageSetsMetadataSummaries: (_) => de_ImageSetsMetadataSummaries(_),
-        nextToken: smithyClient.expectString,
-        sort: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartDICOMImportJobCommand = 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, {
-        datastoreId: smithyClient.expectString,
-        jobId: smithyClient.expectString,
-        jobStatus: smithyClient.expectString,
-        submittedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    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_UpdateImageSetMetadataCommand = 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, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        datastoreId: smithyClient.expectString,
-        imageSetId: smithyClient.expectString,
-        imageSetState: smithyClient.expectString,
-        imageSetWorkflowStatus: smithyClient.expectString,
-        latestVersionId: smithyClient.expectString,
-        message: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    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.medicalimaging#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.medicalimaging#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.medicalimaging#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.medicalimaging#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.medicalimaging#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.medicalimaging#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.medicalimaging#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(MedicalImagingServiceException);
-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,
-    });
-    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({});
-    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,
-    });
-    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,
-    });
-    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({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: 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_DICOMUpdates = (input, context) => {
-    return smithyClient.take(input, {
-        removableAttributes: context.base64Encoder,
-        updatableAttributes: context.base64Encoder,
-    });
-};
-const se_MetadataUpdates = (input, context) => {
-    return exports.MetadataUpdates.visit(input, {
-        DICOMUpdates: (value) => ({ DICOMUpdates: se_DICOMUpdates(value, context) }),
-        revertToVersionId: (value) => ({ revertToVersionId: value }),
-        _: (name, value) => ({ [name]: value }),
-    });
-};
-const se_SearchByAttributeValue = (input, context) => {
-    return exports.SearchByAttributeValue.visit(input, {
-        DICOMAccessionNumber: (value) => ({ DICOMAccessionNumber: value }),
-        DICOMPatientId: (value) => ({ DICOMPatientId: value }),
-        DICOMSeriesInstanceUID: (value) => ({ DICOMSeriesInstanceUID: value }),
-        DICOMStudyDateAndTime: (value) => ({ DICOMStudyDateAndTime: smithyClient._json(value) }),
-        DICOMStudyId: (value) => ({ DICOMStudyId: value }),
-        DICOMStudyInstanceUID: (value) => ({ DICOMStudyInstanceUID: value }),
-        createdAt: (value) => ({ createdAt: value.getTime() / 1_000 }),
-        isPrimary: (value) => ({ isPrimary: value }),
-        updatedAt: (value) => ({ updatedAt: value.getTime() / 1_000 }),
-        _: (name, value) => ({ [name]: value }),
-    });
-};
-const se_SearchByAttributeValues = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_SearchByAttributeValue(entry);
-    });
-};
-const se_SearchCriteria = (input, context) => {
-    return smithyClient.take(input, {
-        filters: (_) => se_SearchFilters(_),
-        sort: smithyClient._json,
-    });
-};
-const se_SearchFilter = (input, context) => {
-    return smithyClient.take(input, {
-        operator: [],
-        values: (_) => se_SearchByAttributeValues(_),
-    });
-};
-const se_SearchFilters = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_SearchFilter(entry);
-    });
-};
-const de_CopyDestinationImageSetProperties = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        imageSetArn: smithyClient.expectString,
-        imageSetId: smithyClient.expectString,
-        imageSetState: smithyClient.expectString,
-        imageSetWorkflowStatus: smithyClient.expectString,
-        latestVersionId: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_CopySourceImageSetProperties = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        imageSetArn: smithyClient.expectString,
-        imageSetId: smithyClient.expectString,
-        imageSetState: smithyClient.expectString,
-        imageSetWorkflowStatus: smithyClient.expectString,
-        latestVersionId: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_DatastoreProperties = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        datastoreArn: smithyClient.expectString,
-        datastoreId: smithyClient.expectString,
-        datastoreName: smithyClient.expectString,
-        datastoreStatus: smithyClient.expectString,
-        kmsKeyArn: smithyClient.expectString,
-        lambdaAuthorizerArn: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_DatastoreSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DatastoreSummary(entry);
-    });
-    return retVal;
-};
-const de_DatastoreSummary = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        datastoreArn: smithyClient.expectString,
-        datastoreId: smithyClient.expectString,
-        datastoreName: smithyClient.expectString,
-        datastoreStatus: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_DICOMImportJobProperties = (output, context) => {
-    return smithyClient.take(output, {
-        dataAccessRoleArn: smithyClient.expectString,
-        datastoreId: smithyClient.expectString,
-        endedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        inputS3Uri: smithyClient.expectString,
-        jobId: smithyClient.expectString,
-        jobName: smithyClient.expectString,
-        jobStatus: smithyClient.expectString,
-        message: smithyClient.expectString,
-        outputS3Uri: smithyClient.expectString,
-        submittedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_DICOMImportJobSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DICOMImportJobSummary(entry);
-    });
-    return retVal;
-};
-const de_DICOMImportJobSummary = (output, context) => {
-    return smithyClient.take(output, {
-        dataAccessRoleArn: smithyClient.expectString,
-        datastoreId: smithyClient.expectString,
-        endedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        jobId: smithyClient.expectString,
-        jobName: smithyClient.expectString,
-        jobStatus: smithyClient.expectString,
-        message: smithyClient.expectString,
-        submittedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_ImageSetProperties = (output, context) => {
-    return smithyClient.take(output, {
-        ImageSetWorkflowStatus: smithyClient.expectString,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        deletedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        imageSetId: smithyClient.expectString,
-        imageSetState: smithyClient.expectString,
-        isPrimary: smithyClient.expectBoolean,
-        message: smithyClient.expectString,
-        overrides: smithyClient._json,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        versionId: smithyClient.expectString,
-    });
-};
-const de_ImageSetPropertiesList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ImageSetProperties(entry);
-    });
-    return retVal;
-};
-const de_ImageSetsMetadataSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ImageSetsMetadataSummary(entry);
-    });
-    return retVal;
-};
-const de_ImageSetsMetadataSummary = (output, context) => {
-    return smithyClient.take(output, {
-        DICOMTags: smithyClient._json,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        imageSetId: smithyClient.expectString,
-        isPrimary: smithyClient.expectBoolean,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        version: smithyClient.expectInt32,
-    });
-};
-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 _CA = "CopiableAttributes";
+const _CD = "CreateDatastore";
+const _CDIS = "CopyDestinationImageSet";
+const _CDISP = "CopyDestinationImageSetProperties";
+const _CDR = "CreateDatastoreRequest";
+const _CDRr = "CreateDatastoreResponse";
+const _CE = "ConflictException";
+const _CE_ = "Content-Encoding";
+const _CIS = "CopyImageSet";
+const _CISI = "CopyImageSetInformation";
+const _CISR = "CopyImageSetRequest";
+const _CISRo = "CopyImageSetResponse";
+const _CSISI = "CopySourceImageSetInformation";
+const _CSISP = "CopySourceImageSetProperties";
+const _CT = "Content-Type";
+const _DD = "DeleteDatastore";
+const _DDR = "DeleteDatastoreRequest";
+const _DDRe = "DeleteDatastoreResponse";
+const _DICOMA = "DICOMAttribute";
+const _DICOMAN = "DICOMAccessionNumber";
+const _DICOMC = "DICOMCopies";
+const _DICOMIJP = "DICOMImportJobProperties";
+const _DICOMIJS = "DICOMImportJobSummary";
+const _DICOMIJSm = "DICOMImportJobSummaries";
+const _DICOMNOSRI = "DICOMNumberOfStudyRelatedInstances";
+const _DICOMNOSRS = "DICOMNumberOfStudyRelatedSeries";
+const _DICOMPBD = "DICOMPatientBirthDate";
+const _DICOMPI = "DICOMPatientId";
+const _DICOMPN = "DICOMPatientName";
+const _DICOMPS = "DICOMPatientSex";
+const _DICOMSBP = "DICOMSeriesBodyPart";
+const _DICOMSD = "DICOMStudyDate";
+const _DICOMSDAT = "DICOMStudyDateAndTime";
+const _DICOMSDt = "DICOMStudyDescription";
+const _DICOMSI = "DICOMStudyId";
+const _DICOMSIUID = "DICOMSeriesInstanceUID";
+const _DICOMSIUIDt = "DICOMStudyInstanceUID";
+const _DICOMSM = "DICOMSeriesModality";
+const _DICOMSN = "DICOMSeriesNumber";
+const _DICOMST = "DICOMStudyTime";
+const _DICOMT = "DICOMTags";
+const _DICOMU = "DICOMUpdates";
+const _DIS = "DeleteImageSet";
+const _DISR = "DeleteImageSetRequest";
+const _DISRe = "DeleteImageSetResponse";
+const _DP = "DatastoreProperties";
+const _DS = "DatastoreSummary";
+const _DSa = "DatastoreSummaries";
+const _GD = "GetDatastore";
+const _GDICOMIJ = "GetDICOMImportJob";
+const _GDICOMIJR = "GetDICOMImportJobRequest";
+const _GDICOMIJRe = "GetDICOMImportJobResponse";
+const _GDR = "GetDatastoreRequest";
+const _GDRe = "GetDatastoreResponse";
+const _GIF = "GetImageFrame";
+const _GIFR = "GetImageFrameRequest";
+const _GIFRe = "GetImageFrameResponse";
+const _GIS = "GetImageSet";
+const _GISM = "GetImageSetMetadata";
+const _GISMR = "GetImageSetMetadataRequest";
+const _GISMRe = "GetImageSetMetadataResponse";
+const _GISR = "GetImageSetRequest";
+const _GISRe = "GetImageSetResponse";
+const _IFI = "ImageFrameInformation";
+const _ISE = "InternalServerException";
+const _ISMB = "ImageSetMetadataBlob";
+const _ISMS = "ImageSetsMetadataSummary";
+const _ISMSm = "ImageSetsMetadataSummaries";
+const _ISP = "ImageSetProperties";
+const _ISPL = "ImageSetPropertiesList";
+const _ISWS = "ImageSetWorkflowStatus";
+const _LD = "ListDatastores";
+const _LDICOMIJ = "ListDICOMImportJobs";
+const _LDICOMIJR = "ListDICOMImportJobsRequest";
+const _LDICOMIJRi = "ListDICOMImportJobsResponse";
+const _LDR = "ListDatastoresRequest";
+const _LDRi = "ListDatastoresResponse";
+const _LISV = "ListImageSetVersions";
+const _LISVR = "ListImageSetVersionsRequest";
+const _LISVRi = "ListImageSetVersionsResponse";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _MC = "MetadataCopies";
+const _MU = "MetadataUpdates";
+const _O = "Overrides";
+const _PB = "PayloadBlob";
+const _RNFE = "ResourceNotFoundException";
+const _S = "Sort";
+const _SBAV = "SearchByAttributeValues";
+const _SBAVe = "SearchByAttributeValue";
+const _SC = "SearchCriteria";
+const _SDICOMIJ = "StartDICOMImportJob";
+const _SDICOMIJR = "StartDICOMImportJobRequest";
+const _SDICOMIJRt = "StartDICOMImportJobResponse";
+const _SF = "SearchFilter";
+const _SFe = "SearchFilters";
+const _SIS = "SearchImageSets";
+const _SISR = "SearchImageSetsRequest";
+const _SISRe = "SearchImageSetsResponse";
+const _SQEE = "ServiceQuotaExceededException";
+const _TE = "ThrottlingException";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _UISM = "UpdateImageSetMetadata";
+const _UISMR = "UpdateImageSetMetadataRequest";
+const _UISMRp = "UpdateImageSetMetadataResponse";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _VE = "ValidationException";
+const _c = "client";
+const _cA = "createdAt";
+const _cAo = "copiableAttributes";
 const _cE = "contentEncoding";
-const _cT = "contentType";
-const _ce = "content-encoding";
-const _ct = "content-type";
+const _cISI = "copyImageSetInformation";
+const _cT = "clientToken";
+const _cTo = "contentType";
+const _dA = "datastoreArn";
+const _dARA = "dataAccessRoleArn";
+const _dAe = "deletedAt";
+const _dI = "datastoreId";
+const _dIS = "destinationImageSet";
+const _dISP = "destinationImageSetProperties";
+const _dN = "datastoreName";
+const _dP = "datastoreProperties";
 const _dS = "datastoreStatus";
+const _dSa = "datastoreSummaries";
+const _e = "error";
+const _eA = "endedAt";
+const _en = "endpoint";
 const _f = "force";
+const _fi = "filters";
+const _fo = "forced";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
+const _iFB = "imageFrameBlob";
+const _iFI = "imageFrameInformation";
+const _iFIm = "imageFrameId";
+const _iOAI = "inputOwnerAccountId";
+const _iP = "isPrimary";
+const _iSA = "imageSetArn";
+const _iSI = "imageSetId";
+const _iSMB = "imageSetMetadataBlob";
+const _iSMS = "imageSetsMetadataSummaries";
+const _iSPL = "imageSetPropertiesList";
+const _iSS = "imageSetState";
+const _iSU = "inputS3Uri";
+const _iSWS = "imageSetWorkflowStatus";
+const _jI = "jobId";
+const _jN = "jobName";
+const _jP = "jobProperties";
 const _jS = "jobStatus";
+const _jSo = "jobSummaries";
+const _kKA = "kmsKeyArn";
+const _lAA = "lambdaAuthorizerArn";
+const _lAAa = "lastAccessedAt";
+const _lSF = "losslessStorageFormat";
 const _lV = "latestVersion";
 const _lVI = "latestVersionId";
+const _m = "message";
 const _mR = "maxResults";
 const _nT = "nextToken";
+const _o = "overrides";
+const _oSU = "outputS3Uri";
+const _op = "operator";
 const _pTP = "promoteToPrimary";
+const _rA = "removableAttributes";
+const _rAe = "resourceArn";
+const _rTVI = "revertToVersionId";
+const _s = "streaming";
+const _sA = "submittedAt";
+const _sC = "searchCriteria";
+const _sF = "sortField";
+const _sIS = "sourceImageSet";
+const _sISI = "sourceImageSetId";
+const _sISP = "sourceImageSetProperties";
+const _sO = "sortOrder";
+const _sT = "storageTier";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.medicalimaging";
+const _so = "sort";
+const _t = "tags";
 const _tK = "tagKeys";
+const _uA = "updatedAt";
+const _uAp = "updatableAttributes";
+const _uISMU = "updateImageSetMetadataUpdates";
 const _v = "version";
 const _vI = "versionId";
+const _va = "values";
+const n0 = "com.amazonaws.medicalimaging";
+var CopiableAttributes = [0, n0, _CA, 8, 0];
+var DICOMAccessionNumber = [0, n0, _DICOMAN, 8, 0];
+var DICOMAttribute = [0, n0, _DICOMA, 8, 21];
+var DICOMPatientBirthDate = [0, n0, _DICOMPBD, 8, 0];
+var DICOMPatientId = [0, n0, _DICOMPI, 8, 0];
+var DICOMPatientName = [0, n0, _DICOMPN, 8, 0];
+var DICOMPatientSex = [0, n0, _DICOMPS, 8, 0];
+var DICOMSeriesBodyPart = [0, n0, _DICOMSBP, 8, 0];
+var DICOMSeriesInstanceUID = [0, n0, _DICOMSIUID, 8, 0];
+var DICOMSeriesModality = [0, n0, _DICOMSM, 8, 0];
+var DICOMSeriesNumber = [0, n0, _DICOMSN, 8, 1];
+var DICOMStudyDate = [0, n0, _DICOMSD, 8, 0];
+var DICOMStudyDescription = [0, n0, _DICOMSDt, 8, 0];
+var DICOMStudyId = [0, n0, _DICOMSI, 8, 0];
+var DICOMStudyInstanceUID = [0, n0, _DICOMSIUIDt, 8, 0];
+var DICOMStudyTime = [0, n0, _DICOMST, 8, 0];
+var ImageSetMetadataBlob = [
+    0,
+    n0,
+    _ISMB,
+    {
+        [_s]: 1,
+    },
+    42,
+];
+var PayloadBlob = [
+    0,
+    n0,
+    _PB,
+    {
+        [_s]: 1,
+    },
+    42,
+];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CopyDestinationImageSet = [3, n0, _CDIS, 0, [_iSI, _lVI], [0, 0]];
+var CopyDestinationImageSetProperties = [
+    3,
+    n0,
+    _CDISP,
+    0,
+    [_iSI, _lVI, _iSS, _iSWS, _cA, _uA, _iSA],
+    [0, 0, 0, 0, 4, 4, 0],
+];
+var CopyImageSetInformation = [
+    3,
+    n0,
+    _CISI,
+    0,
+    [_sIS, _dIS],
+    [[() => CopySourceImageSetInformation, 0], () => CopyDestinationImageSet],
+];
+var CopyImageSetRequest = [
+    3,
+    n0,
+    _CISR,
+    0,
+    [_dI, _sISI, _cISI, _f, _pTP],
+    [
+        [0, 1],
+        [0, 1],
+        [() => CopyImageSetInformation, 16],
+        [
+            2,
+            {
+                [_hQ]: _f,
+            },
+        ],
+        [
+            2,
+            {
+                [_hQ]: _pTP,
+            },
+        ],
+    ],
+];
+var CopyImageSetResponse = [
+    3,
+    n0,
+    _CISRo,
+    0,
+    [_dI, _sISP, _dISP],
+    [0, () => CopySourceImageSetProperties, () => CopyDestinationImageSetProperties],
+];
+var CopySourceImageSetInformation = [
+    3,
+    n0,
+    _CSISI,
+    0,
+    [_lVI, _DICOMC],
+    [0, [() => MetadataCopies, 0]],
+];
+var CopySourceImageSetProperties = [
+    3,
+    n0,
+    _CSISP,
+    0,
+    [_iSI, _lVI, _iSS, _iSWS, _cA, _uA, _iSA],
+    [0, 0, 0, 0, 4, 4, 0],
+];
+var CreateDatastoreRequest = [
+    3,
+    n0,
+    _CDR,
+    0,
+    [_dN, _cT, _t, _kKA, _lAA, _lSF],
+    [0, [0, 4], 128 | 0, 0, 0, 0],
+];
+var CreateDatastoreResponse = [3, n0, _CDRr, 0, [_dI, _dS], [0, 0]];
+var DatastoreProperties = [
+    3,
+    n0,
+    _DP,
+    0,
+    [_dI, _dN, _dS, _kKA, _lAA, _lSF, _dA, _cA, _uA],
+    [0, 0, 0, 0, 0, 0, 0, 4, 4],
+];
+var DatastoreSummary = [
+    3,
+    n0,
+    _DS,
+    0,
+    [_dI, _dN, _dS, _dA, _cA, _uA],
+    [0, 0, 0, 0, 4, 4],
+];
+var DeleteDatastoreRequest = [3, n0, _DDR, 0, [_dI], [[0, 1]]];
+var DeleteDatastoreResponse = [3, n0, _DDRe, 0, [_dI, _dS], [0, 0]];
+var DeleteImageSetRequest = [
+    3,
+    n0,
+    _DISR,
+    0,
+    [_dI, _iSI],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var DeleteImageSetResponse = [3, n0, _DISRe, 0, [_dI, _iSI, _iSS, _iSWS], [0, 0, 0, 0]];
+var DICOMImportJobProperties = [
+    3,
+    n0,
+    _DICOMIJP,
+    0,
+    [_jI, _jN, _jS, _dI, _dARA, _eA, _sA, _iSU, _oSU, _m],
+    [0, 0, 0, 0, 0, 4, 4, 0, 0, 0],
+];
+var DICOMImportJobSummary = [
+    3,
+    n0,
+    _DICOMIJS,
+    0,
+    [_jI, _jN, _jS, _dI, _dARA, _eA, _sA, _m],
+    [0, 0, 0, 0, 0, 4, 4, 0],
+];
+var DICOMStudyDateAndTime = [
+    3,
+    n0,
+    _DICOMSDAT,
+    0,
+    [_DICOMSD, _DICOMST],
+    [
+        [() => DICOMStudyDate, 0],
+        [() => DICOMStudyTime, 0],
+    ],
+];
+var DICOMTags = [
+    3,
+    n0,
+    _DICOMT,
+    0,
+    [
+        _DICOMPI,
+        _DICOMPN,
+        _DICOMPBD,
+        _DICOMPS,
+        _DICOMSIUIDt,
+        _DICOMSI,
+        _DICOMSDt,
+        _DICOMNOSRS,
+        _DICOMNOSRI,
+        _DICOMAN,
+        _DICOMSIUID,
+        _DICOMSM,
+        _DICOMSBP,
+        _DICOMSN,
+        _DICOMSD,
+        _DICOMST,
+    ],
+    [
+        [() => DICOMPatientId, 0],
+        [() => DICOMPatientName, 0],
+        [() => DICOMPatientBirthDate, 0],
+        [() => DICOMPatientSex, 0],
+        [() => DICOMStudyInstanceUID, 0],
+        [() => DICOMStudyId, 0],
+        [() => DICOMStudyDescription, 0],
+        1,
+        1,
+        [() => DICOMAccessionNumber, 0],
+        [() => DICOMSeriesInstanceUID, 0],
+        [() => DICOMSeriesModality, 0],
+        [() => DICOMSeriesBodyPart, 0],
+        [() => DICOMSeriesNumber, 0],
+        [() => DICOMStudyDate, 0],
+        [() => DICOMStudyTime, 0],
+    ],
+];
+var DICOMUpdates = [
+    3,
+    n0,
+    _DICOMU,
+    0,
+    [_rA, _uAp],
+    [
+        [() => DICOMAttribute, 0],
+        [() => DICOMAttribute, 0],
+    ],
+];
+var GetDatastoreRequest = [3, n0, _GDR, 0, [_dI], [[0, 1]]];
+var GetDatastoreResponse = [3, n0, _GDRe, 0, [_dP], [() => DatastoreProperties]];
+var GetDICOMImportJobRequest = [
+    3,
+    n0,
+    _GDICOMIJR,
+    0,
+    [_dI, _jI],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetDICOMImportJobResponse = [
+    3,
+    n0,
+    _GDICOMIJRe,
+    0,
+    [_jP],
+    [() => DICOMImportJobProperties],
+];
+var GetImageFrameRequest = [
+    3,
+    n0,
+    _GIFR,
+    0,
+    [_dI, _iSI, _iFI],
+    [
+        [0, 1],
+        [0, 1],
+        [() => ImageFrameInformation, 16],
+    ],
+];
+var GetImageFrameResponse = [
+    3,
+    n0,
+    _GIFRe,
+    0,
+    [_iFB, _cTo],
+    [
+        [() => PayloadBlob, 16],
+        [
+            0,
+            {
+                [_hH]: _CT,
+            },
+        ],
+    ],
+];
+var GetImageSetMetadataRequest = [
+    3,
+    n0,
+    _GISMR,
+    0,
+    [_dI, _iSI, _vI],
+    [
+        [0, 1],
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _v,
+            },
+        ],
+    ],
+];
+var GetImageSetMetadataResponse = [
+    3,
+    n0,
+    _GISMRe,
+    0,
+    [_iSMB, _cTo, _cE],
+    [
+        [() => ImageSetMetadataBlob, 16],
+        [
+            0,
+            {
+                [_hH]: _CT,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CE_,
+            },
+        ],
+    ],
+];
+var GetImageSetRequest = [
+    3,
+    n0,
+    _GISR,
+    0,
+    [_dI, _iSI, _vI],
+    [
+        [0, 1],
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _v,
+            },
+        ],
+    ],
+];
+var GetImageSetResponse = [
+    3,
+    n0,
+    _GISRe,
+    0,
+    [_dI, _iSI, _vI, _iSS, _iSWS, _cA, _uA, _dAe, _m, _iSA, _o, _iP, _lAAa, _sT],
+    [0, 0, 0, 0, 0, 4, 4, 4, 0, 0, () => Overrides, 2, 4, 0],
+];
+var ImageFrameInformation = [3, n0, _IFI, 0, [_iFIm], [0]];
+var ImageSetProperties = [
+    3,
+    n0,
+    _ISP,
+    0,
+    [_iSI, _vI, _iSS, _ISWS, _cA, _uA, _dAe, _m, _o, _iP],
+    [0, 0, 0, 0, 4, 4, 4, 0, () => Overrides, 2],
+];
+var ImageSetsMetadataSummary = [
+    3,
+    n0,
+    _ISMS,
+    0,
+    [_iSI, _v, _cA, _uA, _lAAa, _sT, _DICOMT, _iP],
+    [0, 1, 4, 4, 4, 0, [() => DICOMTags, 0], 2],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ListDatastoresRequest = [
+    3,
+    n0,
+    _LDR,
+    0,
+    [_dS, _nT, _mR],
+    [
+        [
+            0,
+            {
+                [_hQ]: _dS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListDatastoresResponse = [
+    3,
+    n0,
+    _LDRi,
+    0,
+    [_dSa, _nT],
+    [() => DatastoreSummaries, 0],
+];
+var ListDICOMImportJobsRequest = [
+    3,
+    n0,
+    _LDICOMIJR,
+    0,
+    [_dI, _jS, _nT, _mR],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _jS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListDICOMImportJobsResponse = [
+    3,
+    n0,
+    _LDICOMIJRi,
+    0,
+    [_jSo, _nT],
+    [() => DICOMImportJobSummaries, 0],
+];
+var ListImageSetVersionsRequest = [
+    3,
+    n0,
+    _LISVR,
+    0,
+    [_dI, _iSI, _nT, _mR],
+    [
+        [0, 1],
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListImageSetVersionsResponse = [
+    3,
+    n0,
+    _LISVRi,
+    0,
+    [_iSPL, _nT],
+    [() => ImageSetPropertiesList, 0],
+];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rAe], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_t], [128 | 0]];
+var MetadataCopies = [3, n0, _MC, 0, [_cAo], [[() => CopiableAttributes, 0]]];
+var Overrides = [3, n0, _O, 0, [_fo], [2]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var SearchCriteria = [3, n0, _SC, 8, [_fi, _so], [[() => SearchFilters, 0], () => Sort]];
+var SearchFilter = [3, n0, _SF, 0, [_va, _op], [[() => SearchByAttributeValues, 0], 0]];
+var SearchImageSetsRequest = [
+    3,
+    n0,
+    _SISR,
+    0,
+    [_dI, _sC, _mR, _nT],
+    [
+        [0, 1],
+        [() => SearchCriteria, 16],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+    ],
+];
+var SearchImageSetsResponse = [
+    3,
+    n0,
+    _SISRe,
+    0,
+    [_iSMS, _so, _nT],
+    [[() => ImageSetsMetadataSummaries, 0], () => Sort, 0],
+];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var Sort = [3, n0, _S, 0, [_sO, _sF], [0, 0]];
+var StartDICOMImportJobRequest = [
+    3,
+    n0,
+    _SDICOMIJR,
+    0,
+    [_jN, _dARA, _cT, _dI, _iSU, _oSU, _iOAI],
+    [0, 0, [0, 4], [0, 1], 0, 0, 0],
+];
+var StartDICOMImportJobResponse = [
+    3,
+    n0,
+    _SDICOMIJRt,
+    0,
+    [_dI, _jI, _jS, _sA],
+    [0, 0, 0, 4],
+];
+var TagResourceRequest = [3, n0, _TRR, 0, [_rAe, _t], [[0, 1], 128 | 0]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_rAe, _tK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateImageSetMetadataRequest = [
+    3,
+    n0,
+    _UISMR,
+    0,
+    [_dI, _iSI, _lVI, _f, _uISMU],
+    [
+        [0, 1],
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _lV,
+            },
+        ],
+        [
+            2,
+            {
+                [_hQ]: _f,
+            },
+        ],
+        [() => MetadataUpdates, 16],
+    ],
+];
+var UpdateImageSetMetadataResponse = [
+    3,
+    n0,
+    _UISMRp,
+    0,
+    [_dI, _iSI, _lVI, _iSS, _iSWS, _cA, _uA, _m],
+    [0, 0, 0, 0, 0, 4, 4, 0],
+];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var MedicalImagingServiceException = [-3, _sm, "MedicalImagingServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(MedicalImagingServiceException, MedicalImagingServiceException$1);
+var DatastoreSummaries = [1, n0, _DSa, 0, () => DatastoreSummary];
+var DICOMImportJobSummaries = [1, n0, _DICOMIJSm, 0, () => DICOMImportJobSummary];
+var ImageSetPropertiesList = [1, n0, _ISPL, 0, () => ImageSetProperties];
+var ImageSetsMetadataSummaries = [1, n0, _ISMSm, 0, [() => ImageSetsMetadataSummary, 0]];
+var SearchByAttributeValues = [1, n0, _SBAV, 0, [() => SearchByAttributeValue, 0]];
+var SearchFilters = [1, n0, _SFe, 0, [() => SearchFilter, 0]];
+var MetadataUpdates = [3, n0, _MU, 0, [_DICOMU, _rTVI], [[() => DICOMUpdates, 0], 0]];
+var SearchByAttributeValue = [
+    3,
+    n0,
+    _SBAVe,
+    0,
+    [_DICOMPI, _DICOMAN, _DICOMSI, _DICOMSIUIDt, _DICOMSIUID, _cA, _uA, _DICOMSDAT, _iP],
+    [
+        [() => DICOMPatientId, 0],
+        [() => DICOMAccessionNumber, 0],
+        [() => DICOMStudyId, 0],
+        [() => DICOMStudyInstanceUID, 0],
+        [() => DICOMSeriesInstanceUID, 0],
+        4,
+        4,
+        [() => DICOMStudyDateAndTime, 0],
+        2,
+    ],
+];
+var CopyImageSet = [
+    9,
+    n0,
+    _CIS,
+    {
+        [_h]: ["POST", "/datastore/{datastoreId}/imageSet/{sourceImageSetId}/copyImageSet", 200],
+        [_en]: ["runtime-"],
+    },
+    () => CopyImageSetRequest,
+    () => CopyImageSetResponse,
+];
+var CreateDatastore = [
+    9,
+    n0,
+    _CD,
+    {
+        [_h]: ["POST", "/datastore", 200],
+    },
+    () => CreateDatastoreRequest,
+    () => CreateDatastoreResponse,
+];
+var DeleteDatastore = [
+    9,
+    n0,
+    _DD,
+    {
+        [_h]: ["DELETE", "/datastore/{datastoreId}", 200],
+    },
+    () => DeleteDatastoreRequest,
+    () => DeleteDatastoreResponse,
+];
+var DeleteImageSet = [
+    9,
+    n0,
+    _DIS,
+    {
+        [_h]: ["POST", "/datastore/{datastoreId}/imageSet/{imageSetId}/deleteImageSet", 200],
+        [_en]: ["runtime-"],
+    },
+    () => DeleteImageSetRequest,
+    () => DeleteImageSetResponse,
+];
+var GetDatastore = [
+    9,
+    n0,
+    _GD,
+    {
+        [_h]: ["GET", "/datastore/{datastoreId}", 200],
+    },
+    () => GetDatastoreRequest,
+    () => GetDatastoreResponse,
+];
+var GetDICOMImportJob = [
+    9,
+    n0,
+    _GDICOMIJ,
+    {
+        [_h]: ["GET", "/getDICOMImportJob/datastore/{datastoreId}/job/{jobId}", 200],
+    },
+    () => GetDICOMImportJobRequest,
+    () => GetDICOMImportJobResponse,
+];
+var GetImageFrame = [
+    9,
+    n0,
+    _GIF,
+    {
+        [_h]: ["POST", "/datastore/{datastoreId}/imageSet/{imageSetId}/getImageFrame", 200],
+        [_en]: ["runtime-"],
+    },
+    () => GetImageFrameRequest,
+    () => GetImageFrameResponse,
+];
+var GetImageSet = [
+    9,
+    n0,
+    _GIS,
+    {
+        [_h]: ["POST", "/datastore/{datastoreId}/imageSet/{imageSetId}/getImageSet", 200],
+        [_en]: ["runtime-"],
+    },
+    () => GetImageSetRequest,
+    () => GetImageSetResponse,
+];
+var GetImageSetMetadata = [
+    9,
+    n0,
+    _GISM,
+    {
+        [_h]: ["POST", "/datastore/{datastoreId}/imageSet/{imageSetId}/getImageSetMetadata", 200],
+        [_en]: ["runtime-"],
+    },
+    () => GetImageSetMetadataRequest,
+    () => GetImageSetMetadataResponse,
+];
+var ListDatastores = [
+    9,
+    n0,
+    _LD,
+    {
+        [_h]: ["GET", "/datastore", 200],
+    },
+    () => ListDatastoresRequest,
+    () => ListDatastoresResponse,
+];
+var ListDICOMImportJobs = [
+    9,
+    n0,
+    _LDICOMIJ,
+    {
+        [_h]: ["GET", "/listDICOMImportJobs/datastore/{datastoreId}", 200],
+    },
+    () => ListDICOMImportJobsRequest,
+    () => ListDICOMImportJobsResponse,
+];
+var ListImageSetVersions = [
+    9,
+    n0,
+    _LISV,
+    {
+        [_h]: ["POST", "/datastore/{datastoreId}/imageSet/{imageSetId}/listImageSetVersions", 200],
+        [_en]: ["runtime-"],
+    },
+    () => ListImageSetVersionsRequest,
+    () => ListImageSetVersionsResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags/{resourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var SearchImageSets = [
+    9,
+    n0,
+    _SIS,
+    {
+        [_h]: ["POST", "/datastore/{datastoreId}/searchImageSets", 200],
+        [_en]: ["runtime-"],
+    },
+    () => SearchImageSetsRequest,
+    () => SearchImageSetsResponse,
+];
+var StartDICOMImportJob = [
+    9,
+    n0,
+    _SDICOMIJ,
+    {
+        [_h]: ["POST", "/startDICOMImportJob/datastore/{datastoreId}", 200],
+    },
+    () => StartDICOMImportJobRequest,
+    () => StartDICOMImportJobResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/tags/{resourceArn}", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/tags/{resourceArn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateImageSetMetadata = [
+    9,
+    n0,
+    _UISM,
+    {
+        [_h]: ["POST", "/datastore/{datastoreId}/imageSet/{imageSetId}/updateImageSetMetadata", 200],
+        [_en]: ["runtime-"],
+    },
+    () => UpdateImageSetMetadataRequest,
+    () => UpdateImageSetMetadataResponse,
+];
 
 class CopyImageSetCommand 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("AHIGatewayService", "CopyImageSet", {})
     .n("MedicalImagingClient", "CopyImageSetCommand")
-    .f(CopyImageSetRequestFilterSensitiveLog, void 0)
-    .ser(se_CopyImageSetCommand)
-    .de(de_CopyImageSetCommand)
+    .sc(CopyImageSet)
     .build() {
 }
 
@@ -1346,16 +1356,11 @@ class CreateDatastoreCommand 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("AHIGatewayService", "CreateDatastore", {})
     .n("MedicalImagingClient", "CreateDatastoreCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateDatastoreCommand)
-    .de(de_CreateDatastoreCommand)
+    .sc(CreateDatastore)
     .build() {
 }
 
@@ -1363,16 +1368,11 @@ class DeleteDatastoreCommand 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("AHIGatewayService", "DeleteDatastore", {})
     .n("MedicalImagingClient", "DeleteDatastoreCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteDatastoreCommand)
-    .de(de_DeleteDatastoreCommand)
+    .sc(DeleteDatastore)
     .build() {
 }
 
@@ -1380,16 +1380,11 @@ class DeleteImageSetCommand 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("AHIGatewayService", "DeleteImageSet", {})
     .n("MedicalImagingClient", "DeleteImageSetCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteImageSetCommand)
-    .de(de_DeleteImageSetCommand)
+    .sc(DeleteImageSet)
     .build() {
 }
 
@@ -1397,16 +1392,11 @@ class GetDatastoreCommand 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("AHIGatewayService", "GetDatastore", {})
     .n("MedicalImagingClient", "GetDatastoreCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDatastoreCommand)
-    .de(de_GetDatastoreCommand)
+    .sc(GetDatastore)
     .build() {
 }
 
@@ -1414,16 +1404,11 @@ class GetDICOMImportJobCommand 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("AHIGatewayService", "GetDICOMImportJob", {})
     .n("MedicalImagingClient", "GetDICOMImportJobCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDICOMImportJobCommand)
-    .de(de_GetDICOMImportJobCommand)
+    .sc(GetDICOMImportJob)
     .build() {
 }
 
@@ -1431,16 +1416,11 @@ class GetImageFrameCommand 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("AHIGatewayService", "GetImageFrame", {})
     .n("MedicalImagingClient", "GetImageFrameCommand")
-    .f(void 0, GetImageFrameResponseFilterSensitiveLog)
-    .ser(se_GetImageFrameCommand)
-    .de(de_GetImageFrameCommand)
+    .sc(GetImageFrame)
     .build() {
 }
 
@@ -1448,16 +1428,11 @@ class GetImageSetCommand 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("AHIGatewayService", "GetImageSet", {})
     .n("MedicalImagingClient", "GetImageSetCommand")
-    .f(void 0, void 0)
-    .ser(se_GetImageSetCommand)
-    .de(de_GetImageSetCommand)
+    .sc(GetImageSet)
     .build() {
 }
 
@@ -1465,16 +1440,11 @@ class GetImageSetMetadataCommand 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("AHIGatewayService", "GetImageSetMetadata", {})
     .n("MedicalImagingClient", "GetImageSetMetadataCommand")
-    .f(void 0, GetImageSetMetadataResponseFilterSensitiveLog)
-    .ser(se_GetImageSetMetadataCommand)
-    .de(de_GetImageSetMetadataCommand)
+    .sc(GetImageSetMetadata)
     .build() {
 }
 
@@ -1482,16 +1452,11 @@ class ListDatastoresCommand 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("AHIGatewayService", "ListDatastores", {})
     .n("MedicalImagingClient", "ListDatastoresCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDatastoresCommand)
-    .de(de_ListDatastoresCommand)
+    .sc(ListDatastores)
     .build() {
 }
 
@@ -1499,16 +1464,11 @@ class ListDICOMImportJobsCommand 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("AHIGatewayService", "ListDICOMImportJobs", {})
     .n("MedicalImagingClient", "ListDICOMImportJobsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDICOMImportJobsCommand)
-    .de(de_ListDICOMImportJobsCommand)
+    .sc(ListDICOMImportJobs)
     .build() {
 }
 
@@ -1516,16 +1476,11 @@ class ListImageSetVersionsCommand 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("AHIGatewayService", "ListImageSetVersions", {})
     .n("MedicalImagingClient", "ListImageSetVersionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListImageSetVersionsCommand)
-    .de(de_ListImageSetVersionsCommand)
+    .sc(ListImageSetVersions)
     .build() {
 }
 
@@ -1533,16 +1488,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("AHIGatewayService", "ListTagsForResource", {})
     .n("MedicalImagingClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1550,16 +1500,11 @@ class SearchImageSetsCommand 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("AHIGatewayService", "SearchImageSets", {})
     .n("MedicalImagingClient", "SearchImageSetsCommand")
-    .f(SearchImageSetsRequestFilterSensitiveLog, SearchImageSetsResponseFilterSensitiveLog)
-    .ser(se_SearchImageSetsCommand)
-    .de(de_SearchImageSetsCommand)
+    .sc(SearchImageSets)
     .build() {
 }
 
@@ -1567,16 +1512,11 @@ class StartDICOMImportJobCommand 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("AHIGatewayService", "StartDICOMImportJob", {})
     .n("MedicalImagingClient", "StartDICOMImportJobCommand")
-    .f(void 0, void 0)
-    .ser(se_StartDICOMImportJobCommand)
-    .de(de_StartDICOMImportJobCommand)
+    .sc(StartDICOMImportJob)
     .build() {
 }
 
@@ -1584,16 +1524,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("AHIGatewayService", "TagResource", {})
     .n("MedicalImagingClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1601,16 +1536,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("AHIGatewayService", "UntagResource", {})
     .n("MedicalImagingClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1618,16 +1548,11 @@ class UpdateImageSetMetadataCommand 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("AHIGatewayService", "UpdateImageSetMetadata", {})
     .n("MedicalImagingClient", "UpdateImageSetMetadataCommand")
-    .f(UpdateImageSetMetadataRequestFilterSensitiveLog, void 0)
-    .ser(se_UpdateImageSetMetadataCommand)
-    .de(de_UpdateImageSetMetadataCommand)
+    .sc(UpdateImageSetMetadata)
     .build() {
 }
 
@@ -1671,58 +1596,43 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
-exports.ConflictException = ConflictException;
+exports.AccessDeniedException = AccessDeniedException$1;
+exports.ConflictException = ConflictException$1;
 exports.CopyImageSetCommand = CopyImageSetCommand;
-exports.CopyImageSetInformationFilterSensitiveLog = CopyImageSetInformationFilterSensitiveLog;
-exports.CopyImageSetRequestFilterSensitiveLog = CopyImageSetRequestFilterSensitiveLog;
-exports.CopySourceImageSetInformationFilterSensitiveLog = CopySourceImageSetInformationFilterSensitiveLog;
 exports.CreateDatastoreCommand = CreateDatastoreCommand;
-exports.DICOMStudyDateAndTimeFilterSensitiveLog = DICOMStudyDateAndTimeFilterSensitiveLog;
-exports.DICOMTagsFilterSensitiveLog = DICOMTagsFilterSensitiveLog;
-exports.DICOMUpdatesFilterSensitiveLog = DICOMUpdatesFilterSensitiveLog;
 exports.DatastoreStatus = DatastoreStatus;
 exports.DeleteDatastoreCommand = DeleteDatastoreCommand;
 exports.DeleteImageSetCommand = DeleteImageSetCommand;
 exports.GetDICOMImportJobCommand = GetDICOMImportJobCommand;
 exports.GetDatastoreCommand = GetDatastoreCommand;
 exports.GetImageFrameCommand = GetImageFrameCommand;
-exports.GetImageFrameResponseFilterSensitiveLog = GetImageFrameResponseFilterSensitiveLog;
 exports.GetImageSetCommand = GetImageSetCommand;
 exports.GetImageSetMetadataCommand = GetImageSetMetadataCommand;
-exports.GetImageSetMetadataResponseFilterSensitiveLog = GetImageSetMetadataResponseFilterSensitiveLog;
 exports.ImageSetState = ImageSetState;
 exports.ImageSetWorkflowStatus = ImageSetWorkflowStatus;
-exports.ImageSetsMetadataSummaryFilterSensitiveLog = ImageSetsMetadataSummaryFilterSensitiveLog;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.JobStatus = JobStatus;
 exports.ListDICOMImportJobsCommand = ListDICOMImportJobsCommand;
 exports.ListDatastoresCommand = ListDatastoresCommand;
 exports.ListImageSetVersionsCommand = ListImageSetVersionsCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
+exports.LosslessStorageFormat = LosslessStorageFormat;
 exports.MedicalImaging = MedicalImaging;
 exports.MedicalImagingClient = MedicalImagingClient;
-exports.MedicalImagingServiceException = MedicalImagingServiceException;
-exports.MetadataCopiesFilterSensitiveLog = MetadataCopiesFilterSensitiveLog;
-exports.MetadataUpdatesFilterSensitiveLog = MetadataUpdatesFilterSensitiveLog;
+exports.MedicalImagingServiceException = MedicalImagingServiceException$1;
 exports.Operator = Operator;
-exports.ResourceNotFoundException = ResourceNotFoundException;
-exports.SearchByAttributeValueFilterSensitiveLog = SearchByAttributeValueFilterSensitiveLog;
-exports.SearchCriteriaFilterSensitiveLog = SearchCriteriaFilterSensitiveLog;
-exports.SearchFilterFilterSensitiveLog = SearchFilterFilterSensitiveLog;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.SearchImageSetsCommand = SearchImageSetsCommand;
-exports.SearchImageSetsRequestFilterSensitiveLog = SearchImageSetsRequestFilterSensitiveLog;
-exports.SearchImageSetsResponseFilterSensitiveLog = SearchImageSetsResponseFilterSensitiveLog;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.SortField = SortField;
 exports.SortOrder = SortOrder;
 exports.StartDICOMImportJobCommand = StartDICOMImportJobCommand;
+exports.StorageTier = StorageTier;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateImageSetMetadataCommand = UpdateImageSetMetadataCommand;
-exports.UpdateImageSetMetadataRequestFilterSensitiveLog = UpdateImageSetMetadataRequestFilterSensitiveLog;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.paginateListDICOMImportJobs = paginateListDICOMImportJobs;
 exports.paginateListDatastores = paginateListDatastores;
 exports.paginateListImageSetVersions = paginateListImageSetVersions;