@aws-sdk/client-medical-imaging 3.901.0 → 3.907.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/dist-cjs/index.js +1688 -1815
  2. package/package.json +6 -6
package/dist-cjs/index.js CHANGED
@@ -1,1856 +1,1729 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
7
- var __export = (target, all) => {
8
- for (var name in all)
9
- __defProp(target, name, { get: all[name], enumerable: true });
10
- };
11
- var __copyProps = (to, from, except, desc) => {
12
- if (from && typeof from === "object" || typeof from === "function") {
13
- for (let key of __getOwnPropNames(from))
14
- if (!__hasOwnProp.call(to, key) && key !== except)
15
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
- }
17
- return to;
18
- };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- AccessDeniedException: () => AccessDeniedException,
25
- ConflictException: () => ConflictException,
26
- CopyImageSetCommand: () => CopyImageSetCommand,
27
- CopyImageSetInformationFilterSensitiveLog: () => CopyImageSetInformationFilterSensitiveLog,
28
- CopyImageSetRequestFilterSensitiveLog: () => CopyImageSetRequestFilterSensitiveLog,
29
- CopySourceImageSetInformationFilterSensitiveLog: () => CopySourceImageSetInformationFilterSensitiveLog,
30
- CreateDatastoreCommand: () => CreateDatastoreCommand,
31
- DICOMStudyDateAndTimeFilterSensitiveLog: () => DICOMStudyDateAndTimeFilterSensitiveLog,
32
- DICOMTagsFilterSensitiveLog: () => DICOMTagsFilterSensitiveLog,
33
- DICOMUpdatesFilterSensitiveLog: () => DICOMUpdatesFilterSensitiveLog,
34
- DatastoreStatus: () => DatastoreStatus,
35
- DeleteDatastoreCommand: () => DeleteDatastoreCommand,
36
- DeleteImageSetCommand: () => DeleteImageSetCommand,
37
- GetDICOMImportJobCommand: () => GetDICOMImportJobCommand,
38
- GetDatastoreCommand: () => GetDatastoreCommand,
39
- GetImageFrameCommand: () => GetImageFrameCommand,
40
- GetImageFrameResponseFilterSensitiveLog: () => GetImageFrameResponseFilterSensitiveLog,
41
- GetImageSetCommand: () => GetImageSetCommand,
42
- GetImageSetMetadataCommand: () => GetImageSetMetadataCommand,
43
- GetImageSetMetadataResponseFilterSensitiveLog: () => GetImageSetMetadataResponseFilterSensitiveLog,
44
- ImageSetState: () => ImageSetState,
45
- ImageSetWorkflowStatus: () => ImageSetWorkflowStatus,
46
- ImageSetsMetadataSummaryFilterSensitiveLog: () => ImageSetsMetadataSummaryFilterSensitiveLog,
47
- InternalServerException: () => InternalServerException,
48
- JobStatus: () => JobStatus,
49
- ListDICOMImportJobsCommand: () => ListDICOMImportJobsCommand,
50
- ListDatastoresCommand: () => ListDatastoresCommand,
51
- ListImageSetVersionsCommand: () => ListImageSetVersionsCommand,
52
- ListTagsForResourceCommand: () => ListTagsForResourceCommand,
53
- MedicalImaging: () => MedicalImaging,
54
- MedicalImagingClient: () => MedicalImagingClient,
55
- MedicalImagingServiceException: () => MedicalImagingServiceException,
56
- MetadataCopiesFilterSensitiveLog: () => MetadataCopiesFilterSensitiveLog,
57
- MetadataUpdates: () => MetadataUpdates,
58
- MetadataUpdatesFilterSensitiveLog: () => MetadataUpdatesFilterSensitiveLog,
59
- Operator: () => Operator,
60
- ResourceNotFoundException: () => ResourceNotFoundException,
61
- SearchByAttributeValue: () => SearchByAttributeValue,
62
- SearchByAttributeValueFilterSensitiveLog: () => SearchByAttributeValueFilterSensitiveLog,
63
- SearchCriteriaFilterSensitiveLog: () => SearchCriteriaFilterSensitiveLog,
64
- SearchFilterFilterSensitiveLog: () => SearchFilterFilterSensitiveLog,
65
- SearchImageSetsCommand: () => SearchImageSetsCommand,
66
- SearchImageSetsRequestFilterSensitiveLog: () => SearchImageSetsRequestFilterSensitiveLog,
67
- SearchImageSetsResponseFilterSensitiveLog: () => SearchImageSetsResponseFilterSensitiveLog,
68
- ServiceQuotaExceededException: () => ServiceQuotaExceededException,
69
- SortField: () => SortField,
70
- SortOrder: () => SortOrder,
71
- StartDICOMImportJobCommand: () => StartDICOMImportJobCommand,
72
- TagResourceCommand: () => TagResourceCommand,
73
- ThrottlingException: () => ThrottlingException,
74
- UntagResourceCommand: () => UntagResourceCommand,
75
- UpdateImageSetMetadataCommand: () => UpdateImageSetMetadataCommand,
76
- UpdateImageSetMetadataRequestFilterSensitiveLog: () => UpdateImageSetMetadataRequestFilterSensitiveLog,
77
- ValidationException: () => ValidationException,
78
- __Client: () => import_smithy_client.Client,
79
- paginateListDICOMImportJobs: () => paginateListDICOMImportJobs,
80
- paginateListDatastores: () => paginateListDatastores,
81
- paginateListImageSetVersions: () => paginateListImageSetVersions,
82
- paginateSearchImageSets: () => paginateSearchImageSets
83
- });
84
- module.exports = __toCommonJS(index_exports);
85
-
86
- // src/MedicalImagingClient.ts
87
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
88
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
89
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
90
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
91
- var import_config_resolver = require("@smithy/config-resolver");
92
- var import_core = require("@smithy/core");
93
- var import_middleware_content_length = require("@smithy/middleware-content-length");
94
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
95
- var import_middleware_retry = require("@smithy/middleware-retry");
96
-
97
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
98
-
99
- // src/endpoint/EndpointParameters.ts
100
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
101
- return Object.assign(options, {
102
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
103
- useFipsEndpoint: options.useFipsEndpoint ?? false,
104
- defaultSigningName: "medical-imaging"
105
- });
106
- }, "resolveClientEndpointParameters");
107
- var commonParams = {
108
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
109
- Endpoint: { type: "builtInParams", name: "endpoint" },
110
- Region: { type: "builtInParams", name: "region" },
111
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
1
+ 'use strict';
2
+
3
+ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
4
+ var middlewareLogger = require('@aws-sdk/middleware-logger');
5
+ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
6
+ var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
7
+ var configResolver = require('@smithy/config-resolver');
8
+ var core = require('@smithy/core');
9
+ var middlewareContentLength = require('@smithy/middleware-content-length');
10
+ var middlewareEndpoint = require('@smithy/middleware-endpoint');
11
+ var middlewareRetry = require('@smithy/middleware-retry');
12
+ var smithyClient = require('@smithy/smithy-client');
13
+ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
14
+ var runtimeConfig = require('./runtimeConfig');
15
+ var regionConfigResolver = require('@aws-sdk/region-config-resolver');
16
+ var protocolHttp = require('@smithy/protocol-http');
17
+ var middlewareSerde = require('@smithy/middleware-serde');
18
+ var core$1 = require('@aws-sdk/core');
19
+ var uuid = require('@smithy/uuid');
20
+
21
+ const resolveClientEndpointParameters = (options) => {
22
+ return Object.assign(options, {
23
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
24
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
25
+ defaultSigningName: "medical-imaging",
26
+ });
27
+ };
28
+ const commonParams = {
29
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
30
+ Endpoint: { type: "builtInParams", name: "endpoint" },
31
+ Region: { type: "builtInParams", name: "region" },
32
+ UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
112
33
  };
113
34
 
114
- // src/MedicalImagingClient.ts
115
- var import_runtimeConfig = require("././runtimeConfig");
35
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
36
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
37
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
38
+ let _credentials = runtimeConfig.credentials;
39
+ return {
40
+ setHttpAuthScheme(httpAuthScheme) {
41
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
42
+ if (index === -1) {
43
+ _httpAuthSchemes.push(httpAuthScheme);
44
+ }
45
+ else {
46
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
47
+ }
48
+ },
49
+ httpAuthSchemes() {
50
+ return _httpAuthSchemes;
51
+ },
52
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
53
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
54
+ },
55
+ httpAuthSchemeProvider() {
56
+ return _httpAuthSchemeProvider;
57
+ },
58
+ setCredentials(credentials) {
59
+ _credentials = credentials;
60
+ },
61
+ credentials() {
62
+ return _credentials;
63
+ },
64
+ };
65
+ };
66
+ const resolveHttpAuthRuntimeConfig = (config) => {
67
+ return {
68
+ httpAuthSchemes: config.httpAuthSchemes(),
69
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
70
+ credentials: config.credentials(),
71
+ };
72
+ };
116
73
 
117
- // src/runtimeExtensions.ts
118
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
119
- var import_protocol_http = require("@smithy/protocol-http");
120
- var import_smithy_client = require("@smithy/smithy-client");
74
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
75
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
76
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
77
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
78
+ };
121
79
 
122
- // src/auth/httpAuthExtensionConfiguration.ts
123
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
124
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
125
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
126
- let _credentials = runtimeConfig.credentials;
127
- return {
128
- setHttpAuthScheme(httpAuthScheme) {
129
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
130
- if (index === -1) {
131
- _httpAuthSchemes.push(httpAuthScheme);
132
- } else {
133
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
134
- }
135
- },
136
- httpAuthSchemes() {
137
- return _httpAuthSchemes;
138
- },
139
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
140
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
141
- },
142
- httpAuthSchemeProvider() {
143
- return _httpAuthSchemeProvider;
144
- },
145
- setCredentials(credentials) {
146
- _credentials = credentials;
147
- },
148
- credentials() {
149
- return _credentials;
80
+ class MedicalImagingClient extends smithyClient.Client {
81
+ config;
82
+ constructor(...[configuration]) {
83
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
84
+ super(_config_0);
85
+ this.initConfig = _config_0;
86
+ const _config_1 = resolveClientEndpointParameters(_config_0);
87
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
88
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
89
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
90
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
91
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
92
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
93
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
94
+ this.config = _config_8;
95
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
96
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
97
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
98
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
99
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
100
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
101
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
102
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultMedicalImagingHttpAuthSchemeParametersProvider,
103
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
104
+ "aws.auth#sigv4": config.credentials,
105
+ }),
106
+ }));
107
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
150
108
  }
151
- };
152
- }, "getHttpAuthExtensionConfiguration");
153
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
154
- return {
155
- httpAuthSchemes: config.httpAuthSchemes(),
156
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
157
- credentials: config.credentials()
158
- };
159
- }, "resolveHttpAuthRuntimeConfig");
160
-
161
- // src/runtimeExtensions.ts
162
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
163
- const extensionConfiguration = Object.assign(
164
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
165
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
166
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
167
- getHttpAuthExtensionConfiguration(runtimeConfig)
168
- );
169
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
170
- return Object.assign(
171
- runtimeConfig,
172
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
173
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
174
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
175
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
176
- );
177
- }, "resolveRuntimeExtensions");
109
+ destroy() {
110
+ super.destroy();
111
+ }
112
+ }
178
113
 
179
- // src/MedicalImagingClient.ts
180
- var MedicalImagingClient = class extends import_smithy_client.Client {
181
- static {
182
- __name(this, "MedicalImagingClient");
183
- }
184
- /**
185
- * The resolved configuration of MedicalImagingClient class. This is resolved and normalized from the {@link MedicalImagingClientConfig | constructor configuration interface}.
186
- */
187
- config;
188
- constructor(...[configuration]) {
189
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
190
- super(_config_0);
191
- this.initConfig = _config_0;
192
- const _config_1 = resolveClientEndpointParameters(_config_0);
193
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
194
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
195
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
196
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
197
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
198
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
199
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
200
- this.config = _config_8;
201
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
202
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
203
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
204
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
205
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
206
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
207
- this.middlewareStack.use(
208
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
209
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultMedicalImagingHttpAuthSchemeParametersProvider,
210
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
211
- "aws.auth#sigv4": config.credentials
212
- }), "identityProviderConfigProvider")
213
- })
214
- );
215
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
216
- }
217
- /**
218
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
219
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
220
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
221
- */
222
- destroy() {
223
- super.destroy();
224
- }
114
+ class MedicalImagingServiceException extends smithyClient.ServiceException {
115
+ constructor(options) {
116
+ super(options);
117
+ Object.setPrototypeOf(this, MedicalImagingServiceException.prototype);
118
+ }
119
+ }
120
+
121
+ class AccessDeniedException extends MedicalImagingServiceException {
122
+ name = "AccessDeniedException";
123
+ $fault = "client";
124
+ constructor(opts) {
125
+ super({
126
+ name: "AccessDeniedException",
127
+ $fault: "client",
128
+ ...opts,
129
+ });
130
+ Object.setPrototypeOf(this, AccessDeniedException.prototype);
131
+ }
132
+ }
133
+ class ConflictException extends MedicalImagingServiceException {
134
+ name = "ConflictException";
135
+ $fault = "client";
136
+ constructor(opts) {
137
+ super({
138
+ name: "ConflictException",
139
+ $fault: "client",
140
+ ...opts,
141
+ });
142
+ Object.setPrototypeOf(this, ConflictException.prototype);
143
+ }
144
+ }
145
+ const ImageSetState = {
146
+ ACTIVE: "ACTIVE",
147
+ DELETED: "DELETED",
148
+ LOCKED: "LOCKED",
225
149
  };
226
-
227
- // src/MedicalImaging.ts
228
-
229
-
230
- // src/commands/CopyImageSetCommand.ts
231
-
232
- var import_middleware_serde = require("@smithy/middleware-serde");
233
-
234
-
235
- // src/models/models_0.ts
236
-
237
-
238
- // src/models/MedicalImagingServiceException.ts
239
-
240
- var MedicalImagingServiceException = class _MedicalImagingServiceException extends import_smithy_client.ServiceException {
241
- static {
242
- __name(this, "MedicalImagingServiceException");
243
- }
244
- /**
245
- * @internal
246
- */
247
- constructor(options) {
248
- super(options);
249
- Object.setPrototypeOf(this, _MedicalImagingServiceException.prototype);
250
- }
150
+ const ImageSetWorkflowStatus = {
151
+ COPIED: "COPIED",
152
+ COPYING: "COPYING",
153
+ COPYING_WITH_READ_ONLY_ACCESS: "COPYING_WITH_READ_ONLY_ACCESS",
154
+ COPY_FAILED: "COPY_FAILED",
155
+ CREATED: "CREATED",
156
+ DELETED: "DELETED",
157
+ DELETING: "DELETING",
158
+ IMPORTED: "IMPORTED",
159
+ IMPORTING: "IMPORTING",
160
+ IMPORT_FAILED: "IMPORT_FAILED",
161
+ UPDATED: "UPDATED",
162
+ UPDATE_FAILED: "UPDATE_FAILED",
163
+ UPDATING: "UPDATING",
251
164
  };
165
+ class InternalServerException extends MedicalImagingServiceException {
166
+ name = "InternalServerException";
167
+ $fault = "server";
168
+ constructor(opts) {
169
+ super({
170
+ name: "InternalServerException",
171
+ $fault: "server",
172
+ ...opts,
173
+ });
174
+ Object.setPrototypeOf(this, InternalServerException.prototype);
175
+ }
176
+ }
177
+ class ResourceNotFoundException extends MedicalImagingServiceException {
178
+ name = "ResourceNotFoundException";
179
+ $fault = "client";
180
+ constructor(opts) {
181
+ super({
182
+ name: "ResourceNotFoundException",
183
+ $fault: "client",
184
+ ...opts,
185
+ });
186
+ Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
187
+ }
188
+ }
189
+ class ServiceQuotaExceededException extends MedicalImagingServiceException {
190
+ name = "ServiceQuotaExceededException";
191
+ $fault = "client";
192
+ constructor(opts) {
193
+ super({
194
+ name: "ServiceQuotaExceededException",
195
+ $fault: "client",
196
+ ...opts,
197
+ });
198
+ Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
199
+ }
200
+ }
201
+ class ThrottlingException extends MedicalImagingServiceException {
202
+ name = "ThrottlingException";
203
+ $fault = "client";
204
+ constructor(opts) {
205
+ super({
206
+ name: "ThrottlingException",
207
+ $fault: "client",
208
+ ...opts,
209
+ });
210
+ Object.setPrototypeOf(this, ThrottlingException.prototype);
211
+ }
212
+ }
213
+ class ValidationException extends MedicalImagingServiceException {
214
+ name = "ValidationException";
215
+ $fault = "client";
216
+ constructor(opts) {
217
+ super({
218
+ name: "ValidationException",
219
+ $fault: "client",
220
+ ...opts,
221
+ });
222
+ Object.setPrototypeOf(this, ValidationException.prototype);
223
+ }
224
+ }
225
+ const DatastoreStatus = {
226
+ ACTIVE: "ACTIVE",
227
+ CREATE_FAILED: "CREATE_FAILED",
228
+ CREATING: "CREATING",
229
+ DELETED: "DELETED",
230
+ DELETING: "DELETING",
231
+ };
232
+ const JobStatus = {
233
+ COMPLETED: "COMPLETED",
234
+ FAILED: "FAILED",
235
+ IN_PROGRESS: "IN_PROGRESS",
236
+ SUBMITTED: "SUBMITTED",
237
+ };
238
+ const Operator = {
239
+ BETWEEN: "BETWEEN",
240
+ EQUAL: "EQUAL",
241
+ };
242
+ exports.SearchByAttributeValue = void 0;
243
+ (function (SearchByAttributeValue) {
244
+ SearchByAttributeValue.visit = (value, visitor) => {
245
+ if (value.DICOMPatientId !== undefined)
246
+ return visitor.DICOMPatientId(value.DICOMPatientId);
247
+ if (value.DICOMAccessionNumber !== undefined)
248
+ return visitor.DICOMAccessionNumber(value.DICOMAccessionNumber);
249
+ if (value.DICOMStudyId !== undefined)
250
+ return visitor.DICOMStudyId(value.DICOMStudyId);
251
+ if (value.DICOMStudyInstanceUID !== undefined)
252
+ return visitor.DICOMStudyInstanceUID(value.DICOMStudyInstanceUID);
253
+ if (value.DICOMSeriesInstanceUID !== undefined)
254
+ return visitor.DICOMSeriesInstanceUID(value.DICOMSeriesInstanceUID);
255
+ if (value.createdAt !== undefined)
256
+ return visitor.createdAt(value.createdAt);
257
+ if (value.updatedAt !== undefined)
258
+ return visitor.updatedAt(value.updatedAt);
259
+ if (value.DICOMStudyDateAndTime !== undefined)
260
+ return visitor.DICOMStudyDateAndTime(value.DICOMStudyDateAndTime);
261
+ if (value.isPrimary !== undefined)
262
+ return visitor.isPrimary(value.isPrimary);
263
+ return visitor._(value.$unknown[0], value.$unknown[1]);
264
+ };
265
+ })(exports.SearchByAttributeValue || (exports.SearchByAttributeValue = {}));
266
+ const SortField = {
267
+ DICOMStudyDateAndTime: "DICOMStudyDateAndTime",
268
+ createdAt: "createdAt",
269
+ updatedAt: "updatedAt",
270
+ };
271
+ const SortOrder = {
272
+ ASC: "ASC",
273
+ DESC: "DESC",
274
+ };
275
+ exports.MetadataUpdates = void 0;
276
+ (function (MetadataUpdates) {
277
+ MetadataUpdates.visit = (value, visitor) => {
278
+ if (value.DICOMUpdates !== undefined)
279
+ return visitor.DICOMUpdates(value.DICOMUpdates);
280
+ if (value.revertToVersionId !== undefined)
281
+ return visitor.revertToVersionId(value.revertToVersionId);
282
+ return visitor._(value.$unknown[0], value.$unknown[1]);
283
+ };
284
+ })(exports.MetadataUpdates || (exports.MetadataUpdates = {}));
285
+ const MetadataCopiesFilterSensitiveLog = (obj) => ({
286
+ ...obj,
287
+ ...(obj.copiableAttributes && { copiableAttributes: smithyClient.SENSITIVE_STRING }),
288
+ });
289
+ const CopySourceImageSetInformationFilterSensitiveLog = (obj) => ({
290
+ ...obj,
291
+ ...(obj.DICOMCopies && { DICOMCopies: MetadataCopiesFilterSensitiveLog(obj.DICOMCopies) }),
292
+ });
293
+ const CopyImageSetInformationFilterSensitiveLog = (obj) => ({
294
+ ...obj,
295
+ ...(obj.sourceImageSet && { sourceImageSet: CopySourceImageSetInformationFilterSensitiveLog(obj.sourceImageSet) }),
296
+ });
297
+ const CopyImageSetRequestFilterSensitiveLog = (obj) => ({
298
+ ...obj,
299
+ ...(obj.copyImageSetInformation && {
300
+ copyImageSetInformation: CopyImageSetInformationFilterSensitiveLog(obj.copyImageSetInformation),
301
+ }),
302
+ });
303
+ const GetImageFrameResponseFilterSensitiveLog = (obj) => ({
304
+ ...obj,
305
+ });
306
+ const GetImageSetMetadataResponseFilterSensitiveLog = (obj) => ({
307
+ ...obj,
308
+ });
309
+ const DICOMStudyDateAndTimeFilterSensitiveLog = (obj) => ({
310
+ ...obj,
311
+ ...(obj.DICOMStudyDate && { DICOMStudyDate: smithyClient.SENSITIVE_STRING }),
312
+ ...(obj.DICOMStudyTime && { DICOMStudyTime: smithyClient.SENSITIVE_STRING }),
313
+ });
314
+ const SearchByAttributeValueFilterSensitiveLog = (obj) => {
315
+ if (obj.DICOMPatientId !== undefined)
316
+ return { DICOMPatientId: smithyClient.SENSITIVE_STRING };
317
+ if (obj.DICOMAccessionNumber !== undefined)
318
+ return { DICOMAccessionNumber: smithyClient.SENSITIVE_STRING };
319
+ if (obj.DICOMStudyId !== undefined)
320
+ return { DICOMStudyId: smithyClient.SENSITIVE_STRING };
321
+ if (obj.DICOMStudyInstanceUID !== undefined)
322
+ return { DICOMStudyInstanceUID: smithyClient.SENSITIVE_STRING };
323
+ if (obj.DICOMSeriesInstanceUID !== undefined)
324
+ return { DICOMSeriesInstanceUID: smithyClient.SENSITIVE_STRING };
325
+ if (obj.createdAt !== undefined)
326
+ return { createdAt: obj.createdAt };
327
+ if (obj.updatedAt !== undefined)
328
+ return { updatedAt: obj.updatedAt };
329
+ if (obj.DICOMStudyDateAndTime !== undefined)
330
+ return { DICOMStudyDateAndTime: DICOMStudyDateAndTimeFilterSensitiveLog(obj.DICOMStudyDateAndTime) };
331
+ if (obj.isPrimary !== undefined)
332
+ return { isPrimary: obj.isPrimary };
333
+ if (obj.$unknown !== undefined)
334
+ return { [obj.$unknown[0]]: "UNKNOWN" };
335
+ };
336
+ const SearchFilterFilterSensitiveLog = (obj) => ({
337
+ ...obj,
338
+ ...(obj.values && { values: obj.values.map((item) => SearchByAttributeValueFilterSensitiveLog(item)) }),
339
+ });
340
+ const SearchCriteriaFilterSensitiveLog = (obj) => ({
341
+ ...obj,
342
+ ...(obj.filters && { filters: obj.filters.map((item) => SearchFilterFilterSensitiveLog(item)) }),
343
+ });
344
+ const SearchImageSetsRequestFilterSensitiveLog = (obj) => ({
345
+ ...obj,
346
+ ...(obj.searchCriteria && { searchCriteria: smithyClient.SENSITIVE_STRING }),
347
+ });
348
+ const DICOMTagsFilterSensitiveLog = (obj) => ({
349
+ ...obj,
350
+ ...(obj.DICOMPatientId && { DICOMPatientId: smithyClient.SENSITIVE_STRING }),
351
+ ...(obj.DICOMPatientName && { DICOMPatientName: smithyClient.SENSITIVE_STRING }),
352
+ ...(obj.DICOMPatientBirthDate && { DICOMPatientBirthDate: smithyClient.SENSITIVE_STRING }),
353
+ ...(obj.DICOMPatientSex && { DICOMPatientSex: smithyClient.SENSITIVE_STRING }),
354
+ ...(obj.DICOMStudyInstanceUID && { DICOMStudyInstanceUID: smithyClient.SENSITIVE_STRING }),
355
+ ...(obj.DICOMStudyId && { DICOMStudyId: smithyClient.SENSITIVE_STRING }),
356
+ ...(obj.DICOMStudyDescription && { DICOMStudyDescription: smithyClient.SENSITIVE_STRING }),
357
+ ...(obj.DICOMAccessionNumber && { DICOMAccessionNumber: smithyClient.SENSITIVE_STRING }),
358
+ ...(obj.DICOMSeriesInstanceUID && { DICOMSeriesInstanceUID: smithyClient.SENSITIVE_STRING }),
359
+ ...(obj.DICOMSeriesModality && { DICOMSeriesModality: smithyClient.SENSITIVE_STRING }),
360
+ ...(obj.DICOMSeriesBodyPart && { DICOMSeriesBodyPart: smithyClient.SENSITIVE_STRING }),
361
+ ...(obj.DICOMSeriesNumber && { DICOMSeriesNumber: smithyClient.SENSITIVE_STRING }),
362
+ ...(obj.DICOMStudyDate && { DICOMStudyDate: smithyClient.SENSITIVE_STRING }),
363
+ ...(obj.DICOMStudyTime && { DICOMStudyTime: smithyClient.SENSITIVE_STRING }),
364
+ });
365
+ const ImageSetsMetadataSummaryFilterSensitiveLog = (obj) => ({
366
+ ...obj,
367
+ ...(obj.DICOMTags && { DICOMTags: DICOMTagsFilterSensitiveLog(obj.DICOMTags) }),
368
+ });
369
+ const SearchImageSetsResponseFilterSensitiveLog = (obj) => ({
370
+ ...obj,
371
+ ...(obj.imageSetsMetadataSummaries && {
372
+ imageSetsMetadataSummaries: obj.imageSetsMetadataSummaries.map((item) => ImageSetsMetadataSummaryFilterSensitiveLog(item)),
373
+ }),
374
+ });
375
+ const DICOMUpdatesFilterSensitiveLog = (obj) => ({
376
+ ...obj,
377
+ ...(obj.removableAttributes && { removableAttributes: smithyClient.SENSITIVE_STRING }),
378
+ ...(obj.updatableAttributes && { updatableAttributes: smithyClient.SENSITIVE_STRING }),
379
+ });
380
+ const MetadataUpdatesFilterSensitiveLog = (obj) => {
381
+ if (obj.DICOMUpdates !== undefined)
382
+ return { DICOMUpdates: DICOMUpdatesFilterSensitiveLog(obj.DICOMUpdates) };
383
+ if (obj.revertToVersionId !== undefined)
384
+ return { revertToVersionId: obj.revertToVersionId };
385
+ if (obj.$unknown !== undefined)
386
+ return { [obj.$unknown[0]]: "UNKNOWN" };
387
+ };
388
+ const UpdateImageSetMetadataRequestFilterSensitiveLog = (obj) => ({
389
+ ...obj,
390
+ ...(obj.updateImageSetMetadataUpdates && {
391
+ updateImageSetMetadataUpdates: MetadataUpdatesFilterSensitiveLog(obj.updateImageSetMetadataUpdates),
392
+ }),
393
+ });
252
394
 
253
- // src/models/models_0.ts
254
- var AccessDeniedException = class _AccessDeniedException extends MedicalImagingServiceException {
255
- static {
256
- __name(this, "AccessDeniedException");
257
- }
258
- name = "AccessDeniedException";
259
- $fault = "client";
260
- /**
261
- * @internal
262
- */
263
- constructor(opts) {
264
- super({
265
- name: "AccessDeniedException",
266
- $fault: "client",
267
- ...opts
268
- });
269
- Object.setPrototypeOf(this, _AccessDeniedException.prototype);
270
- }
271
- };
272
- var ConflictException = class _ConflictException extends MedicalImagingServiceException {
273
- static {
274
- __name(this, "ConflictException");
275
- }
276
- name = "ConflictException";
277
- $fault = "client";
278
- /**
279
- * @internal
280
- */
281
- constructor(opts) {
282
- super({
283
- name: "ConflictException",
284
- $fault: "client",
285
- ...opts
286
- });
287
- Object.setPrototypeOf(this, _ConflictException.prototype);
288
- }
289
- };
290
- var ImageSetState = {
291
- ACTIVE: "ACTIVE",
292
- DELETED: "DELETED",
293
- LOCKED: "LOCKED"
294
- };
295
- var ImageSetWorkflowStatus = {
296
- COPIED: "COPIED",
297
- COPYING: "COPYING",
298
- COPYING_WITH_READ_ONLY_ACCESS: "COPYING_WITH_READ_ONLY_ACCESS",
299
- COPY_FAILED: "COPY_FAILED",
300
- CREATED: "CREATED",
301
- DELETED: "DELETED",
302
- DELETING: "DELETING",
303
- IMPORTED: "IMPORTED",
304
- IMPORTING: "IMPORTING",
305
- IMPORT_FAILED: "IMPORT_FAILED",
306
- UPDATED: "UPDATED",
307
- UPDATE_FAILED: "UPDATE_FAILED",
308
- UPDATING: "UPDATING"
309
- };
310
- var InternalServerException = class _InternalServerException extends MedicalImagingServiceException {
311
- static {
312
- __name(this, "InternalServerException");
313
- }
314
- name = "InternalServerException";
315
- $fault = "server";
316
- /**
317
- * @internal
318
- */
319
- constructor(opts) {
320
- super({
321
- name: "InternalServerException",
322
- $fault: "server",
323
- ...opts
324
- });
325
- Object.setPrototypeOf(this, _InternalServerException.prototype);
326
- }
327
- };
328
- var ResourceNotFoundException = class _ResourceNotFoundException extends MedicalImagingServiceException {
329
- static {
330
- __name(this, "ResourceNotFoundException");
331
- }
332
- name = "ResourceNotFoundException";
333
- $fault = "client";
334
- /**
335
- * @internal
336
- */
337
- constructor(opts) {
338
- super({
339
- name: "ResourceNotFoundException",
340
- $fault: "client",
341
- ...opts
342
- });
343
- Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
344
- }
345
- };
346
- var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends MedicalImagingServiceException {
347
- static {
348
- __name(this, "ServiceQuotaExceededException");
349
- }
350
- name = "ServiceQuotaExceededException";
351
- $fault = "client";
352
- /**
353
- * @internal
354
- */
355
- constructor(opts) {
356
- super({
357
- name: "ServiceQuotaExceededException",
358
- $fault: "client",
359
- ...opts
360
- });
361
- Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
362
- }
363
- };
364
- var ThrottlingException = class _ThrottlingException extends MedicalImagingServiceException {
365
- static {
366
- __name(this, "ThrottlingException");
367
- }
368
- name = "ThrottlingException";
369
- $fault = "client";
370
- /**
371
- * @internal
372
- */
373
- constructor(opts) {
374
- super({
375
- name: "ThrottlingException",
376
- $fault: "client",
377
- ...opts
378
- });
379
- Object.setPrototypeOf(this, _ThrottlingException.prototype);
380
- }
381
- };
382
- var ValidationException = class _ValidationException extends MedicalImagingServiceException {
383
- static {
384
- __name(this, "ValidationException");
385
- }
386
- name = "ValidationException";
387
- $fault = "client";
388
- /**
389
- * @internal
390
- */
391
- constructor(opts) {
392
- super({
393
- name: "ValidationException",
394
- $fault: "client",
395
- ...opts
396
- });
397
- Object.setPrototypeOf(this, _ValidationException.prototype);
398
- }
399
- };
400
- var DatastoreStatus = {
401
- ACTIVE: "ACTIVE",
402
- CREATE_FAILED: "CREATE_FAILED",
403
- CREATING: "CREATING",
404
- DELETED: "DELETED",
405
- DELETING: "DELETING"
406
- };
407
- var JobStatus = {
408
- COMPLETED: "COMPLETED",
409
- FAILED: "FAILED",
410
- IN_PROGRESS: "IN_PROGRESS",
411
- SUBMITTED: "SUBMITTED"
412
- };
413
- var Operator = {
414
- BETWEEN: "BETWEEN",
415
- EQUAL: "EQUAL"
416
- };
417
- var SearchByAttributeValue;
418
- ((SearchByAttributeValue2) => {
419
- SearchByAttributeValue2.visit = /* @__PURE__ */ __name((value, visitor) => {
420
- if (value.DICOMPatientId !== void 0) return visitor.DICOMPatientId(value.DICOMPatientId);
421
- if (value.DICOMAccessionNumber !== void 0) return visitor.DICOMAccessionNumber(value.DICOMAccessionNumber);
422
- if (value.DICOMStudyId !== void 0) return visitor.DICOMStudyId(value.DICOMStudyId);
423
- if (value.DICOMStudyInstanceUID !== void 0) return visitor.DICOMStudyInstanceUID(value.DICOMStudyInstanceUID);
424
- if (value.DICOMSeriesInstanceUID !== void 0) return visitor.DICOMSeriesInstanceUID(value.DICOMSeriesInstanceUID);
425
- if (value.createdAt !== void 0) return visitor.createdAt(value.createdAt);
426
- if (value.updatedAt !== void 0) return visitor.updatedAt(value.updatedAt);
427
- if (value.DICOMStudyDateAndTime !== void 0) return visitor.DICOMStudyDateAndTime(value.DICOMStudyDateAndTime);
428
- if (value.isPrimary !== void 0) return visitor.isPrimary(value.isPrimary);
429
- return visitor._(value.$unknown[0], value.$unknown[1]);
430
- }, "visit");
431
- })(SearchByAttributeValue || (SearchByAttributeValue = {}));
432
- var SortField = {
433
- DICOMStudyDateAndTime: "DICOMStudyDateAndTime",
434
- createdAt: "createdAt",
435
- updatedAt: "updatedAt"
436
- };
437
- var SortOrder = {
438
- ASC: "ASC",
439
- DESC: "DESC"
440
- };
441
- var MetadataUpdates;
442
- ((MetadataUpdates2) => {
443
- MetadataUpdates2.visit = /* @__PURE__ */ __name((value, visitor) => {
444
- if (value.DICOMUpdates !== void 0) return visitor.DICOMUpdates(value.DICOMUpdates);
445
- if (value.revertToVersionId !== void 0) return visitor.revertToVersionId(value.revertToVersionId);
446
- return visitor._(value.$unknown[0], value.$unknown[1]);
447
- }, "visit");
448
- })(MetadataUpdates || (MetadataUpdates = {}));
449
- var MetadataCopiesFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
450
- ...obj,
451
- ...obj.copiableAttributes && { copiableAttributes: import_smithy_client.SENSITIVE_STRING }
452
- }), "MetadataCopiesFilterSensitiveLog");
453
- var CopySourceImageSetInformationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
454
- ...obj,
455
- ...obj.DICOMCopies && { DICOMCopies: MetadataCopiesFilterSensitiveLog(obj.DICOMCopies) }
456
- }), "CopySourceImageSetInformationFilterSensitiveLog");
457
- var CopyImageSetInformationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
458
- ...obj,
459
- ...obj.sourceImageSet && { sourceImageSet: CopySourceImageSetInformationFilterSensitiveLog(obj.sourceImageSet) }
460
- }), "CopyImageSetInformationFilterSensitiveLog");
461
- var CopyImageSetRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
462
- ...obj,
463
- ...obj.copyImageSetInformation && {
464
- copyImageSetInformation: CopyImageSetInformationFilterSensitiveLog(obj.copyImageSetInformation)
465
- }
466
- }), "CopyImageSetRequestFilterSensitiveLog");
467
- var GetImageFrameResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
468
- ...obj
469
- }), "GetImageFrameResponseFilterSensitiveLog");
470
- var GetImageSetMetadataResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
471
- ...obj
472
- }), "GetImageSetMetadataResponseFilterSensitiveLog");
473
- var DICOMStudyDateAndTimeFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
474
- ...obj,
475
- ...obj.DICOMStudyDate && { DICOMStudyDate: import_smithy_client.SENSITIVE_STRING },
476
- ...obj.DICOMStudyTime && { DICOMStudyTime: import_smithy_client.SENSITIVE_STRING }
477
- }), "DICOMStudyDateAndTimeFilterSensitiveLog");
478
- var SearchByAttributeValueFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
479
- if (obj.DICOMPatientId !== void 0) return { DICOMPatientId: import_smithy_client.SENSITIVE_STRING };
480
- if (obj.DICOMAccessionNumber !== void 0) return { DICOMAccessionNumber: import_smithy_client.SENSITIVE_STRING };
481
- if (obj.DICOMStudyId !== void 0) return { DICOMStudyId: import_smithy_client.SENSITIVE_STRING };
482
- if (obj.DICOMStudyInstanceUID !== void 0) return { DICOMStudyInstanceUID: import_smithy_client.SENSITIVE_STRING };
483
- if (obj.DICOMSeriesInstanceUID !== void 0) return { DICOMSeriesInstanceUID: import_smithy_client.SENSITIVE_STRING };
484
- if (obj.createdAt !== void 0) return { createdAt: obj.createdAt };
485
- if (obj.updatedAt !== void 0) return { updatedAt: obj.updatedAt };
486
- if (obj.DICOMStudyDateAndTime !== void 0)
487
- return { DICOMStudyDateAndTime: DICOMStudyDateAndTimeFilterSensitiveLog(obj.DICOMStudyDateAndTime) };
488
- if (obj.isPrimary !== void 0) return { isPrimary: obj.isPrimary };
489
- if (obj.$unknown !== void 0) return { [obj.$unknown[0]]: "UNKNOWN" };
490
- }, "SearchByAttributeValueFilterSensitiveLog");
491
- var SearchFilterFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
492
- ...obj,
493
- ...obj.values && { values: obj.values.map((item) => SearchByAttributeValueFilterSensitiveLog(item)) }
494
- }), "SearchFilterFilterSensitiveLog");
495
- var SearchCriteriaFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
496
- ...obj,
497
- ...obj.filters && { filters: obj.filters.map((item) => SearchFilterFilterSensitiveLog(item)) }
498
- }), "SearchCriteriaFilterSensitiveLog");
499
- var SearchImageSetsRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
500
- ...obj,
501
- ...obj.searchCriteria && { searchCriteria: import_smithy_client.SENSITIVE_STRING }
502
- }), "SearchImageSetsRequestFilterSensitiveLog");
503
- var DICOMTagsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
504
- ...obj,
505
- ...obj.DICOMPatientId && { DICOMPatientId: import_smithy_client.SENSITIVE_STRING },
506
- ...obj.DICOMPatientName && { DICOMPatientName: import_smithy_client.SENSITIVE_STRING },
507
- ...obj.DICOMPatientBirthDate && { DICOMPatientBirthDate: import_smithy_client.SENSITIVE_STRING },
508
- ...obj.DICOMPatientSex && { DICOMPatientSex: import_smithy_client.SENSITIVE_STRING },
509
- ...obj.DICOMStudyInstanceUID && { DICOMStudyInstanceUID: import_smithy_client.SENSITIVE_STRING },
510
- ...obj.DICOMStudyId && { DICOMStudyId: import_smithy_client.SENSITIVE_STRING },
511
- ...obj.DICOMStudyDescription && { DICOMStudyDescription: import_smithy_client.SENSITIVE_STRING },
512
- ...obj.DICOMAccessionNumber && { DICOMAccessionNumber: import_smithy_client.SENSITIVE_STRING },
513
- ...obj.DICOMSeriesInstanceUID && { DICOMSeriesInstanceUID: import_smithy_client.SENSITIVE_STRING },
514
- ...obj.DICOMSeriesModality && { DICOMSeriesModality: import_smithy_client.SENSITIVE_STRING },
515
- ...obj.DICOMSeriesBodyPart && { DICOMSeriesBodyPart: import_smithy_client.SENSITIVE_STRING },
516
- ...obj.DICOMSeriesNumber && { DICOMSeriesNumber: import_smithy_client.SENSITIVE_STRING },
517
- ...obj.DICOMStudyDate && { DICOMStudyDate: import_smithy_client.SENSITIVE_STRING },
518
- ...obj.DICOMStudyTime && { DICOMStudyTime: import_smithy_client.SENSITIVE_STRING }
519
- }), "DICOMTagsFilterSensitiveLog");
520
- var ImageSetsMetadataSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
521
- ...obj,
522
- ...obj.DICOMTags && { DICOMTags: DICOMTagsFilterSensitiveLog(obj.DICOMTags) }
523
- }), "ImageSetsMetadataSummaryFilterSensitiveLog");
524
- var SearchImageSetsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
525
- ...obj,
526
- ...obj.imageSetsMetadataSummaries && {
527
- imageSetsMetadataSummaries: obj.imageSetsMetadataSummaries.map(
528
- (item) => ImageSetsMetadataSummaryFilterSensitiveLog(item)
529
- )
530
- }
531
- }), "SearchImageSetsResponseFilterSensitiveLog");
532
- var DICOMUpdatesFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
533
- ...obj,
534
- ...obj.removableAttributes && { removableAttributes: import_smithy_client.SENSITIVE_STRING },
535
- ...obj.updatableAttributes && { updatableAttributes: import_smithy_client.SENSITIVE_STRING }
536
- }), "DICOMUpdatesFilterSensitiveLog");
537
- var MetadataUpdatesFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
538
- if (obj.DICOMUpdates !== void 0) return { DICOMUpdates: DICOMUpdatesFilterSensitiveLog(obj.DICOMUpdates) };
539
- if (obj.revertToVersionId !== void 0) return { revertToVersionId: obj.revertToVersionId };
540
- if (obj.$unknown !== void 0) return { [obj.$unknown[0]]: "UNKNOWN" };
541
- }, "MetadataUpdatesFilterSensitiveLog");
542
- var UpdateImageSetMetadataRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
543
- ...obj,
544
- ...obj.updateImageSetMetadataUpdates && {
545
- updateImageSetMetadataUpdates: MetadataUpdatesFilterSensitiveLog(obj.updateImageSetMetadataUpdates)
546
- }
547
- }), "UpdateImageSetMetadataRequestFilterSensitiveLog");
548
-
549
- // src/protocols/Aws_restJson1.ts
550
- var import_core2 = require("@aws-sdk/core");
551
-
552
-
553
-
554
- var import_uuid = require("@smithy/uuid");
555
- var se_CopyImageSetCommand = /* @__PURE__ */ __name(async (input, context) => {
556
- const b = (0, import_core.requestBuilder)(input, context);
557
- const headers = {
558
- "content-type": "application/json"
559
- };
560
- b.bp("/datastore/{datastoreId}/imageSet/{sourceImageSetId}/copyImageSet");
561
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
562
- b.p("sourceImageSetId", () => input.sourceImageSetId, "{sourceImageSetId}", false);
563
- const query = (0, import_smithy_client.map)({
564
- [_f]: [() => input.force !== void 0, () => input[_f].toString()],
565
- [_pTP]: [() => input.promoteToPrimary !== void 0, () => input[_pTP].toString()]
566
- });
567
- let body;
568
- if (input.copyImageSetInformation !== void 0) {
569
- body = (0, import_smithy_client._json)(input.copyImageSetInformation);
570
- }
571
- if (body === void 0) {
572
- body = {};
573
- }
574
- body = JSON.stringify(body);
575
- let { hostname: resolvedHostname } = await context.endpoint();
576
- if (context.disableHostPrefix !== true) {
577
- resolvedHostname = "runtime-" + resolvedHostname;
578
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
579
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
395
+ const se_CopyImageSetCommand = async (input, context) => {
396
+ const b = core.requestBuilder(input, context);
397
+ const headers = {
398
+ "content-type": "application/json",
399
+ };
400
+ b.bp("/datastore/{datastoreId}/imageSet/{sourceImageSetId}/copyImageSet");
401
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
402
+ b.p("sourceImageSetId", () => input.sourceImageSetId, "{sourceImageSetId}", false);
403
+ const query = smithyClient.map({
404
+ [_f]: [() => input.force !== void 0, () => input[_f].toString()],
405
+ [_pTP]: [() => input.promoteToPrimary !== void 0, () => input[_pTP].toString()],
406
+ });
407
+ let body;
408
+ if (input.copyImageSetInformation !== undefined) {
409
+ body = smithyClient._json(input.copyImageSetInformation);
580
410
  }
581
- }
582
- b.hn(resolvedHostname);
583
- b.m("POST").h(headers).q(query).b(body);
584
- return b.build();
585
- }, "se_CopyImageSetCommand");
586
- var se_CreateDatastoreCommand = /* @__PURE__ */ __name(async (input, context) => {
587
- const b = (0, import_core.requestBuilder)(input, context);
588
- const headers = {
589
- "content-type": "application/json"
590
- };
591
- b.bp("/datastore");
592
- let body;
593
- body = JSON.stringify(
594
- (0, import_smithy_client.take)(input, {
595
- clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
596
- datastoreName: [],
597
- kmsKeyArn: [],
598
- lambdaAuthorizerArn: [],
599
- tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tags")
600
- })
601
- );
602
- b.m("POST").h(headers).b(body);
603
- return b.build();
604
- }, "se_CreateDatastoreCommand");
605
- var se_DeleteDatastoreCommand = /* @__PURE__ */ __name(async (input, context) => {
606
- const b = (0, import_core.requestBuilder)(input, context);
607
- const headers = {};
608
- b.bp("/datastore/{datastoreId}");
609
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
610
- let body;
611
- b.m("DELETE").h(headers).b(body);
612
- return b.build();
613
- }, "se_DeleteDatastoreCommand");
614
- var se_DeleteImageSetCommand = /* @__PURE__ */ __name(async (input, context) => {
615
- const b = (0, import_core.requestBuilder)(input, context);
616
- const headers = {};
617
- b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/deleteImageSet");
618
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
619
- b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
620
- let body;
621
- let { hostname: resolvedHostname } = await context.endpoint();
622
- if (context.disableHostPrefix !== true) {
623
- resolvedHostname = "runtime-" + resolvedHostname;
624
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
625
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
411
+ if (body === undefined) {
412
+ body = {};
626
413
  }
627
- }
628
- b.hn(resolvedHostname);
629
- b.m("POST").h(headers).b(body);
630
- return b.build();
631
- }, "se_DeleteImageSetCommand");
632
- var se_GetDatastoreCommand = /* @__PURE__ */ __name(async (input, context) => {
633
- const b = (0, import_core.requestBuilder)(input, context);
634
- const headers = {};
635
- b.bp("/datastore/{datastoreId}");
636
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
637
- let body;
638
- b.m("GET").h(headers).b(body);
639
- return b.build();
640
- }, "se_GetDatastoreCommand");
641
- var se_GetDICOMImportJobCommand = /* @__PURE__ */ __name(async (input, context) => {
642
- const b = (0, import_core.requestBuilder)(input, context);
643
- const headers = {};
644
- b.bp("/getDICOMImportJob/datastore/{datastoreId}/job/{jobId}");
645
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
646
- b.p("jobId", () => input.jobId, "{jobId}", false);
647
- let body;
648
- b.m("GET").h(headers).b(body);
649
- return b.build();
650
- }, "se_GetDICOMImportJobCommand");
651
- var se_GetImageFrameCommand = /* @__PURE__ */ __name(async (input, context) => {
652
- const b = (0, import_core.requestBuilder)(input, context);
653
- const headers = {
654
- "content-type": "application/json"
655
- };
656
- b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/getImageFrame");
657
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
658
- b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
659
- let body;
660
- if (input.imageFrameInformation !== void 0) {
661
- body = (0, import_smithy_client._json)(input.imageFrameInformation);
662
- }
663
- if (body === void 0) {
664
- body = {};
665
- }
666
- body = JSON.stringify(body);
667
- let { hostname: resolvedHostname } = await context.endpoint();
668
- if (context.disableHostPrefix !== true) {
669
- resolvedHostname = "runtime-" + resolvedHostname;
670
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
671
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
414
+ body = JSON.stringify(body);
415
+ let { hostname: resolvedHostname } = await context.endpoint();
416
+ if (context.disableHostPrefix !== true) {
417
+ resolvedHostname = "runtime-" + resolvedHostname;
418
+ if (!protocolHttp.isValidHostname(resolvedHostname)) {
419
+ throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
420
+ }
672
421
  }
673
- }
674
- b.hn(resolvedHostname);
675
- b.m("POST").h(headers).b(body);
676
- return b.build();
677
- }, "se_GetImageFrameCommand");
678
- var se_GetImageSetCommand = /* @__PURE__ */ __name(async (input, context) => {
679
- const b = (0, import_core.requestBuilder)(input, context);
680
- const headers = {};
681
- b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/getImageSet");
682
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
683
- b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
684
- const query = (0, import_smithy_client.map)({
685
- [_v]: [, input[_vI]]
686
- });
687
- let body;
688
- let { hostname: resolvedHostname } = await context.endpoint();
689
- if (context.disableHostPrefix !== true) {
690
- resolvedHostname = "runtime-" + resolvedHostname;
691
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
692
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
422
+ b.hn(resolvedHostname);
423
+ b.m("POST").h(headers).q(query).b(body);
424
+ return b.build();
425
+ };
426
+ const se_CreateDatastoreCommand = async (input, context) => {
427
+ const b = core.requestBuilder(input, context);
428
+ const headers = {
429
+ "content-type": "application/json",
430
+ };
431
+ b.bp("/datastore");
432
+ let body;
433
+ body = JSON.stringify(smithyClient.take(input, {
434
+ clientToken: [true, (_) => _ ?? uuid.v4()],
435
+ datastoreName: [],
436
+ kmsKeyArn: [],
437
+ lambdaAuthorizerArn: [],
438
+ tags: (_) => smithyClient._json(_),
439
+ }));
440
+ b.m("POST").h(headers).b(body);
441
+ return b.build();
442
+ };
443
+ const se_DeleteDatastoreCommand = async (input, context) => {
444
+ const b = core.requestBuilder(input, context);
445
+ const headers = {};
446
+ b.bp("/datastore/{datastoreId}");
447
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
448
+ let body;
449
+ b.m("DELETE").h(headers).b(body);
450
+ return b.build();
451
+ };
452
+ const se_DeleteImageSetCommand = async (input, context) => {
453
+ const b = core.requestBuilder(input, context);
454
+ const headers = {};
455
+ b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/deleteImageSet");
456
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
457
+ b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
458
+ let body;
459
+ let { hostname: resolvedHostname } = await context.endpoint();
460
+ if (context.disableHostPrefix !== true) {
461
+ resolvedHostname = "runtime-" + resolvedHostname;
462
+ if (!protocolHttp.isValidHostname(resolvedHostname)) {
463
+ throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
464
+ }
693
465
  }
694
- }
695
- b.hn(resolvedHostname);
696
- b.m("POST").h(headers).q(query).b(body);
697
- return b.build();
698
- }, "se_GetImageSetCommand");
699
- var se_GetImageSetMetadataCommand = /* @__PURE__ */ __name(async (input, context) => {
700
- const b = (0, import_core.requestBuilder)(input, context);
701
- const headers = {};
702
- b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/getImageSetMetadata");
703
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
704
- b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
705
- const query = (0, import_smithy_client.map)({
706
- [_v]: [, input[_vI]]
707
- });
708
- let body;
709
- let { hostname: resolvedHostname } = await context.endpoint();
710
- if (context.disableHostPrefix !== true) {
711
- resolvedHostname = "runtime-" + resolvedHostname;
712
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
713
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
466
+ b.hn(resolvedHostname);
467
+ b.m("POST").h(headers).b(body);
468
+ return b.build();
469
+ };
470
+ const se_GetDatastoreCommand = async (input, context) => {
471
+ const b = core.requestBuilder(input, context);
472
+ const headers = {};
473
+ b.bp("/datastore/{datastoreId}");
474
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
475
+ let body;
476
+ b.m("GET").h(headers).b(body);
477
+ return b.build();
478
+ };
479
+ const se_GetDICOMImportJobCommand = async (input, context) => {
480
+ const b = core.requestBuilder(input, context);
481
+ const headers = {};
482
+ b.bp("/getDICOMImportJob/datastore/{datastoreId}/job/{jobId}");
483
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
484
+ b.p("jobId", () => input.jobId, "{jobId}", false);
485
+ let body;
486
+ b.m("GET").h(headers).b(body);
487
+ return b.build();
488
+ };
489
+ const se_GetImageFrameCommand = async (input, context) => {
490
+ const b = core.requestBuilder(input, context);
491
+ const headers = {
492
+ "content-type": "application/json",
493
+ };
494
+ b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/getImageFrame");
495
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
496
+ b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
497
+ let body;
498
+ if (input.imageFrameInformation !== undefined) {
499
+ body = smithyClient._json(input.imageFrameInformation);
714
500
  }
715
- }
716
- b.hn(resolvedHostname);
717
- b.m("POST").h(headers).q(query).b(body);
718
- return b.build();
719
- }, "se_GetImageSetMetadataCommand");
720
- var se_ListDatastoresCommand = /* @__PURE__ */ __name(async (input, context) => {
721
- const b = (0, import_core.requestBuilder)(input, context);
722
- const headers = {};
723
- b.bp("/datastore");
724
- const query = (0, import_smithy_client.map)({
725
- [_dS]: [, input[_dS]],
726
- [_nT]: [, input[_nT]],
727
- [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()]
728
- });
729
- let body;
730
- b.m("GET").h(headers).q(query).b(body);
731
- return b.build();
732
- }, "se_ListDatastoresCommand");
733
- var se_ListDICOMImportJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
734
- const b = (0, import_core.requestBuilder)(input, context);
735
- const headers = {};
736
- b.bp("/listDICOMImportJobs/datastore/{datastoreId}");
737
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
738
- const query = (0, import_smithy_client.map)({
739
- [_jS]: [, input[_jS]],
740
- [_nT]: [, input[_nT]],
741
- [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()]
742
- });
743
- let body;
744
- b.m("GET").h(headers).q(query).b(body);
745
- return b.build();
746
- }, "se_ListDICOMImportJobsCommand");
747
- var se_ListImageSetVersionsCommand = /* @__PURE__ */ __name(async (input, context) => {
748
- const b = (0, import_core.requestBuilder)(input, context);
749
- const headers = {};
750
- b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/listImageSetVersions");
751
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
752
- b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
753
- const query = (0, import_smithy_client.map)({
754
- [_nT]: [, input[_nT]],
755
- [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()]
756
- });
757
- let body;
758
- let { hostname: resolvedHostname } = await context.endpoint();
759
- if (context.disableHostPrefix !== true) {
760
- resolvedHostname = "runtime-" + resolvedHostname;
761
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
762
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
501
+ if (body === undefined) {
502
+ body = {};
763
503
  }
764
- }
765
- b.hn(resolvedHostname);
766
- b.m("POST").h(headers).q(query).b(body);
767
- return b.build();
768
- }, "se_ListImageSetVersionsCommand");
769
- var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
770
- const b = (0, import_core.requestBuilder)(input, context);
771
- const headers = {};
772
- b.bp("/tags/{resourceArn}");
773
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
774
- let body;
775
- b.m("GET").h(headers).b(body);
776
- return b.build();
777
- }, "se_ListTagsForResourceCommand");
778
- var se_SearchImageSetsCommand = /* @__PURE__ */ __name(async (input, context) => {
779
- const b = (0, import_core.requestBuilder)(input, context);
780
- const headers = {
781
- "content-type": "application/json"
782
- };
783
- b.bp("/datastore/{datastoreId}/searchImageSets");
784
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
785
- const query = (0, import_smithy_client.map)({
786
- [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
787
- [_nT]: [, input[_nT]]
788
- });
789
- let body;
790
- if (input.searchCriteria !== void 0) {
791
- body = se_SearchCriteria(input.searchCriteria, context);
792
- }
793
- if (body === void 0) {
794
- body = {};
795
- }
796
- body = JSON.stringify(body);
797
- let { hostname: resolvedHostname } = await context.endpoint();
798
- if (context.disableHostPrefix !== true) {
799
- resolvedHostname = "runtime-" + resolvedHostname;
800
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
801
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
504
+ body = JSON.stringify(body);
505
+ let { hostname: resolvedHostname } = await context.endpoint();
506
+ if (context.disableHostPrefix !== true) {
507
+ resolvedHostname = "runtime-" + resolvedHostname;
508
+ if (!protocolHttp.isValidHostname(resolvedHostname)) {
509
+ throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
510
+ }
802
511
  }
803
- }
804
- b.hn(resolvedHostname);
805
- b.m("POST").h(headers).q(query).b(body);
806
- return b.build();
807
- }, "se_SearchImageSetsCommand");
808
- var se_StartDICOMImportJobCommand = /* @__PURE__ */ __name(async (input, context) => {
809
- const b = (0, import_core.requestBuilder)(input, context);
810
- const headers = {
811
- "content-type": "application/json"
812
- };
813
- b.bp("/startDICOMImportJob/datastore/{datastoreId}");
814
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
815
- let body;
816
- body = JSON.stringify(
817
- (0, import_smithy_client.take)(input, {
818
- clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
819
- dataAccessRoleArn: [],
820
- inputOwnerAccountId: [],
821
- inputS3Uri: [],
822
- jobName: [],
823
- outputS3Uri: []
824
- })
825
- );
826
- b.m("POST").h(headers).b(body);
827
- return b.build();
828
- }, "se_StartDICOMImportJobCommand");
829
- var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
830
- const b = (0, import_core.requestBuilder)(input, context);
831
- const headers = {
832
- "content-type": "application/json"
833
- };
834
- b.bp("/tags/{resourceArn}");
835
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
836
- let body;
837
- body = JSON.stringify(
838
- (0, import_smithy_client.take)(input, {
839
- tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tags")
840
- })
841
- );
842
- b.m("POST").h(headers).b(body);
843
- return b.build();
844
- }, "se_TagResourceCommand");
845
- var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
846
- const b = (0, import_core.requestBuilder)(input, context);
847
- const headers = {};
848
- b.bp("/tags/{resourceArn}");
849
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
850
- const query = (0, import_smithy_client.map)({
851
- [_tK]: [(0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []]
852
- });
853
- let body;
854
- b.m("DELETE").h(headers).q(query).b(body);
855
- return b.build();
856
- }, "se_UntagResourceCommand");
857
- var se_UpdateImageSetMetadataCommand = /* @__PURE__ */ __name(async (input, context) => {
858
- const b = (0, import_core.requestBuilder)(input, context);
859
- const headers = {
860
- "content-type": "application/json"
861
- };
862
- b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/updateImageSetMetadata");
863
- b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
864
- b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
865
- const query = (0, import_smithy_client.map)({
866
- [_lV]: [, (0, import_smithy_client.expectNonNull)(input[_lVI], `latestVersionId`)],
867
- [_f]: [() => input.force !== void 0, () => input[_f].toString()]
868
- });
869
- let body;
870
- if (input.updateImageSetMetadataUpdates !== void 0) {
871
- body = se_MetadataUpdates(input.updateImageSetMetadataUpdates, context);
872
- }
873
- if (body === void 0) {
874
- body = {};
875
- }
876
- body = JSON.stringify(body);
877
- let { hostname: resolvedHostname } = await context.endpoint();
878
- if (context.disableHostPrefix !== true) {
879
- resolvedHostname = "runtime-" + resolvedHostname;
880
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
881
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
512
+ b.hn(resolvedHostname);
513
+ b.m("POST").h(headers).b(body);
514
+ return b.build();
515
+ };
516
+ const se_GetImageSetCommand = async (input, context) => {
517
+ const b = core.requestBuilder(input, context);
518
+ const headers = {};
519
+ b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/getImageSet");
520
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
521
+ b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
522
+ const query = smithyClient.map({
523
+ [_v]: [, input[_vI]],
524
+ });
525
+ let body;
526
+ let { hostname: resolvedHostname } = await context.endpoint();
527
+ if (context.disableHostPrefix !== true) {
528
+ resolvedHostname = "runtime-" + resolvedHostname;
529
+ if (!protocolHttp.isValidHostname(resolvedHostname)) {
530
+ throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
531
+ }
882
532
  }
883
- }
884
- b.hn(resolvedHostname);
885
- b.m("POST").h(headers).q(query).b(body);
886
- return b.build();
887
- }, "se_UpdateImageSetMetadataCommand");
888
- var de_CopyImageSetCommand = /* @__PURE__ */ __name(async (output, context) => {
889
- if (output.statusCode !== 200 && output.statusCode >= 300) {
890
- return de_CommandError(output, context);
891
- }
892
- const contents = (0, import_smithy_client.map)({
893
- $metadata: deserializeMetadata(output)
894
- });
895
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
896
- const doc = (0, import_smithy_client.take)(data, {
897
- datastoreId: import_smithy_client.expectString,
898
- destinationImageSetProperties: /* @__PURE__ */ __name((_) => de_CopyDestinationImageSetProperties(_, context), "destinationImageSetProperties"),
899
- sourceImageSetProperties: /* @__PURE__ */ __name((_) => de_CopySourceImageSetProperties(_, context), "sourceImageSetProperties")
900
- });
901
- Object.assign(contents, doc);
902
- return contents;
903
- }, "de_CopyImageSetCommand");
904
- var de_CreateDatastoreCommand = /* @__PURE__ */ __name(async (output, context) => {
905
- if (output.statusCode !== 200 && output.statusCode >= 300) {
906
- return de_CommandError(output, context);
907
- }
908
- const contents = (0, import_smithy_client.map)({
909
- $metadata: deserializeMetadata(output)
910
- });
911
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
912
- const doc = (0, import_smithy_client.take)(data, {
913
- datastoreId: import_smithy_client.expectString,
914
- datastoreStatus: import_smithy_client.expectString
915
- });
916
- Object.assign(contents, doc);
917
- return contents;
918
- }, "de_CreateDatastoreCommand");
919
- var de_DeleteDatastoreCommand = /* @__PURE__ */ __name(async (output, context) => {
920
- if (output.statusCode !== 200 && output.statusCode >= 300) {
921
- return de_CommandError(output, context);
922
- }
923
- const contents = (0, import_smithy_client.map)({
924
- $metadata: deserializeMetadata(output)
925
- });
926
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
927
- const doc = (0, import_smithy_client.take)(data, {
928
- datastoreId: import_smithy_client.expectString,
929
- datastoreStatus: import_smithy_client.expectString
930
- });
931
- Object.assign(contents, doc);
932
- return contents;
933
- }, "de_DeleteDatastoreCommand");
934
- var de_DeleteImageSetCommand = /* @__PURE__ */ __name(async (output, context) => {
935
- if (output.statusCode !== 200 && output.statusCode >= 300) {
936
- return de_CommandError(output, context);
937
- }
938
- const contents = (0, import_smithy_client.map)({
939
- $metadata: deserializeMetadata(output)
940
- });
941
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
942
- const doc = (0, import_smithy_client.take)(data, {
943
- datastoreId: import_smithy_client.expectString,
944
- imageSetId: import_smithy_client.expectString,
945
- imageSetState: import_smithy_client.expectString,
946
- imageSetWorkflowStatus: import_smithy_client.expectString
947
- });
948
- Object.assign(contents, doc);
949
- return contents;
950
- }, "de_DeleteImageSetCommand");
951
- var de_GetDatastoreCommand = /* @__PURE__ */ __name(async (output, context) => {
952
- if (output.statusCode !== 200 && output.statusCode >= 300) {
953
- return de_CommandError(output, context);
954
- }
955
- const contents = (0, import_smithy_client.map)({
956
- $metadata: deserializeMetadata(output)
957
- });
958
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
959
- const doc = (0, import_smithy_client.take)(data, {
960
- datastoreProperties: /* @__PURE__ */ __name((_) => de_DatastoreProperties(_, context), "datastoreProperties")
961
- });
962
- Object.assign(contents, doc);
963
- return contents;
964
- }, "de_GetDatastoreCommand");
965
- var de_GetDICOMImportJobCommand = /* @__PURE__ */ __name(async (output, context) => {
966
- if (output.statusCode !== 200 && output.statusCode >= 300) {
967
- return de_CommandError(output, context);
968
- }
969
- const contents = (0, import_smithy_client.map)({
970
- $metadata: deserializeMetadata(output)
971
- });
972
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
973
- const doc = (0, import_smithy_client.take)(data, {
974
- jobProperties: /* @__PURE__ */ __name((_) => de_DICOMImportJobProperties(_, context), "jobProperties")
975
- });
976
- Object.assign(contents, doc);
977
- return contents;
978
- }, "de_GetDICOMImportJobCommand");
979
- var de_GetImageFrameCommand = /* @__PURE__ */ __name(async (output, context) => {
980
- if (output.statusCode !== 200 && output.statusCode >= 300) {
981
- return de_CommandError(output, context);
982
- }
983
- const contents = (0, import_smithy_client.map)({
984
- $metadata: deserializeMetadata(output),
985
- [_cT]: [, output.headers[_ct]]
986
- });
987
- const data = output.body;
988
- context.sdkStreamMixin(data);
989
- contents.imageFrameBlob = data;
990
- return contents;
991
- }, "de_GetImageFrameCommand");
992
- var de_GetImageSetCommand = /* @__PURE__ */ __name(async (output, context) => {
993
- if (output.statusCode !== 200 && output.statusCode >= 300) {
994
- return de_CommandError(output, context);
995
- }
996
- const contents = (0, import_smithy_client.map)({
997
- $metadata: deserializeMetadata(output)
998
- });
999
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1000
- const doc = (0, import_smithy_client.take)(data, {
1001
- createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
1002
- datastoreId: import_smithy_client.expectString,
1003
- deletedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "deletedAt"),
1004
- imageSetArn: import_smithy_client.expectString,
1005
- imageSetId: import_smithy_client.expectString,
1006
- imageSetState: import_smithy_client.expectString,
1007
- imageSetWorkflowStatus: import_smithy_client.expectString,
1008
- isPrimary: import_smithy_client.expectBoolean,
1009
- message: import_smithy_client.expectString,
1010
- overrides: import_smithy_client._json,
1011
- updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt"),
1012
- versionId: import_smithy_client.expectString
1013
- });
1014
- Object.assign(contents, doc);
1015
- return contents;
1016
- }, "de_GetImageSetCommand");
1017
- var de_GetImageSetMetadataCommand = /* @__PURE__ */ __name(async (output, context) => {
1018
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1019
- return de_CommandError(output, context);
1020
- }
1021
- const contents = (0, import_smithy_client.map)({
1022
- $metadata: deserializeMetadata(output),
1023
- [_cT]: [, output.headers[_ct]],
1024
- [_cE]: [, output.headers[_ce]]
1025
- });
1026
- const data = output.body;
1027
- context.sdkStreamMixin(data);
1028
- contents.imageSetMetadataBlob = data;
1029
- return contents;
1030
- }, "de_GetImageSetMetadataCommand");
1031
- var de_ListDatastoresCommand = /* @__PURE__ */ __name(async (output, context) => {
1032
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1033
- return de_CommandError(output, context);
1034
- }
1035
- const contents = (0, import_smithy_client.map)({
1036
- $metadata: deserializeMetadata(output)
1037
- });
1038
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1039
- const doc = (0, import_smithy_client.take)(data, {
1040
- datastoreSummaries: /* @__PURE__ */ __name((_) => de_DatastoreSummaries(_, context), "datastoreSummaries"),
1041
- nextToken: import_smithy_client.expectString
1042
- });
1043
- Object.assign(contents, doc);
1044
- return contents;
1045
- }, "de_ListDatastoresCommand");
1046
- var de_ListDICOMImportJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
1047
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1048
- return de_CommandError(output, context);
1049
- }
1050
- const contents = (0, import_smithy_client.map)({
1051
- $metadata: deserializeMetadata(output)
1052
- });
1053
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1054
- const doc = (0, import_smithy_client.take)(data, {
1055
- jobSummaries: /* @__PURE__ */ __name((_) => de_DICOMImportJobSummaries(_, context), "jobSummaries"),
1056
- nextToken: import_smithy_client.expectString
1057
- });
1058
- Object.assign(contents, doc);
1059
- return contents;
1060
- }, "de_ListDICOMImportJobsCommand");
1061
- var de_ListImageSetVersionsCommand = /* @__PURE__ */ __name(async (output, context) => {
1062
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1063
- return de_CommandError(output, context);
1064
- }
1065
- const contents = (0, import_smithy_client.map)({
1066
- $metadata: deserializeMetadata(output)
1067
- });
1068
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1069
- const doc = (0, import_smithy_client.take)(data, {
1070
- imageSetPropertiesList: /* @__PURE__ */ __name((_) => de_ImageSetPropertiesList(_, context), "imageSetPropertiesList"),
1071
- nextToken: import_smithy_client.expectString
1072
- });
1073
- Object.assign(contents, doc);
1074
- return contents;
1075
- }, "de_ListImageSetVersionsCommand");
1076
- var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1077
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1078
- return de_CommandError(output, context);
1079
- }
1080
- const contents = (0, import_smithy_client.map)({
1081
- $metadata: deserializeMetadata(output)
1082
- });
1083
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1084
- const doc = (0, import_smithy_client.take)(data, {
1085
- tags: import_smithy_client._json
1086
- });
1087
- Object.assign(contents, doc);
1088
- return contents;
1089
- }, "de_ListTagsForResourceCommand");
1090
- var de_SearchImageSetsCommand = /* @__PURE__ */ __name(async (output, context) => {
1091
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1092
- return de_CommandError(output, context);
1093
- }
1094
- const contents = (0, import_smithy_client.map)({
1095
- $metadata: deserializeMetadata(output)
1096
- });
1097
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1098
- const doc = (0, import_smithy_client.take)(data, {
1099
- imageSetsMetadataSummaries: /* @__PURE__ */ __name((_) => de_ImageSetsMetadataSummaries(_, context), "imageSetsMetadataSummaries"),
1100
- nextToken: import_smithy_client.expectString,
1101
- sort: import_smithy_client._json
1102
- });
1103
- Object.assign(contents, doc);
1104
- return contents;
1105
- }, "de_SearchImageSetsCommand");
1106
- var de_StartDICOMImportJobCommand = /* @__PURE__ */ __name(async (output, context) => {
1107
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1108
- return de_CommandError(output, context);
1109
- }
1110
- const contents = (0, import_smithy_client.map)({
1111
- $metadata: deserializeMetadata(output)
1112
- });
1113
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1114
- const doc = (0, import_smithy_client.take)(data, {
1115
- datastoreId: import_smithy_client.expectString,
1116
- jobId: import_smithy_client.expectString,
1117
- jobStatus: import_smithy_client.expectString,
1118
- submittedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "submittedAt")
1119
- });
1120
- Object.assign(contents, doc);
1121
- return contents;
1122
- }, "de_StartDICOMImportJobCommand");
1123
- var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1124
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1125
- return de_CommandError(output, context);
1126
- }
1127
- const contents = (0, import_smithy_client.map)({
1128
- $metadata: deserializeMetadata(output)
1129
- });
1130
- await (0, import_smithy_client.collectBody)(output.body, context);
1131
- return contents;
1132
- }, "de_TagResourceCommand");
1133
- var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1134
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1135
- return de_CommandError(output, context);
1136
- }
1137
- const contents = (0, import_smithy_client.map)({
1138
- $metadata: deserializeMetadata(output)
1139
- });
1140
- await (0, import_smithy_client.collectBody)(output.body, context);
1141
- return contents;
1142
- }, "de_UntagResourceCommand");
1143
- var de_UpdateImageSetMetadataCommand = /* @__PURE__ */ __name(async (output, context) => {
1144
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1145
- return de_CommandError(output, context);
1146
- }
1147
- const contents = (0, import_smithy_client.map)({
1148
- $metadata: deserializeMetadata(output)
1149
- });
1150
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1151
- const doc = (0, import_smithy_client.take)(data, {
1152
- createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
1153
- datastoreId: import_smithy_client.expectString,
1154
- imageSetId: import_smithy_client.expectString,
1155
- imageSetState: import_smithy_client.expectString,
1156
- imageSetWorkflowStatus: import_smithy_client.expectString,
1157
- latestVersionId: import_smithy_client.expectString,
1158
- message: import_smithy_client.expectString,
1159
- updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt")
1160
- });
1161
- Object.assign(contents, doc);
1162
- return contents;
1163
- }, "de_UpdateImageSetMetadataCommand");
1164
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
1165
- const parsedOutput = {
1166
- ...output,
1167
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
1168
- };
1169
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
1170
- switch (errorCode) {
1171
- case "AccessDeniedException":
1172
- case "com.amazonaws.medicalimaging#AccessDeniedException":
1173
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1174
- case "ConflictException":
1175
- case "com.amazonaws.medicalimaging#ConflictException":
1176
- throw await de_ConflictExceptionRes(parsedOutput, context);
1177
- case "InternalServerException":
1178
- case "com.amazonaws.medicalimaging#InternalServerException":
1179
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1180
- case "ResourceNotFoundException":
1181
- case "com.amazonaws.medicalimaging#ResourceNotFoundException":
1182
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1183
- case "ServiceQuotaExceededException":
1184
- case "com.amazonaws.medicalimaging#ServiceQuotaExceededException":
1185
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1186
- case "ThrottlingException":
1187
- case "com.amazonaws.medicalimaging#ThrottlingException":
1188
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1189
- case "ValidationException":
1190
- case "com.amazonaws.medicalimaging#ValidationException":
1191
- throw await de_ValidationExceptionRes(parsedOutput, context);
1192
- default:
1193
- const parsedBody = parsedOutput.body;
1194
- return throwDefaultError({
1195
- output,
1196
- parsedBody,
1197
- errorCode
1198
- });
1199
- }
1200
- }, "de_CommandError");
1201
- var throwDefaultError = (0, import_smithy_client.withBaseException)(MedicalImagingServiceException);
1202
- var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1203
- const contents = (0, import_smithy_client.map)({});
1204
- const data = parsedOutput.body;
1205
- const doc = (0, import_smithy_client.take)(data, {
1206
- message: import_smithy_client.expectString
1207
- });
1208
- Object.assign(contents, doc);
1209
- const exception = new AccessDeniedException({
1210
- $metadata: deserializeMetadata(parsedOutput),
1211
- ...contents
1212
- });
1213
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1214
- }, "de_AccessDeniedExceptionRes");
1215
- var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1216
- const contents = (0, import_smithy_client.map)({});
1217
- const data = parsedOutput.body;
1218
- const doc = (0, import_smithy_client.take)(data, {
1219
- message: import_smithy_client.expectString
1220
- });
1221
- Object.assign(contents, doc);
1222
- const exception = new ConflictException({
1223
- $metadata: deserializeMetadata(parsedOutput),
1224
- ...contents
1225
- });
1226
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1227
- }, "de_ConflictExceptionRes");
1228
- var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1229
- const contents = (0, import_smithy_client.map)({});
1230
- const data = parsedOutput.body;
1231
- const doc = (0, import_smithy_client.take)(data, {
1232
- message: import_smithy_client.expectString
1233
- });
1234
- Object.assign(contents, doc);
1235
- const exception = new InternalServerException({
1236
- $metadata: deserializeMetadata(parsedOutput),
1237
- ...contents
1238
- });
1239
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1240
- }, "de_InternalServerExceptionRes");
1241
- var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1242
- const contents = (0, import_smithy_client.map)({});
1243
- const data = parsedOutput.body;
1244
- const doc = (0, import_smithy_client.take)(data, {
1245
- message: import_smithy_client.expectString
1246
- });
1247
- Object.assign(contents, doc);
1248
- const exception = new ResourceNotFoundException({
1249
- $metadata: deserializeMetadata(parsedOutput),
1250
- ...contents
1251
- });
1252
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1253
- }, "de_ResourceNotFoundExceptionRes");
1254
- var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1255
- const contents = (0, import_smithy_client.map)({});
1256
- const data = parsedOutput.body;
1257
- const doc = (0, import_smithy_client.take)(data, {
1258
- message: import_smithy_client.expectString
1259
- });
1260
- Object.assign(contents, doc);
1261
- const exception = new ServiceQuotaExceededException({
1262
- $metadata: deserializeMetadata(parsedOutput),
1263
- ...contents
1264
- });
1265
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1266
- }, "de_ServiceQuotaExceededExceptionRes");
1267
- var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1268
- const contents = (0, import_smithy_client.map)({});
1269
- const data = parsedOutput.body;
1270
- const doc = (0, import_smithy_client.take)(data, {
1271
- message: import_smithy_client.expectString
1272
- });
1273
- Object.assign(contents, doc);
1274
- const exception = new ThrottlingException({
1275
- $metadata: deserializeMetadata(parsedOutput),
1276
- ...contents
1277
- });
1278
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1279
- }, "de_ThrottlingExceptionRes");
1280
- var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1281
- const contents = (0, import_smithy_client.map)({});
1282
- const data = parsedOutput.body;
1283
- const doc = (0, import_smithy_client.take)(data, {
1284
- message: import_smithy_client.expectString
1285
- });
1286
- Object.assign(contents, doc);
1287
- const exception = new ValidationException({
1288
- $metadata: deserializeMetadata(parsedOutput),
1289
- ...contents
1290
- });
1291
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1292
- }, "de_ValidationExceptionRes");
1293
- var se_DICOMUpdates = /* @__PURE__ */ __name((input, context) => {
1294
- return (0, import_smithy_client.take)(input, {
1295
- removableAttributes: context.base64Encoder,
1296
- updatableAttributes: context.base64Encoder
1297
- });
1298
- }, "se_DICOMUpdates");
1299
- var se_MetadataUpdates = /* @__PURE__ */ __name((input, context) => {
1300
- return MetadataUpdates.visit(input, {
1301
- DICOMUpdates: /* @__PURE__ */ __name((value) => ({ DICOMUpdates: se_DICOMUpdates(value, context) }), "DICOMUpdates"),
1302
- revertToVersionId: /* @__PURE__ */ __name((value) => ({ revertToVersionId: value }), "revertToVersionId"),
1303
- _: /* @__PURE__ */ __name((name, value) => ({ [name]: value }), "_")
1304
- });
1305
- }, "se_MetadataUpdates");
1306
- var se_SearchByAttributeValue = /* @__PURE__ */ __name((input, context) => {
1307
- return SearchByAttributeValue.visit(input, {
1308
- DICOMAccessionNumber: /* @__PURE__ */ __name((value) => ({ DICOMAccessionNumber: value }), "DICOMAccessionNumber"),
1309
- DICOMPatientId: /* @__PURE__ */ __name((value) => ({ DICOMPatientId: value }), "DICOMPatientId"),
1310
- DICOMSeriesInstanceUID: /* @__PURE__ */ __name((value) => ({ DICOMSeriesInstanceUID: value }), "DICOMSeriesInstanceUID"),
1311
- DICOMStudyDateAndTime: /* @__PURE__ */ __name((value) => ({ DICOMStudyDateAndTime: (0, import_smithy_client._json)(value) }), "DICOMStudyDateAndTime"),
1312
- DICOMStudyId: /* @__PURE__ */ __name((value) => ({ DICOMStudyId: value }), "DICOMStudyId"),
1313
- DICOMStudyInstanceUID: /* @__PURE__ */ __name((value) => ({ DICOMStudyInstanceUID: value }), "DICOMStudyInstanceUID"),
1314
- createdAt: /* @__PURE__ */ __name((value) => ({ createdAt: value.getTime() / 1e3 }), "createdAt"),
1315
- isPrimary: /* @__PURE__ */ __name((value) => ({ isPrimary: value }), "isPrimary"),
1316
- updatedAt: /* @__PURE__ */ __name((value) => ({ updatedAt: value.getTime() / 1e3 }), "updatedAt"),
1317
- _: /* @__PURE__ */ __name((name, value) => ({ [name]: value }), "_")
1318
- });
1319
- }, "se_SearchByAttributeValue");
1320
- var se_SearchByAttributeValues = /* @__PURE__ */ __name((input, context) => {
1321
- return input.filter((e) => e != null).map((entry) => {
1322
- return se_SearchByAttributeValue(entry, context);
1323
- });
1324
- }, "se_SearchByAttributeValues");
1325
- var se_SearchCriteria = /* @__PURE__ */ __name((input, context) => {
1326
- return (0, import_smithy_client.take)(input, {
1327
- filters: /* @__PURE__ */ __name((_) => se_SearchFilters(_, context), "filters"),
1328
- sort: import_smithy_client._json
1329
- });
1330
- }, "se_SearchCriteria");
1331
- var se_SearchFilter = /* @__PURE__ */ __name((input, context) => {
1332
- return (0, import_smithy_client.take)(input, {
1333
- operator: [],
1334
- values: /* @__PURE__ */ __name((_) => se_SearchByAttributeValues(_, context), "values")
1335
- });
1336
- }, "se_SearchFilter");
1337
- var se_SearchFilters = /* @__PURE__ */ __name((input, context) => {
1338
- return input.filter((e) => e != null).map((entry) => {
1339
- return se_SearchFilter(entry, context);
1340
- });
1341
- }, "se_SearchFilters");
1342
- var de_CopyDestinationImageSetProperties = /* @__PURE__ */ __name((output, context) => {
1343
- return (0, import_smithy_client.take)(output, {
1344
- createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
1345
- imageSetArn: import_smithy_client.expectString,
1346
- imageSetId: import_smithy_client.expectString,
1347
- imageSetState: import_smithy_client.expectString,
1348
- imageSetWorkflowStatus: import_smithy_client.expectString,
1349
- latestVersionId: import_smithy_client.expectString,
1350
- updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt")
1351
- });
1352
- }, "de_CopyDestinationImageSetProperties");
1353
- var de_CopySourceImageSetProperties = /* @__PURE__ */ __name((output, context) => {
1354
- return (0, import_smithy_client.take)(output, {
1355
- createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
1356
- imageSetArn: import_smithy_client.expectString,
1357
- imageSetId: import_smithy_client.expectString,
1358
- imageSetState: import_smithy_client.expectString,
1359
- imageSetWorkflowStatus: import_smithy_client.expectString,
1360
- latestVersionId: import_smithy_client.expectString,
1361
- updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt")
1362
- });
1363
- }, "de_CopySourceImageSetProperties");
1364
- var de_DatastoreProperties = /* @__PURE__ */ __name((output, context) => {
1365
- return (0, import_smithy_client.take)(output, {
1366
- createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
1367
- datastoreArn: import_smithy_client.expectString,
1368
- datastoreId: import_smithy_client.expectString,
1369
- datastoreName: import_smithy_client.expectString,
1370
- datastoreStatus: import_smithy_client.expectString,
1371
- kmsKeyArn: import_smithy_client.expectString,
1372
- lambdaAuthorizerArn: import_smithy_client.expectString,
1373
- updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt")
1374
- });
1375
- }, "de_DatastoreProperties");
1376
- var de_DatastoreSummaries = /* @__PURE__ */ __name((output, context) => {
1377
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1378
- return de_DatastoreSummary(entry, context);
1379
- });
1380
- return retVal;
1381
- }, "de_DatastoreSummaries");
1382
- var de_DatastoreSummary = /* @__PURE__ */ __name((output, context) => {
1383
- return (0, import_smithy_client.take)(output, {
1384
- createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
1385
- datastoreArn: import_smithy_client.expectString,
1386
- datastoreId: import_smithy_client.expectString,
1387
- datastoreName: import_smithy_client.expectString,
1388
- datastoreStatus: import_smithy_client.expectString,
1389
- updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt")
1390
- });
1391
- }, "de_DatastoreSummary");
1392
- var de_DICOMImportJobProperties = /* @__PURE__ */ __name((output, context) => {
1393
- return (0, import_smithy_client.take)(output, {
1394
- dataAccessRoleArn: import_smithy_client.expectString,
1395
- datastoreId: import_smithy_client.expectString,
1396
- endedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "endedAt"),
1397
- inputS3Uri: import_smithy_client.expectString,
1398
- jobId: import_smithy_client.expectString,
1399
- jobName: import_smithy_client.expectString,
1400
- jobStatus: import_smithy_client.expectString,
1401
- message: import_smithy_client.expectString,
1402
- outputS3Uri: import_smithy_client.expectString,
1403
- submittedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "submittedAt")
1404
- });
1405
- }, "de_DICOMImportJobProperties");
1406
- var de_DICOMImportJobSummaries = /* @__PURE__ */ __name((output, context) => {
1407
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1408
- return de_DICOMImportJobSummary(entry, context);
1409
- });
1410
- return retVal;
1411
- }, "de_DICOMImportJobSummaries");
1412
- var de_DICOMImportJobSummary = /* @__PURE__ */ __name((output, context) => {
1413
- return (0, import_smithy_client.take)(output, {
1414
- dataAccessRoleArn: import_smithy_client.expectString,
1415
- datastoreId: import_smithy_client.expectString,
1416
- endedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "endedAt"),
1417
- jobId: import_smithy_client.expectString,
1418
- jobName: import_smithy_client.expectString,
1419
- jobStatus: import_smithy_client.expectString,
1420
- message: import_smithy_client.expectString,
1421
- submittedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "submittedAt")
1422
- });
1423
- }, "de_DICOMImportJobSummary");
1424
- var de_ImageSetProperties = /* @__PURE__ */ __name((output, context) => {
1425
- return (0, import_smithy_client.take)(output, {
1426
- ImageSetWorkflowStatus: import_smithy_client.expectString,
1427
- createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
1428
- deletedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "deletedAt"),
1429
- imageSetId: import_smithy_client.expectString,
1430
- imageSetState: import_smithy_client.expectString,
1431
- isPrimary: import_smithy_client.expectBoolean,
1432
- message: import_smithy_client.expectString,
1433
- overrides: import_smithy_client._json,
1434
- updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt"),
1435
- versionId: import_smithy_client.expectString
1436
- });
1437
- }, "de_ImageSetProperties");
1438
- var de_ImageSetPropertiesList = /* @__PURE__ */ __name((output, context) => {
1439
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1440
- return de_ImageSetProperties(entry, context);
1441
- });
1442
- return retVal;
1443
- }, "de_ImageSetPropertiesList");
1444
- var de_ImageSetsMetadataSummaries = /* @__PURE__ */ __name((output, context) => {
1445
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1446
- return de_ImageSetsMetadataSummary(entry, context);
1447
- });
1448
- return retVal;
1449
- }, "de_ImageSetsMetadataSummaries");
1450
- var de_ImageSetsMetadataSummary = /* @__PURE__ */ __name((output, context) => {
1451
- return (0, import_smithy_client.take)(output, {
1452
- DICOMTags: import_smithy_client._json,
1453
- createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
1454
- imageSetId: import_smithy_client.expectString,
1455
- isPrimary: import_smithy_client.expectBoolean,
1456
- updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt"),
1457
- version: import_smithy_client.expectInt32
1458
- });
1459
- }, "de_ImageSetsMetadataSummary");
1460
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
1461
- httpStatusCode: output.statusCode,
1462
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1463
- extendedRequestId: output.headers["x-amz-id-2"],
1464
- cfId: output.headers["x-amz-cf-id"]
1465
- }), "deserializeMetadata");
1466
- var _cE = "contentEncoding";
1467
- var _cT = "contentType";
1468
- var _ce = "content-encoding";
1469
- var _ct = "content-type";
1470
- var _dS = "datastoreStatus";
1471
- var _f = "force";
1472
- var _jS = "jobStatus";
1473
- var _lV = "latestVersion";
1474
- var _lVI = "latestVersionId";
1475
- var _mR = "maxResults";
1476
- var _nT = "nextToken";
1477
- var _pTP = "promoteToPrimary";
1478
- var _tK = "tagKeys";
1479
- var _v = "version";
1480
- var _vI = "versionId";
1481
-
1482
- // src/commands/CopyImageSetCommand.ts
1483
- var CopyImageSetCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1484
- return [
1485
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1486
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1487
- ];
1488
- }).s("AHIGatewayService", "CopyImageSet", {}).n("MedicalImagingClient", "CopyImageSetCommand").f(CopyImageSetRequestFilterSensitiveLog, void 0).ser(se_CopyImageSetCommand).de(de_CopyImageSetCommand).build() {
1489
- static {
1490
- __name(this, "CopyImageSetCommand");
1491
- }
533
+ b.hn(resolvedHostname);
534
+ b.m("POST").h(headers).q(query).b(body);
535
+ return b.build();
1492
536
  };
1493
-
1494
- // src/commands/CreateDatastoreCommand.ts
1495
-
1496
-
1497
-
1498
- var CreateDatastoreCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1499
- return [
1500
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1501
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1502
- ];
1503
- }).s("AHIGatewayService", "CreateDatastore", {}).n("MedicalImagingClient", "CreateDatastoreCommand").f(void 0, void 0).ser(se_CreateDatastoreCommand).de(de_CreateDatastoreCommand).build() {
1504
- static {
1505
- __name(this, "CreateDatastoreCommand");
1506
- }
537
+ const se_GetImageSetMetadataCommand = async (input, context) => {
538
+ const b = core.requestBuilder(input, context);
539
+ const headers = {};
540
+ b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/getImageSetMetadata");
541
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
542
+ b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
543
+ const query = smithyClient.map({
544
+ [_v]: [, input[_vI]],
545
+ });
546
+ let body;
547
+ let { hostname: resolvedHostname } = await context.endpoint();
548
+ if (context.disableHostPrefix !== true) {
549
+ resolvedHostname = "runtime-" + resolvedHostname;
550
+ if (!protocolHttp.isValidHostname(resolvedHostname)) {
551
+ throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
552
+ }
553
+ }
554
+ b.hn(resolvedHostname);
555
+ b.m("POST").h(headers).q(query).b(body);
556
+ return b.build();
1507
557
  };
1508
-
1509
- // src/commands/DeleteDatastoreCommand.ts
1510
-
1511
-
1512
-
1513
- var DeleteDatastoreCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1514
- return [
1515
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1516
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1517
- ];
1518
- }).s("AHIGatewayService", "DeleteDatastore", {}).n("MedicalImagingClient", "DeleteDatastoreCommand").f(void 0, void 0).ser(se_DeleteDatastoreCommand).de(de_DeleteDatastoreCommand).build() {
1519
- static {
1520
- __name(this, "DeleteDatastoreCommand");
1521
- }
558
+ const se_ListDatastoresCommand = async (input, context) => {
559
+ const b = core.requestBuilder(input, context);
560
+ const headers = {};
561
+ b.bp("/datastore");
562
+ const query = smithyClient.map({
563
+ [_dS]: [, input[_dS]],
564
+ [_nT]: [, input[_nT]],
565
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
566
+ });
567
+ let body;
568
+ b.m("GET").h(headers).q(query).b(body);
569
+ return b.build();
1522
570
  };
1523
-
1524
- // src/commands/DeleteImageSetCommand.ts
1525
-
1526
-
1527
-
1528
- var DeleteImageSetCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1529
- return [
1530
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1531
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1532
- ];
1533
- }).s("AHIGatewayService", "DeleteImageSet", {}).n("MedicalImagingClient", "DeleteImageSetCommand").f(void 0, void 0).ser(se_DeleteImageSetCommand).de(de_DeleteImageSetCommand).build() {
1534
- static {
1535
- __name(this, "DeleteImageSetCommand");
1536
- }
571
+ const se_ListDICOMImportJobsCommand = async (input, context) => {
572
+ const b = core.requestBuilder(input, context);
573
+ const headers = {};
574
+ b.bp("/listDICOMImportJobs/datastore/{datastoreId}");
575
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
576
+ const query = smithyClient.map({
577
+ [_jS]: [, input[_jS]],
578
+ [_nT]: [, input[_nT]],
579
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
580
+ });
581
+ let body;
582
+ b.m("GET").h(headers).q(query).b(body);
583
+ return b.build();
1537
584
  };
1538
-
1539
- // src/commands/GetDatastoreCommand.ts
1540
-
1541
-
1542
-
1543
- var GetDatastoreCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1544
- return [
1545
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1546
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1547
- ];
1548
- }).s("AHIGatewayService", "GetDatastore", {}).n("MedicalImagingClient", "GetDatastoreCommand").f(void 0, void 0).ser(se_GetDatastoreCommand).de(de_GetDatastoreCommand).build() {
1549
- static {
1550
- __name(this, "GetDatastoreCommand");
1551
- }
585
+ const se_ListImageSetVersionsCommand = async (input, context) => {
586
+ const b = core.requestBuilder(input, context);
587
+ const headers = {};
588
+ b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/listImageSetVersions");
589
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
590
+ b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
591
+ const query = smithyClient.map({
592
+ [_nT]: [, input[_nT]],
593
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
594
+ });
595
+ let body;
596
+ let { hostname: resolvedHostname } = await context.endpoint();
597
+ if (context.disableHostPrefix !== true) {
598
+ resolvedHostname = "runtime-" + resolvedHostname;
599
+ if (!protocolHttp.isValidHostname(resolvedHostname)) {
600
+ throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
601
+ }
602
+ }
603
+ b.hn(resolvedHostname);
604
+ b.m("POST").h(headers).q(query).b(body);
605
+ return b.build();
1552
606
  };
1553
-
1554
- // src/commands/GetDICOMImportJobCommand.ts
1555
-
1556
-
1557
-
1558
- var GetDICOMImportJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1559
- return [
1560
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1561
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1562
- ];
1563
- }).s("AHIGatewayService", "GetDICOMImportJob", {}).n("MedicalImagingClient", "GetDICOMImportJobCommand").f(void 0, void 0).ser(se_GetDICOMImportJobCommand).de(de_GetDICOMImportJobCommand).build() {
1564
- static {
1565
- __name(this, "GetDICOMImportJobCommand");
1566
- }
607
+ const se_ListTagsForResourceCommand = async (input, context) => {
608
+ const b = core.requestBuilder(input, context);
609
+ const headers = {};
610
+ b.bp("/tags/{resourceArn}");
611
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
612
+ let body;
613
+ b.m("GET").h(headers).b(body);
614
+ return b.build();
1567
615
  };
1568
-
1569
- // src/commands/GetImageFrameCommand.ts
1570
-
1571
-
1572
-
1573
- var GetImageFrameCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1574
- return [
1575
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1576
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1577
- ];
1578
- }).s("AHIGatewayService", "GetImageFrame", {}).n("MedicalImagingClient", "GetImageFrameCommand").f(void 0, GetImageFrameResponseFilterSensitiveLog).ser(se_GetImageFrameCommand).de(de_GetImageFrameCommand).build() {
1579
- static {
1580
- __name(this, "GetImageFrameCommand");
1581
- }
616
+ const se_SearchImageSetsCommand = async (input, context) => {
617
+ const b = core.requestBuilder(input, context);
618
+ const headers = {
619
+ "content-type": "application/json",
620
+ };
621
+ b.bp("/datastore/{datastoreId}/searchImageSets");
622
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
623
+ const query = smithyClient.map({
624
+ [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
625
+ [_nT]: [, input[_nT]],
626
+ });
627
+ let body;
628
+ if (input.searchCriteria !== undefined) {
629
+ body = se_SearchCriteria(input.searchCriteria);
630
+ }
631
+ if (body === undefined) {
632
+ body = {};
633
+ }
634
+ body = JSON.stringify(body);
635
+ let { hostname: resolvedHostname } = await context.endpoint();
636
+ if (context.disableHostPrefix !== true) {
637
+ resolvedHostname = "runtime-" + resolvedHostname;
638
+ if (!protocolHttp.isValidHostname(resolvedHostname)) {
639
+ throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
640
+ }
641
+ }
642
+ b.hn(resolvedHostname);
643
+ b.m("POST").h(headers).q(query).b(body);
644
+ return b.build();
1582
645
  };
1583
-
1584
- // src/commands/GetImageSetCommand.ts
1585
-
1586
-
1587
-
1588
- var GetImageSetCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1589
- return [
1590
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1591
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1592
- ];
1593
- }).s("AHIGatewayService", "GetImageSet", {}).n("MedicalImagingClient", "GetImageSetCommand").f(void 0, void 0).ser(se_GetImageSetCommand).de(de_GetImageSetCommand).build() {
1594
- static {
1595
- __name(this, "GetImageSetCommand");
1596
- }
646
+ const se_StartDICOMImportJobCommand = async (input, context) => {
647
+ const b = core.requestBuilder(input, context);
648
+ const headers = {
649
+ "content-type": "application/json",
650
+ };
651
+ b.bp("/startDICOMImportJob/datastore/{datastoreId}");
652
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
653
+ let body;
654
+ body = JSON.stringify(smithyClient.take(input, {
655
+ clientToken: [true, (_) => _ ?? uuid.v4()],
656
+ dataAccessRoleArn: [],
657
+ inputOwnerAccountId: [],
658
+ inputS3Uri: [],
659
+ jobName: [],
660
+ outputS3Uri: [],
661
+ }));
662
+ b.m("POST").h(headers).b(body);
663
+ return b.build();
1597
664
  };
1598
-
1599
- // src/commands/GetImageSetMetadataCommand.ts
1600
-
1601
-
1602
-
1603
- var GetImageSetMetadataCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1604
- return [
1605
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1606
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1607
- ];
1608
- }).s("AHIGatewayService", "GetImageSetMetadata", {}).n("MedicalImagingClient", "GetImageSetMetadataCommand").f(void 0, GetImageSetMetadataResponseFilterSensitiveLog).ser(se_GetImageSetMetadataCommand).de(de_GetImageSetMetadataCommand).build() {
1609
- static {
1610
- __name(this, "GetImageSetMetadataCommand");
1611
- }
665
+ const se_TagResourceCommand = async (input, context) => {
666
+ const b = core.requestBuilder(input, context);
667
+ const headers = {
668
+ "content-type": "application/json",
669
+ };
670
+ b.bp("/tags/{resourceArn}");
671
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
672
+ let body;
673
+ body = JSON.stringify(smithyClient.take(input, {
674
+ tags: (_) => smithyClient._json(_),
675
+ }));
676
+ b.m("POST").h(headers).b(body);
677
+ return b.build();
1612
678
  };
1613
-
1614
- // src/commands/ListDatastoresCommand.ts
1615
-
1616
-
1617
-
1618
- var ListDatastoresCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1619
- return [
1620
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1621
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1622
- ];
1623
- }).s("AHIGatewayService", "ListDatastores", {}).n("MedicalImagingClient", "ListDatastoresCommand").f(void 0, void 0).ser(se_ListDatastoresCommand).de(de_ListDatastoresCommand).build() {
1624
- static {
1625
- __name(this, "ListDatastoresCommand");
1626
- }
679
+ const se_UntagResourceCommand = async (input, context) => {
680
+ const b = core.requestBuilder(input, context);
681
+ const headers = {};
682
+ b.bp("/tags/{resourceArn}");
683
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
684
+ const query = smithyClient.map({
685
+ [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
686
+ });
687
+ let body;
688
+ b.m("DELETE").h(headers).q(query).b(body);
689
+ return b.build();
1627
690
  };
1628
-
1629
- // src/commands/ListDICOMImportJobsCommand.ts
1630
-
1631
-
1632
-
1633
- var ListDICOMImportJobsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1634
- return [
1635
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1636
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1637
- ];
1638
- }).s("AHIGatewayService", "ListDICOMImportJobs", {}).n("MedicalImagingClient", "ListDICOMImportJobsCommand").f(void 0, void 0).ser(se_ListDICOMImportJobsCommand).de(de_ListDICOMImportJobsCommand).build() {
1639
- static {
1640
- __name(this, "ListDICOMImportJobsCommand");
1641
- }
691
+ const se_UpdateImageSetMetadataCommand = async (input, context) => {
692
+ const b = core.requestBuilder(input, context);
693
+ const headers = {
694
+ "content-type": "application/json",
695
+ };
696
+ b.bp("/datastore/{datastoreId}/imageSet/{imageSetId}/updateImageSetMetadata");
697
+ b.p("datastoreId", () => input.datastoreId, "{datastoreId}", false);
698
+ b.p("imageSetId", () => input.imageSetId, "{imageSetId}", false);
699
+ const query = smithyClient.map({
700
+ [_lV]: [, smithyClient.expectNonNull(input[_lVI], `latestVersionId`)],
701
+ [_f]: [() => input.force !== void 0, () => input[_f].toString()],
702
+ });
703
+ let body;
704
+ if (input.updateImageSetMetadataUpdates !== undefined) {
705
+ body = se_MetadataUpdates(input.updateImageSetMetadataUpdates, context);
706
+ }
707
+ if (body === undefined) {
708
+ body = {};
709
+ }
710
+ body = JSON.stringify(body);
711
+ let { hostname: resolvedHostname } = await context.endpoint();
712
+ if (context.disableHostPrefix !== true) {
713
+ resolvedHostname = "runtime-" + resolvedHostname;
714
+ if (!protocolHttp.isValidHostname(resolvedHostname)) {
715
+ throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
716
+ }
717
+ }
718
+ b.hn(resolvedHostname);
719
+ b.m("POST").h(headers).q(query).b(body);
720
+ return b.build();
1642
721
  };
1643
-
1644
- // src/commands/ListImageSetVersionsCommand.ts
1645
-
1646
-
1647
-
1648
- var ListImageSetVersionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1649
- return [
1650
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1651
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1652
- ];
1653
- }).s("AHIGatewayService", "ListImageSetVersions", {}).n("MedicalImagingClient", "ListImageSetVersionsCommand").f(void 0, void 0).ser(se_ListImageSetVersionsCommand).de(de_ListImageSetVersionsCommand).build() {
1654
- static {
1655
- __name(this, "ListImageSetVersionsCommand");
1656
- }
722
+ const de_CopyImageSetCommand = async (output, context) => {
723
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
724
+ return de_CommandError(output, context);
725
+ }
726
+ const contents = smithyClient.map({
727
+ $metadata: deserializeMetadata(output),
728
+ });
729
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
730
+ const doc = smithyClient.take(data, {
731
+ datastoreId: smithyClient.expectString,
732
+ destinationImageSetProperties: (_) => de_CopyDestinationImageSetProperties(_),
733
+ sourceImageSetProperties: (_) => de_CopySourceImageSetProperties(_),
734
+ });
735
+ Object.assign(contents, doc);
736
+ return contents;
1657
737
  };
1658
-
1659
- // src/commands/ListTagsForResourceCommand.ts
1660
-
1661
-
1662
-
1663
- var ListTagsForResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1664
- return [
1665
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1666
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1667
- ];
1668
- }).s("AHIGatewayService", "ListTagsForResource", {}).n("MedicalImagingClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
1669
- static {
1670
- __name(this, "ListTagsForResourceCommand");
1671
- }
738
+ const de_CreateDatastoreCommand = async (output, context) => {
739
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
740
+ return de_CommandError(output, context);
741
+ }
742
+ const contents = smithyClient.map({
743
+ $metadata: deserializeMetadata(output),
744
+ });
745
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
746
+ const doc = smithyClient.take(data, {
747
+ datastoreId: smithyClient.expectString,
748
+ datastoreStatus: smithyClient.expectString,
749
+ });
750
+ Object.assign(contents, doc);
751
+ return contents;
1672
752
  };
1673
-
1674
- // src/commands/SearchImageSetsCommand.ts
1675
-
1676
-
1677
-
1678
- var SearchImageSetsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1679
- return [
1680
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1681
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1682
- ];
1683
- }).s("AHIGatewayService", "SearchImageSets", {}).n("MedicalImagingClient", "SearchImageSetsCommand").f(SearchImageSetsRequestFilterSensitiveLog, SearchImageSetsResponseFilterSensitiveLog).ser(se_SearchImageSetsCommand).de(de_SearchImageSetsCommand).build() {
1684
- static {
1685
- __name(this, "SearchImageSetsCommand");
1686
- }
753
+ const de_DeleteDatastoreCommand = async (output, context) => {
754
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
755
+ return de_CommandError(output, context);
756
+ }
757
+ const contents = smithyClient.map({
758
+ $metadata: deserializeMetadata(output),
759
+ });
760
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
761
+ const doc = smithyClient.take(data, {
762
+ datastoreId: smithyClient.expectString,
763
+ datastoreStatus: smithyClient.expectString,
764
+ });
765
+ Object.assign(contents, doc);
766
+ return contents;
1687
767
  };
1688
-
1689
- // src/commands/StartDICOMImportJobCommand.ts
1690
-
1691
-
1692
-
1693
- var StartDICOMImportJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1694
- return [
1695
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1696
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1697
- ];
1698
- }).s("AHIGatewayService", "StartDICOMImportJob", {}).n("MedicalImagingClient", "StartDICOMImportJobCommand").f(void 0, void 0).ser(se_StartDICOMImportJobCommand).de(de_StartDICOMImportJobCommand).build() {
1699
- static {
1700
- __name(this, "StartDICOMImportJobCommand");
1701
- }
768
+ const de_DeleteImageSetCommand = async (output, context) => {
769
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
770
+ return de_CommandError(output, context);
771
+ }
772
+ const contents = smithyClient.map({
773
+ $metadata: deserializeMetadata(output),
774
+ });
775
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
776
+ const doc = smithyClient.take(data, {
777
+ datastoreId: smithyClient.expectString,
778
+ imageSetId: smithyClient.expectString,
779
+ imageSetState: smithyClient.expectString,
780
+ imageSetWorkflowStatus: smithyClient.expectString,
781
+ });
782
+ Object.assign(contents, doc);
783
+ return contents;
1702
784
  };
1703
-
1704
- // src/commands/TagResourceCommand.ts
1705
-
1706
-
1707
-
1708
- var TagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1709
- return [
1710
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1711
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1712
- ];
1713
- }).s("AHIGatewayService", "TagResource", {}).n("MedicalImagingClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
1714
- static {
1715
- __name(this, "TagResourceCommand");
1716
- }
785
+ const de_GetDatastoreCommand = async (output, context) => {
786
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
787
+ return de_CommandError(output, context);
788
+ }
789
+ const contents = smithyClient.map({
790
+ $metadata: deserializeMetadata(output),
791
+ });
792
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
793
+ const doc = smithyClient.take(data, {
794
+ datastoreProperties: (_) => de_DatastoreProperties(_),
795
+ });
796
+ Object.assign(contents, doc);
797
+ return contents;
1717
798
  };
1718
-
1719
- // src/commands/UntagResourceCommand.ts
1720
-
1721
-
1722
-
1723
- var UntagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1724
- return [
1725
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1726
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1727
- ];
1728
- }).s("AHIGatewayService", "UntagResource", {}).n("MedicalImagingClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
1729
- static {
1730
- __name(this, "UntagResourceCommand");
1731
- }
799
+ const de_GetDICOMImportJobCommand = async (output, context) => {
800
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
801
+ return de_CommandError(output, context);
802
+ }
803
+ const contents = smithyClient.map({
804
+ $metadata: deserializeMetadata(output),
805
+ });
806
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
807
+ const doc = smithyClient.take(data, {
808
+ jobProperties: (_) => de_DICOMImportJobProperties(_),
809
+ });
810
+ Object.assign(contents, doc);
811
+ return contents;
1732
812
  };
1733
-
1734
- // src/commands/UpdateImageSetMetadataCommand.ts
1735
-
1736
-
1737
-
1738
- var UpdateImageSetMetadataCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1739
- return [
1740
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1741
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1742
- ];
1743
- }).s("AHIGatewayService", "UpdateImageSetMetadata", {}).n("MedicalImagingClient", "UpdateImageSetMetadataCommand").f(UpdateImageSetMetadataRequestFilterSensitiveLog, void 0).ser(se_UpdateImageSetMetadataCommand).de(de_UpdateImageSetMetadataCommand).build() {
1744
- static {
1745
- __name(this, "UpdateImageSetMetadataCommand");
1746
- }
813
+ const de_GetImageFrameCommand = async (output, context) => {
814
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
815
+ return de_CommandError(output, context);
816
+ }
817
+ const contents = smithyClient.map({
818
+ $metadata: deserializeMetadata(output),
819
+ [_cT]: [, output.headers[_ct]],
820
+ });
821
+ const data = output.body;
822
+ context.sdkStreamMixin(data);
823
+ contents.imageFrameBlob = data;
824
+ return contents;
1747
825
  };
826
+ const de_GetImageSetCommand = async (output, context) => {
827
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
828
+ return de_CommandError(output, context);
829
+ }
830
+ const contents = smithyClient.map({
831
+ $metadata: deserializeMetadata(output),
832
+ });
833
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
834
+ const doc = smithyClient.take(data, {
835
+ createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
836
+ datastoreId: smithyClient.expectString,
837
+ deletedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
838
+ imageSetArn: smithyClient.expectString,
839
+ imageSetId: smithyClient.expectString,
840
+ imageSetState: smithyClient.expectString,
841
+ imageSetWorkflowStatus: smithyClient.expectString,
842
+ isPrimary: smithyClient.expectBoolean,
843
+ message: smithyClient.expectString,
844
+ overrides: smithyClient._json,
845
+ updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
846
+ versionId: smithyClient.expectString,
847
+ });
848
+ Object.assign(contents, doc);
849
+ return contents;
850
+ };
851
+ const de_GetImageSetMetadataCommand = async (output, context) => {
852
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
853
+ return de_CommandError(output, context);
854
+ }
855
+ const contents = smithyClient.map({
856
+ $metadata: deserializeMetadata(output),
857
+ [_cT]: [, output.headers[_ct]],
858
+ [_cE]: [, output.headers[_ce]],
859
+ });
860
+ const data = output.body;
861
+ context.sdkStreamMixin(data);
862
+ contents.imageSetMetadataBlob = data;
863
+ return contents;
864
+ };
865
+ const de_ListDatastoresCommand = async (output, context) => {
866
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
867
+ return de_CommandError(output, context);
868
+ }
869
+ const contents = smithyClient.map({
870
+ $metadata: deserializeMetadata(output),
871
+ });
872
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
873
+ const doc = smithyClient.take(data, {
874
+ datastoreSummaries: (_) => de_DatastoreSummaries(_),
875
+ nextToken: smithyClient.expectString,
876
+ });
877
+ Object.assign(contents, doc);
878
+ return contents;
879
+ };
880
+ const de_ListDICOMImportJobsCommand = async (output, context) => {
881
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
882
+ return de_CommandError(output, context);
883
+ }
884
+ const contents = smithyClient.map({
885
+ $metadata: deserializeMetadata(output),
886
+ });
887
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
888
+ const doc = smithyClient.take(data, {
889
+ jobSummaries: (_) => de_DICOMImportJobSummaries(_),
890
+ nextToken: smithyClient.expectString,
891
+ });
892
+ Object.assign(contents, doc);
893
+ return contents;
894
+ };
895
+ const de_ListImageSetVersionsCommand = async (output, context) => {
896
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
897
+ return de_CommandError(output, context);
898
+ }
899
+ const contents = smithyClient.map({
900
+ $metadata: deserializeMetadata(output),
901
+ });
902
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
903
+ const doc = smithyClient.take(data, {
904
+ imageSetPropertiesList: (_) => de_ImageSetPropertiesList(_),
905
+ nextToken: smithyClient.expectString,
906
+ });
907
+ Object.assign(contents, doc);
908
+ return contents;
909
+ };
910
+ const de_ListTagsForResourceCommand = async (output, context) => {
911
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
912
+ return de_CommandError(output, context);
913
+ }
914
+ const contents = smithyClient.map({
915
+ $metadata: deserializeMetadata(output),
916
+ });
917
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
918
+ const doc = smithyClient.take(data, {
919
+ tags: smithyClient._json,
920
+ });
921
+ Object.assign(contents, doc);
922
+ return contents;
923
+ };
924
+ const de_SearchImageSetsCommand = async (output, context) => {
925
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
926
+ return de_CommandError(output, context);
927
+ }
928
+ const contents = smithyClient.map({
929
+ $metadata: deserializeMetadata(output),
930
+ });
931
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
932
+ const doc = smithyClient.take(data, {
933
+ imageSetsMetadataSummaries: (_) => de_ImageSetsMetadataSummaries(_),
934
+ nextToken: smithyClient.expectString,
935
+ sort: smithyClient._json,
936
+ });
937
+ Object.assign(contents, doc);
938
+ return contents;
939
+ };
940
+ const de_StartDICOMImportJobCommand = async (output, context) => {
941
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
942
+ return de_CommandError(output, context);
943
+ }
944
+ const contents = smithyClient.map({
945
+ $metadata: deserializeMetadata(output),
946
+ });
947
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
948
+ const doc = smithyClient.take(data, {
949
+ datastoreId: smithyClient.expectString,
950
+ jobId: smithyClient.expectString,
951
+ jobStatus: smithyClient.expectString,
952
+ submittedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
953
+ });
954
+ Object.assign(contents, doc);
955
+ return contents;
956
+ };
957
+ const de_TagResourceCommand = async (output, context) => {
958
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
959
+ return de_CommandError(output, context);
960
+ }
961
+ const contents = smithyClient.map({
962
+ $metadata: deserializeMetadata(output),
963
+ });
964
+ await smithyClient.collectBody(output.body, context);
965
+ return contents;
966
+ };
967
+ const de_UntagResourceCommand = async (output, context) => {
968
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
969
+ return de_CommandError(output, context);
970
+ }
971
+ const contents = smithyClient.map({
972
+ $metadata: deserializeMetadata(output),
973
+ });
974
+ await smithyClient.collectBody(output.body, context);
975
+ return contents;
976
+ };
977
+ const de_UpdateImageSetMetadataCommand = async (output, context) => {
978
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
979
+ return de_CommandError(output, context);
980
+ }
981
+ const contents = smithyClient.map({
982
+ $metadata: deserializeMetadata(output),
983
+ });
984
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
985
+ const doc = smithyClient.take(data, {
986
+ createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
987
+ datastoreId: smithyClient.expectString,
988
+ imageSetId: smithyClient.expectString,
989
+ imageSetState: smithyClient.expectString,
990
+ imageSetWorkflowStatus: smithyClient.expectString,
991
+ latestVersionId: smithyClient.expectString,
992
+ message: smithyClient.expectString,
993
+ updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
994
+ });
995
+ Object.assign(contents, doc);
996
+ return contents;
997
+ };
998
+ const de_CommandError = async (output, context) => {
999
+ const parsedOutput = {
1000
+ ...output,
1001
+ body: await core$1.parseJsonErrorBody(output.body, context),
1002
+ };
1003
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
1004
+ switch (errorCode) {
1005
+ case "AccessDeniedException":
1006
+ case "com.amazonaws.medicalimaging#AccessDeniedException":
1007
+ throw await de_AccessDeniedExceptionRes(parsedOutput);
1008
+ case "ConflictException":
1009
+ case "com.amazonaws.medicalimaging#ConflictException":
1010
+ throw await de_ConflictExceptionRes(parsedOutput);
1011
+ case "InternalServerException":
1012
+ case "com.amazonaws.medicalimaging#InternalServerException":
1013
+ throw await de_InternalServerExceptionRes(parsedOutput);
1014
+ case "ResourceNotFoundException":
1015
+ case "com.amazonaws.medicalimaging#ResourceNotFoundException":
1016
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput);
1017
+ case "ServiceQuotaExceededException":
1018
+ case "com.amazonaws.medicalimaging#ServiceQuotaExceededException":
1019
+ throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
1020
+ case "ThrottlingException":
1021
+ case "com.amazonaws.medicalimaging#ThrottlingException":
1022
+ throw await de_ThrottlingExceptionRes(parsedOutput);
1023
+ case "ValidationException":
1024
+ case "com.amazonaws.medicalimaging#ValidationException":
1025
+ throw await de_ValidationExceptionRes(parsedOutput);
1026
+ default:
1027
+ const parsedBody = parsedOutput.body;
1028
+ return throwDefaultError({
1029
+ output,
1030
+ parsedBody,
1031
+ errorCode,
1032
+ });
1033
+ }
1034
+ };
1035
+ const throwDefaultError = smithyClient.withBaseException(MedicalImagingServiceException);
1036
+ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
1037
+ const contents = smithyClient.map({});
1038
+ const data = parsedOutput.body;
1039
+ const doc = smithyClient.take(data, {
1040
+ message: smithyClient.expectString,
1041
+ });
1042
+ Object.assign(contents, doc);
1043
+ const exception = new AccessDeniedException({
1044
+ $metadata: deserializeMetadata(parsedOutput),
1045
+ ...contents,
1046
+ });
1047
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1048
+ };
1049
+ const de_ConflictExceptionRes = async (parsedOutput, context) => {
1050
+ const contents = smithyClient.map({});
1051
+ const data = parsedOutput.body;
1052
+ const doc = smithyClient.take(data, {
1053
+ message: smithyClient.expectString,
1054
+ });
1055
+ Object.assign(contents, doc);
1056
+ const exception = new ConflictException({
1057
+ $metadata: deserializeMetadata(parsedOutput),
1058
+ ...contents,
1059
+ });
1060
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1061
+ };
1062
+ const de_InternalServerExceptionRes = async (parsedOutput, context) => {
1063
+ const contents = smithyClient.map({});
1064
+ const data = parsedOutput.body;
1065
+ const doc = smithyClient.take(data, {
1066
+ message: smithyClient.expectString,
1067
+ });
1068
+ Object.assign(contents, doc);
1069
+ const exception = new InternalServerException({
1070
+ $metadata: deserializeMetadata(parsedOutput),
1071
+ ...contents,
1072
+ });
1073
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1074
+ };
1075
+ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
1076
+ const contents = smithyClient.map({});
1077
+ const data = parsedOutput.body;
1078
+ const doc = smithyClient.take(data, {
1079
+ message: smithyClient.expectString,
1080
+ });
1081
+ Object.assign(contents, doc);
1082
+ const exception = new ResourceNotFoundException({
1083
+ $metadata: deserializeMetadata(parsedOutput),
1084
+ ...contents,
1085
+ });
1086
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1087
+ };
1088
+ const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
1089
+ const contents = smithyClient.map({});
1090
+ const data = parsedOutput.body;
1091
+ const doc = smithyClient.take(data, {
1092
+ message: smithyClient.expectString,
1093
+ });
1094
+ Object.assign(contents, doc);
1095
+ const exception = new ServiceQuotaExceededException({
1096
+ $metadata: deserializeMetadata(parsedOutput),
1097
+ ...contents,
1098
+ });
1099
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1100
+ };
1101
+ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
1102
+ const contents = smithyClient.map({});
1103
+ const data = parsedOutput.body;
1104
+ const doc = smithyClient.take(data, {
1105
+ message: smithyClient.expectString,
1106
+ });
1107
+ Object.assign(contents, doc);
1108
+ const exception = new ThrottlingException({
1109
+ $metadata: deserializeMetadata(parsedOutput),
1110
+ ...contents,
1111
+ });
1112
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1113
+ };
1114
+ const de_ValidationExceptionRes = async (parsedOutput, context) => {
1115
+ const contents = smithyClient.map({});
1116
+ const data = parsedOutput.body;
1117
+ const doc = smithyClient.take(data, {
1118
+ message: smithyClient.expectString,
1119
+ });
1120
+ Object.assign(contents, doc);
1121
+ const exception = new ValidationException({
1122
+ $metadata: deserializeMetadata(parsedOutput),
1123
+ ...contents,
1124
+ });
1125
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1126
+ };
1127
+ const se_DICOMUpdates = (input, context) => {
1128
+ return smithyClient.take(input, {
1129
+ removableAttributes: context.base64Encoder,
1130
+ updatableAttributes: context.base64Encoder,
1131
+ });
1132
+ };
1133
+ const se_MetadataUpdates = (input, context) => {
1134
+ return exports.MetadataUpdates.visit(input, {
1135
+ DICOMUpdates: (value) => ({ DICOMUpdates: se_DICOMUpdates(value, context) }),
1136
+ revertToVersionId: (value) => ({ revertToVersionId: value }),
1137
+ _: (name, value) => ({ [name]: value }),
1138
+ });
1139
+ };
1140
+ const se_SearchByAttributeValue = (input, context) => {
1141
+ return exports.SearchByAttributeValue.visit(input, {
1142
+ DICOMAccessionNumber: (value) => ({ DICOMAccessionNumber: value }),
1143
+ DICOMPatientId: (value) => ({ DICOMPatientId: value }),
1144
+ DICOMSeriesInstanceUID: (value) => ({ DICOMSeriesInstanceUID: value }),
1145
+ DICOMStudyDateAndTime: (value) => ({ DICOMStudyDateAndTime: smithyClient._json(value) }),
1146
+ DICOMStudyId: (value) => ({ DICOMStudyId: value }),
1147
+ DICOMStudyInstanceUID: (value) => ({ DICOMStudyInstanceUID: value }),
1148
+ createdAt: (value) => ({ createdAt: value.getTime() / 1_000 }),
1149
+ isPrimary: (value) => ({ isPrimary: value }),
1150
+ updatedAt: (value) => ({ updatedAt: value.getTime() / 1_000 }),
1151
+ _: (name, value) => ({ [name]: value }),
1152
+ });
1153
+ };
1154
+ const se_SearchByAttributeValues = (input, context) => {
1155
+ return input
1156
+ .filter((e) => e != null)
1157
+ .map((entry) => {
1158
+ return se_SearchByAttributeValue(entry);
1159
+ });
1160
+ };
1161
+ const se_SearchCriteria = (input, context) => {
1162
+ return smithyClient.take(input, {
1163
+ filters: (_) => se_SearchFilters(_),
1164
+ sort: smithyClient._json,
1165
+ });
1166
+ };
1167
+ const se_SearchFilter = (input, context) => {
1168
+ return smithyClient.take(input, {
1169
+ operator: [],
1170
+ values: (_) => se_SearchByAttributeValues(_),
1171
+ });
1172
+ };
1173
+ const se_SearchFilters = (input, context) => {
1174
+ return input
1175
+ .filter((e) => e != null)
1176
+ .map((entry) => {
1177
+ return se_SearchFilter(entry);
1178
+ });
1179
+ };
1180
+ const de_CopyDestinationImageSetProperties = (output, context) => {
1181
+ return smithyClient.take(output, {
1182
+ createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1183
+ imageSetArn: smithyClient.expectString,
1184
+ imageSetId: smithyClient.expectString,
1185
+ imageSetState: smithyClient.expectString,
1186
+ imageSetWorkflowStatus: smithyClient.expectString,
1187
+ latestVersionId: smithyClient.expectString,
1188
+ updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1189
+ });
1190
+ };
1191
+ const de_CopySourceImageSetProperties = (output, context) => {
1192
+ return smithyClient.take(output, {
1193
+ createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1194
+ imageSetArn: smithyClient.expectString,
1195
+ imageSetId: smithyClient.expectString,
1196
+ imageSetState: smithyClient.expectString,
1197
+ imageSetWorkflowStatus: smithyClient.expectString,
1198
+ latestVersionId: smithyClient.expectString,
1199
+ updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1200
+ });
1201
+ };
1202
+ const de_DatastoreProperties = (output, context) => {
1203
+ return smithyClient.take(output, {
1204
+ createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1205
+ datastoreArn: smithyClient.expectString,
1206
+ datastoreId: smithyClient.expectString,
1207
+ datastoreName: smithyClient.expectString,
1208
+ datastoreStatus: smithyClient.expectString,
1209
+ kmsKeyArn: smithyClient.expectString,
1210
+ lambdaAuthorizerArn: smithyClient.expectString,
1211
+ updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1212
+ });
1213
+ };
1214
+ const de_DatastoreSummaries = (output, context) => {
1215
+ const retVal = (output || [])
1216
+ .filter((e) => e != null)
1217
+ .map((entry) => {
1218
+ return de_DatastoreSummary(entry);
1219
+ });
1220
+ return retVal;
1221
+ };
1222
+ const de_DatastoreSummary = (output, context) => {
1223
+ return smithyClient.take(output, {
1224
+ createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1225
+ datastoreArn: smithyClient.expectString,
1226
+ datastoreId: smithyClient.expectString,
1227
+ datastoreName: smithyClient.expectString,
1228
+ datastoreStatus: smithyClient.expectString,
1229
+ updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1230
+ });
1231
+ };
1232
+ const de_DICOMImportJobProperties = (output, context) => {
1233
+ return smithyClient.take(output, {
1234
+ dataAccessRoleArn: smithyClient.expectString,
1235
+ datastoreId: smithyClient.expectString,
1236
+ endedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1237
+ inputS3Uri: smithyClient.expectString,
1238
+ jobId: smithyClient.expectString,
1239
+ jobName: smithyClient.expectString,
1240
+ jobStatus: smithyClient.expectString,
1241
+ message: smithyClient.expectString,
1242
+ outputS3Uri: smithyClient.expectString,
1243
+ submittedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1244
+ });
1245
+ };
1246
+ const de_DICOMImportJobSummaries = (output, context) => {
1247
+ const retVal = (output || [])
1248
+ .filter((e) => e != null)
1249
+ .map((entry) => {
1250
+ return de_DICOMImportJobSummary(entry);
1251
+ });
1252
+ return retVal;
1253
+ };
1254
+ const de_DICOMImportJobSummary = (output, context) => {
1255
+ return smithyClient.take(output, {
1256
+ dataAccessRoleArn: smithyClient.expectString,
1257
+ datastoreId: smithyClient.expectString,
1258
+ endedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1259
+ jobId: smithyClient.expectString,
1260
+ jobName: smithyClient.expectString,
1261
+ jobStatus: smithyClient.expectString,
1262
+ message: smithyClient.expectString,
1263
+ submittedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1264
+ });
1265
+ };
1266
+ const de_ImageSetProperties = (output, context) => {
1267
+ return smithyClient.take(output, {
1268
+ ImageSetWorkflowStatus: smithyClient.expectString,
1269
+ createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1270
+ deletedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1271
+ imageSetId: smithyClient.expectString,
1272
+ imageSetState: smithyClient.expectString,
1273
+ isPrimary: smithyClient.expectBoolean,
1274
+ message: smithyClient.expectString,
1275
+ overrides: smithyClient._json,
1276
+ updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1277
+ versionId: smithyClient.expectString,
1278
+ });
1279
+ };
1280
+ const de_ImageSetPropertiesList = (output, context) => {
1281
+ const retVal = (output || [])
1282
+ .filter((e) => e != null)
1283
+ .map((entry) => {
1284
+ return de_ImageSetProperties(entry);
1285
+ });
1286
+ return retVal;
1287
+ };
1288
+ const de_ImageSetsMetadataSummaries = (output, context) => {
1289
+ const retVal = (output || [])
1290
+ .filter((e) => e != null)
1291
+ .map((entry) => {
1292
+ return de_ImageSetsMetadataSummary(entry);
1293
+ });
1294
+ return retVal;
1295
+ };
1296
+ const de_ImageSetsMetadataSummary = (output, context) => {
1297
+ return smithyClient.take(output, {
1298
+ DICOMTags: smithyClient._json,
1299
+ createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1300
+ imageSetId: smithyClient.expectString,
1301
+ isPrimary: smithyClient.expectBoolean,
1302
+ updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1303
+ version: smithyClient.expectInt32,
1304
+ });
1305
+ };
1306
+ const deserializeMetadata = (output) => ({
1307
+ httpStatusCode: output.statusCode,
1308
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1309
+ extendedRequestId: output.headers["x-amz-id-2"],
1310
+ cfId: output.headers["x-amz-cf-id"],
1311
+ });
1312
+ const _cE = "contentEncoding";
1313
+ const _cT = "contentType";
1314
+ const _ce = "content-encoding";
1315
+ const _ct = "content-type";
1316
+ const _dS = "datastoreStatus";
1317
+ const _f = "force";
1318
+ const _jS = "jobStatus";
1319
+ const _lV = "latestVersion";
1320
+ const _lVI = "latestVersionId";
1321
+ const _mR = "maxResults";
1322
+ const _nT = "nextToken";
1323
+ const _pTP = "promoteToPrimary";
1324
+ const _tK = "tagKeys";
1325
+ const _v = "version";
1326
+ const _vI = "versionId";
1327
+
1328
+ class CopyImageSetCommand extends smithyClient.Command
1329
+ .classBuilder()
1330
+ .ep(commonParams)
1331
+ .m(function (Command, cs, config, o) {
1332
+ return [
1333
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1334
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1335
+ ];
1336
+ })
1337
+ .s("AHIGatewayService", "CopyImageSet", {})
1338
+ .n("MedicalImagingClient", "CopyImageSetCommand")
1339
+ .f(CopyImageSetRequestFilterSensitiveLog, void 0)
1340
+ .ser(se_CopyImageSetCommand)
1341
+ .de(de_CopyImageSetCommand)
1342
+ .build() {
1343
+ }
1344
+
1345
+ class CreateDatastoreCommand extends smithyClient.Command
1346
+ .classBuilder()
1347
+ .ep(commonParams)
1348
+ .m(function (Command, cs, config, o) {
1349
+ return [
1350
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1351
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1352
+ ];
1353
+ })
1354
+ .s("AHIGatewayService", "CreateDatastore", {})
1355
+ .n("MedicalImagingClient", "CreateDatastoreCommand")
1356
+ .f(void 0, void 0)
1357
+ .ser(se_CreateDatastoreCommand)
1358
+ .de(de_CreateDatastoreCommand)
1359
+ .build() {
1360
+ }
1361
+
1362
+ class DeleteDatastoreCommand extends smithyClient.Command
1363
+ .classBuilder()
1364
+ .ep(commonParams)
1365
+ .m(function (Command, cs, config, o) {
1366
+ return [
1367
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1368
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1369
+ ];
1370
+ })
1371
+ .s("AHIGatewayService", "DeleteDatastore", {})
1372
+ .n("MedicalImagingClient", "DeleteDatastoreCommand")
1373
+ .f(void 0, void 0)
1374
+ .ser(se_DeleteDatastoreCommand)
1375
+ .de(de_DeleteDatastoreCommand)
1376
+ .build() {
1377
+ }
1378
+
1379
+ class DeleteImageSetCommand extends smithyClient.Command
1380
+ .classBuilder()
1381
+ .ep(commonParams)
1382
+ .m(function (Command, cs, config, o) {
1383
+ return [
1384
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1385
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1386
+ ];
1387
+ })
1388
+ .s("AHIGatewayService", "DeleteImageSet", {})
1389
+ .n("MedicalImagingClient", "DeleteImageSetCommand")
1390
+ .f(void 0, void 0)
1391
+ .ser(se_DeleteImageSetCommand)
1392
+ .de(de_DeleteImageSetCommand)
1393
+ .build() {
1394
+ }
1395
+
1396
+ class GetDatastoreCommand extends smithyClient.Command
1397
+ .classBuilder()
1398
+ .ep(commonParams)
1399
+ .m(function (Command, cs, config, o) {
1400
+ return [
1401
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1402
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1403
+ ];
1404
+ })
1405
+ .s("AHIGatewayService", "GetDatastore", {})
1406
+ .n("MedicalImagingClient", "GetDatastoreCommand")
1407
+ .f(void 0, void 0)
1408
+ .ser(se_GetDatastoreCommand)
1409
+ .de(de_GetDatastoreCommand)
1410
+ .build() {
1411
+ }
1412
+
1413
+ class GetDICOMImportJobCommand extends smithyClient.Command
1414
+ .classBuilder()
1415
+ .ep(commonParams)
1416
+ .m(function (Command, cs, config, o) {
1417
+ return [
1418
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1419
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1420
+ ];
1421
+ })
1422
+ .s("AHIGatewayService", "GetDICOMImportJob", {})
1423
+ .n("MedicalImagingClient", "GetDICOMImportJobCommand")
1424
+ .f(void 0, void 0)
1425
+ .ser(se_GetDICOMImportJobCommand)
1426
+ .de(de_GetDICOMImportJobCommand)
1427
+ .build() {
1428
+ }
1429
+
1430
+ class GetImageFrameCommand extends smithyClient.Command
1431
+ .classBuilder()
1432
+ .ep(commonParams)
1433
+ .m(function (Command, cs, config, o) {
1434
+ return [
1435
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1436
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1437
+ ];
1438
+ })
1439
+ .s("AHIGatewayService", "GetImageFrame", {})
1440
+ .n("MedicalImagingClient", "GetImageFrameCommand")
1441
+ .f(void 0, GetImageFrameResponseFilterSensitiveLog)
1442
+ .ser(se_GetImageFrameCommand)
1443
+ .de(de_GetImageFrameCommand)
1444
+ .build() {
1445
+ }
1446
+
1447
+ class GetImageSetCommand extends smithyClient.Command
1448
+ .classBuilder()
1449
+ .ep(commonParams)
1450
+ .m(function (Command, cs, config, o) {
1451
+ return [
1452
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1453
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1454
+ ];
1455
+ })
1456
+ .s("AHIGatewayService", "GetImageSet", {})
1457
+ .n("MedicalImagingClient", "GetImageSetCommand")
1458
+ .f(void 0, void 0)
1459
+ .ser(se_GetImageSetCommand)
1460
+ .de(de_GetImageSetCommand)
1461
+ .build() {
1462
+ }
1463
+
1464
+ class GetImageSetMetadataCommand extends smithyClient.Command
1465
+ .classBuilder()
1466
+ .ep(commonParams)
1467
+ .m(function (Command, cs, config, o) {
1468
+ return [
1469
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1470
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1471
+ ];
1472
+ })
1473
+ .s("AHIGatewayService", "GetImageSetMetadata", {})
1474
+ .n("MedicalImagingClient", "GetImageSetMetadataCommand")
1475
+ .f(void 0, GetImageSetMetadataResponseFilterSensitiveLog)
1476
+ .ser(se_GetImageSetMetadataCommand)
1477
+ .de(de_GetImageSetMetadataCommand)
1478
+ .build() {
1479
+ }
1480
+
1481
+ class ListDatastoresCommand extends smithyClient.Command
1482
+ .classBuilder()
1483
+ .ep(commonParams)
1484
+ .m(function (Command, cs, config, o) {
1485
+ return [
1486
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1487
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1488
+ ];
1489
+ })
1490
+ .s("AHIGatewayService", "ListDatastores", {})
1491
+ .n("MedicalImagingClient", "ListDatastoresCommand")
1492
+ .f(void 0, void 0)
1493
+ .ser(se_ListDatastoresCommand)
1494
+ .de(de_ListDatastoresCommand)
1495
+ .build() {
1496
+ }
1497
+
1498
+ class ListDICOMImportJobsCommand extends smithyClient.Command
1499
+ .classBuilder()
1500
+ .ep(commonParams)
1501
+ .m(function (Command, cs, config, o) {
1502
+ return [
1503
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1504
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1505
+ ];
1506
+ })
1507
+ .s("AHIGatewayService", "ListDICOMImportJobs", {})
1508
+ .n("MedicalImagingClient", "ListDICOMImportJobsCommand")
1509
+ .f(void 0, void 0)
1510
+ .ser(se_ListDICOMImportJobsCommand)
1511
+ .de(de_ListDICOMImportJobsCommand)
1512
+ .build() {
1513
+ }
1514
+
1515
+ class ListImageSetVersionsCommand extends smithyClient.Command
1516
+ .classBuilder()
1517
+ .ep(commonParams)
1518
+ .m(function (Command, cs, config, o) {
1519
+ return [
1520
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1521
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1522
+ ];
1523
+ })
1524
+ .s("AHIGatewayService", "ListImageSetVersions", {})
1525
+ .n("MedicalImagingClient", "ListImageSetVersionsCommand")
1526
+ .f(void 0, void 0)
1527
+ .ser(se_ListImageSetVersionsCommand)
1528
+ .de(de_ListImageSetVersionsCommand)
1529
+ .build() {
1530
+ }
1531
+
1532
+ class ListTagsForResourceCommand extends smithyClient.Command
1533
+ .classBuilder()
1534
+ .ep(commonParams)
1535
+ .m(function (Command, cs, config, o) {
1536
+ return [
1537
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1538
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1539
+ ];
1540
+ })
1541
+ .s("AHIGatewayService", "ListTagsForResource", {})
1542
+ .n("MedicalImagingClient", "ListTagsForResourceCommand")
1543
+ .f(void 0, void 0)
1544
+ .ser(se_ListTagsForResourceCommand)
1545
+ .de(de_ListTagsForResourceCommand)
1546
+ .build() {
1547
+ }
1548
+
1549
+ class SearchImageSetsCommand extends smithyClient.Command
1550
+ .classBuilder()
1551
+ .ep(commonParams)
1552
+ .m(function (Command, cs, config, o) {
1553
+ return [
1554
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1555
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1556
+ ];
1557
+ })
1558
+ .s("AHIGatewayService", "SearchImageSets", {})
1559
+ .n("MedicalImagingClient", "SearchImageSetsCommand")
1560
+ .f(SearchImageSetsRequestFilterSensitiveLog, SearchImageSetsResponseFilterSensitiveLog)
1561
+ .ser(se_SearchImageSetsCommand)
1562
+ .de(de_SearchImageSetsCommand)
1563
+ .build() {
1564
+ }
1565
+
1566
+ class StartDICOMImportJobCommand extends smithyClient.Command
1567
+ .classBuilder()
1568
+ .ep(commonParams)
1569
+ .m(function (Command, cs, config, o) {
1570
+ return [
1571
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1572
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1573
+ ];
1574
+ })
1575
+ .s("AHIGatewayService", "StartDICOMImportJob", {})
1576
+ .n("MedicalImagingClient", "StartDICOMImportJobCommand")
1577
+ .f(void 0, void 0)
1578
+ .ser(se_StartDICOMImportJobCommand)
1579
+ .de(de_StartDICOMImportJobCommand)
1580
+ .build() {
1581
+ }
1582
+
1583
+ class TagResourceCommand extends smithyClient.Command
1584
+ .classBuilder()
1585
+ .ep(commonParams)
1586
+ .m(function (Command, cs, config, o) {
1587
+ return [
1588
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1589
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1590
+ ];
1591
+ })
1592
+ .s("AHIGatewayService", "TagResource", {})
1593
+ .n("MedicalImagingClient", "TagResourceCommand")
1594
+ .f(void 0, void 0)
1595
+ .ser(se_TagResourceCommand)
1596
+ .de(de_TagResourceCommand)
1597
+ .build() {
1598
+ }
1599
+
1600
+ class UntagResourceCommand extends smithyClient.Command
1601
+ .classBuilder()
1602
+ .ep(commonParams)
1603
+ .m(function (Command, cs, config, o) {
1604
+ return [
1605
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1606
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1607
+ ];
1608
+ })
1609
+ .s("AHIGatewayService", "UntagResource", {})
1610
+ .n("MedicalImagingClient", "UntagResourceCommand")
1611
+ .f(void 0, void 0)
1612
+ .ser(se_UntagResourceCommand)
1613
+ .de(de_UntagResourceCommand)
1614
+ .build() {
1615
+ }
1616
+
1617
+ class UpdateImageSetMetadataCommand extends smithyClient.Command
1618
+ .classBuilder()
1619
+ .ep(commonParams)
1620
+ .m(function (Command, cs, config, o) {
1621
+ return [
1622
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1623
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1624
+ ];
1625
+ })
1626
+ .s("AHIGatewayService", "UpdateImageSetMetadata", {})
1627
+ .n("MedicalImagingClient", "UpdateImageSetMetadataCommand")
1628
+ .f(UpdateImageSetMetadataRequestFilterSensitiveLog, void 0)
1629
+ .ser(se_UpdateImageSetMetadataCommand)
1630
+ .de(de_UpdateImageSetMetadataCommand)
1631
+ .build() {
1632
+ }
1633
+
1634
+ const commands = {
1635
+ CopyImageSetCommand,
1636
+ CreateDatastoreCommand,
1637
+ DeleteDatastoreCommand,
1638
+ DeleteImageSetCommand,
1639
+ GetDatastoreCommand,
1640
+ GetDICOMImportJobCommand,
1641
+ GetImageFrameCommand,
1642
+ GetImageSetCommand,
1643
+ GetImageSetMetadataCommand,
1644
+ ListDatastoresCommand,
1645
+ ListDICOMImportJobsCommand,
1646
+ ListImageSetVersionsCommand,
1647
+ ListTagsForResourceCommand,
1648
+ SearchImageSetsCommand,
1649
+ StartDICOMImportJobCommand,
1650
+ TagResourceCommand,
1651
+ UntagResourceCommand,
1652
+ UpdateImageSetMetadataCommand,
1653
+ };
1654
+ class MedicalImaging extends MedicalImagingClient {
1655
+ }
1656
+ smithyClient.createAggregatedClient(commands, MedicalImaging);
1748
1657
 
1749
- // src/MedicalImaging.ts
1750
- var commands = {
1751
- CopyImageSetCommand,
1752
- CreateDatastoreCommand,
1753
- DeleteDatastoreCommand,
1754
- DeleteImageSetCommand,
1755
- GetDatastoreCommand,
1756
- GetDICOMImportJobCommand,
1757
- GetImageFrameCommand,
1758
- GetImageSetCommand,
1759
- GetImageSetMetadataCommand,
1760
- ListDatastoresCommand,
1761
- ListDICOMImportJobsCommand,
1762
- ListImageSetVersionsCommand,
1763
- ListTagsForResourceCommand,
1764
- SearchImageSetsCommand,
1765
- StartDICOMImportJobCommand,
1766
- TagResourceCommand,
1767
- UntagResourceCommand,
1768
- UpdateImageSetMetadataCommand
1769
- };
1770
- var MedicalImaging = class extends MedicalImagingClient {
1771
- static {
1772
- __name(this, "MedicalImaging");
1773
- }
1774
- };
1775
- (0, import_smithy_client.createAggregatedClient)(commands, MedicalImaging);
1776
-
1777
- // src/pagination/ListDICOMImportJobsPaginator.ts
1778
-
1779
- var paginateListDICOMImportJobs = (0, import_core.createPaginator)(MedicalImagingClient, ListDICOMImportJobsCommand, "nextToken", "nextToken", "maxResults");
1780
-
1781
- // src/pagination/ListDatastoresPaginator.ts
1782
-
1783
- var paginateListDatastores = (0, import_core.createPaginator)(MedicalImagingClient, ListDatastoresCommand, "nextToken", "nextToken", "maxResults");
1784
-
1785
- // src/pagination/ListImageSetVersionsPaginator.ts
1658
+ const paginateListDICOMImportJobs = core.createPaginator(MedicalImagingClient, ListDICOMImportJobsCommand, "nextToken", "nextToken", "maxResults");
1786
1659
 
1787
- var paginateListImageSetVersions = (0, import_core.createPaginator)(MedicalImagingClient, ListImageSetVersionsCommand, "nextToken", "nextToken", "maxResults");
1660
+ const paginateListDatastores = core.createPaginator(MedicalImagingClient, ListDatastoresCommand, "nextToken", "nextToken", "maxResults");
1788
1661
 
1789
- // src/pagination/SearchImageSetsPaginator.ts
1662
+ const paginateListImageSetVersions = core.createPaginator(MedicalImagingClient, ListImageSetVersionsCommand, "nextToken", "nextToken", "maxResults");
1790
1663
 
1791
- var paginateSearchImageSets = (0, import_core.createPaginator)(MedicalImagingClient, SearchImageSetsCommand, "nextToken", "nextToken", "maxResults");
1792
- // Annotate the CommonJS export names for ESM import in node:
1664
+ const paginateSearchImageSets = core.createPaginator(MedicalImagingClient, SearchImageSetsCommand, "nextToken", "nextToken", "maxResults");
1793
1665
 
1794
- 0 && (module.exports = {
1795
- MedicalImagingServiceException,
1796
- __Client,
1797
- MedicalImagingClient,
1798
- MedicalImaging,
1799
- $Command,
1800
- CopyImageSetCommand,
1801
- CreateDatastoreCommand,
1802
- DeleteDatastoreCommand,
1803
- DeleteImageSetCommand,
1804
- GetDICOMImportJobCommand,
1805
- GetDatastoreCommand,
1806
- GetImageFrameCommand,
1807
- GetImageSetCommand,
1808
- GetImageSetMetadataCommand,
1809
- ListDICOMImportJobsCommand,
1810
- ListDatastoresCommand,
1811
- ListImageSetVersionsCommand,
1812
- ListTagsForResourceCommand,
1813
- SearchImageSetsCommand,
1814
- StartDICOMImportJobCommand,
1815
- TagResourceCommand,
1816
- UntagResourceCommand,
1817
- UpdateImageSetMetadataCommand,
1818
- paginateListDICOMImportJobs,
1819
- paginateListDatastores,
1820
- paginateListImageSetVersions,
1821
- paginateSearchImageSets,
1822
- AccessDeniedException,
1823
- ConflictException,
1824
- ImageSetState,
1825
- ImageSetWorkflowStatus,
1826
- InternalServerException,
1827
- ResourceNotFoundException,
1828
- ServiceQuotaExceededException,
1829
- ThrottlingException,
1830
- ValidationException,
1831
- DatastoreStatus,
1832
- JobStatus,
1833
- Operator,
1834
- SearchByAttributeValue,
1835
- SortField,
1836
- SortOrder,
1837
- MetadataUpdates,
1838
- MetadataCopiesFilterSensitiveLog,
1839
- CopySourceImageSetInformationFilterSensitiveLog,
1840
- CopyImageSetInformationFilterSensitiveLog,
1841
- CopyImageSetRequestFilterSensitiveLog,
1842
- GetImageFrameResponseFilterSensitiveLog,
1843
- GetImageSetMetadataResponseFilterSensitiveLog,
1844
- DICOMStudyDateAndTimeFilterSensitiveLog,
1845
- SearchByAttributeValueFilterSensitiveLog,
1846
- SearchFilterFilterSensitiveLog,
1847
- SearchCriteriaFilterSensitiveLog,
1848
- SearchImageSetsRequestFilterSensitiveLog,
1849
- DICOMTagsFilterSensitiveLog,
1850
- ImageSetsMetadataSummaryFilterSensitiveLog,
1851
- SearchImageSetsResponseFilterSensitiveLog,
1852
- DICOMUpdatesFilterSensitiveLog,
1853
- MetadataUpdatesFilterSensitiveLog,
1854
- UpdateImageSetMetadataRequestFilterSensitiveLog
1666
+ Object.defineProperty(exports, "$Command", {
1667
+ enumerable: true,
1668
+ get: function () { return smithyClient.Command; }
1855
1669
  });
1856
-
1670
+ Object.defineProperty(exports, "__Client", {
1671
+ enumerable: true,
1672
+ get: function () { return smithyClient.Client; }
1673
+ });
1674
+ exports.AccessDeniedException = AccessDeniedException;
1675
+ exports.ConflictException = ConflictException;
1676
+ exports.CopyImageSetCommand = CopyImageSetCommand;
1677
+ exports.CopyImageSetInformationFilterSensitiveLog = CopyImageSetInformationFilterSensitiveLog;
1678
+ exports.CopyImageSetRequestFilterSensitiveLog = CopyImageSetRequestFilterSensitiveLog;
1679
+ exports.CopySourceImageSetInformationFilterSensitiveLog = CopySourceImageSetInformationFilterSensitiveLog;
1680
+ exports.CreateDatastoreCommand = CreateDatastoreCommand;
1681
+ exports.DICOMStudyDateAndTimeFilterSensitiveLog = DICOMStudyDateAndTimeFilterSensitiveLog;
1682
+ exports.DICOMTagsFilterSensitiveLog = DICOMTagsFilterSensitiveLog;
1683
+ exports.DICOMUpdatesFilterSensitiveLog = DICOMUpdatesFilterSensitiveLog;
1684
+ exports.DatastoreStatus = DatastoreStatus;
1685
+ exports.DeleteDatastoreCommand = DeleteDatastoreCommand;
1686
+ exports.DeleteImageSetCommand = DeleteImageSetCommand;
1687
+ exports.GetDICOMImportJobCommand = GetDICOMImportJobCommand;
1688
+ exports.GetDatastoreCommand = GetDatastoreCommand;
1689
+ exports.GetImageFrameCommand = GetImageFrameCommand;
1690
+ exports.GetImageFrameResponseFilterSensitiveLog = GetImageFrameResponseFilterSensitiveLog;
1691
+ exports.GetImageSetCommand = GetImageSetCommand;
1692
+ exports.GetImageSetMetadataCommand = GetImageSetMetadataCommand;
1693
+ exports.GetImageSetMetadataResponseFilterSensitiveLog = GetImageSetMetadataResponseFilterSensitiveLog;
1694
+ exports.ImageSetState = ImageSetState;
1695
+ exports.ImageSetWorkflowStatus = ImageSetWorkflowStatus;
1696
+ exports.ImageSetsMetadataSummaryFilterSensitiveLog = ImageSetsMetadataSummaryFilterSensitiveLog;
1697
+ exports.InternalServerException = InternalServerException;
1698
+ exports.JobStatus = JobStatus;
1699
+ exports.ListDICOMImportJobsCommand = ListDICOMImportJobsCommand;
1700
+ exports.ListDatastoresCommand = ListDatastoresCommand;
1701
+ exports.ListImageSetVersionsCommand = ListImageSetVersionsCommand;
1702
+ exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
1703
+ exports.MedicalImaging = MedicalImaging;
1704
+ exports.MedicalImagingClient = MedicalImagingClient;
1705
+ exports.MedicalImagingServiceException = MedicalImagingServiceException;
1706
+ exports.MetadataCopiesFilterSensitiveLog = MetadataCopiesFilterSensitiveLog;
1707
+ exports.MetadataUpdatesFilterSensitiveLog = MetadataUpdatesFilterSensitiveLog;
1708
+ exports.Operator = Operator;
1709
+ exports.ResourceNotFoundException = ResourceNotFoundException;
1710
+ exports.SearchByAttributeValueFilterSensitiveLog = SearchByAttributeValueFilterSensitiveLog;
1711
+ exports.SearchCriteriaFilterSensitiveLog = SearchCriteriaFilterSensitiveLog;
1712
+ exports.SearchFilterFilterSensitiveLog = SearchFilterFilterSensitiveLog;
1713
+ exports.SearchImageSetsCommand = SearchImageSetsCommand;
1714
+ exports.SearchImageSetsRequestFilterSensitiveLog = SearchImageSetsRequestFilterSensitiveLog;
1715
+ exports.SearchImageSetsResponseFilterSensitiveLog = SearchImageSetsResponseFilterSensitiveLog;
1716
+ exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
1717
+ exports.SortField = SortField;
1718
+ exports.SortOrder = SortOrder;
1719
+ exports.StartDICOMImportJobCommand = StartDICOMImportJobCommand;
1720
+ exports.TagResourceCommand = TagResourceCommand;
1721
+ exports.ThrottlingException = ThrottlingException;
1722
+ exports.UntagResourceCommand = UntagResourceCommand;
1723
+ exports.UpdateImageSetMetadataCommand = UpdateImageSetMetadataCommand;
1724
+ exports.UpdateImageSetMetadataRequestFilterSensitiveLog = UpdateImageSetMetadataRequestFilterSensitiveLog;
1725
+ exports.ValidationException = ValidationException;
1726
+ exports.paginateListDICOMImportJobs = paginateListDICOMImportJobs;
1727
+ exports.paginateListDatastores = paginateListDatastores;
1728
+ exports.paginateListImageSetVersions = paginateListImageSetVersions;
1729
+ exports.paginateSearchImageSets = paginateSearchImageSets;