@aws-sdk/client-braket 3.928.0 → 3.930.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,9 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class BraketClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -111,14 +110,14 @@ class BraketClient extends smithyClient.Client {
     }
 }
 
-class BraketServiceException extends smithyClient.ServiceException {
+let BraketServiceException$1 = class BraketServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, BraketServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends BraketServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends BraketServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -129,7 +128,7 @@ class AccessDeniedException extends BraketServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
+};
 const CompressionType = {
     GZIP: "GZIP",
     NONE: "NONE",
@@ -154,7 +153,7 @@ const DeviceType = {
     QPU: "QPU",
     SIMULATOR: "SIMULATOR",
 };
-class InternalServiceException extends BraketServiceException {
+let InternalServiceException$1 = class InternalServiceException extends BraketServiceException$1 {
     name = "InternalServiceException";
     $fault = "server";
     constructor(opts) {
@@ -165,8 +164,8 @@ class InternalServiceException extends BraketServiceException {
         });
         Object.setPrototypeOf(this, InternalServiceException.prototype);
     }
-}
-class ResourceNotFoundException extends BraketServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends BraketServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -177,8 +176,8 @@ class ResourceNotFoundException extends BraketServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
-class ThrottlingException extends BraketServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends BraketServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     constructor(opts) {
@@ -189,11 +188,11 @@ class ThrottlingException extends BraketServiceException {
         });
         Object.setPrototypeOf(this, ThrottlingException.prototype);
     }
-}
+};
 const ValidationExceptionReason = {
     PROGRAM_SET_VALIDATION_FAILED: "ProgramSetValidationFailed",
 };
-class ValidationException extends BraketServiceException {
+let ValidationException$1 = class ValidationException extends BraketServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     reason;
@@ -208,12 +207,12 @@ class ValidationException extends BraketServiceException {
         this.reason = opts.reason;
         this.programSetValidationFailures = opts.programSetValidationFailures;
     }
-}
+};
 const CancellationStatus = {
     CANCELLED: "CANCELLED",
     CANCELLING: "CANCELLING",
 };
-class ConflictException extends BraketServiceException {
+let ConflictException$1 = class ConflictException extends BraketServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     constructor(opts) {
@@ -224,7 +223,7 @@ class ConflictException extends BraketServiceException {
         });
         Object.setPrototypeOf(this, ConflictException.prototype);
     }
-}
+};
 const _InstanceType = {
     ML_C4_2XLARGE: "ml.c4.2xlarge",
     ML_C4_4XLARGE: "ml.c4.4xlarge",
@@ -266,7 +265,7 @@ const _InstanceType = {
     ML_P3_8XLARGE: "ml.p3.8xlarge",
     ML_P4D_24XLARGE: "ml.p4d.24xlarge",
 };
-class DeviceOfflineException extends BraketServiceException {
+let DeviceOfflineException$1 = class DeviceOfflineException extends BraketServiceException$1 {
     name = "DeviceOfflineException";
     $fault = "client";
     constructor(opts) {
@@ -277,8 +276,8 @@ class DeviceOfflineException extends BraketServiceException {
         });
         Object.setPrototypeOf(this, DeviceOfflineException.prototype);
     }
-}
-class DeviceRetiredException extends BraketServiceException {
+};
+let DeviceRetiredException$1 = class DeviceRetiredException extends BraketServiceException$1 {
     name = "DeviceRetiredException";
     $fault = "client";
     constructor(opts) {
@@ -289,8 +288,8 @@ class DeviceRetiredException extends BraketServiceException {
         });
         Object.setPrototypeOf(this, DeviceRetiredException.prototype);
     }
-}
-class ServiceQuotaExceededException extends BraketServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends BraketServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     constructor(opts) {
@@ -301,7 +300,7 @@ class ServiceQuotaExceededException extends BraketServiceException {
         });
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
     }
-}
+};
 const HybridJobAdditionalAttributeName = {
     QUEUE_INFO: "QueueInfo",
 };
@@ -339,14 +338,6 @@ const ExperimentalCapabilitiesEnablementType = {
     ALL: "ALL",
     NONE: "NONE",
 };
-exports.ExperimentalCapabilities = void 0;
-(function (ExperimentalCapabilities) {
-    ExperimentalCapabilities.visit = (value, visitor) => {
-        if (value.enabled !== undefined)
-            return visitor.enabled(value.enabled);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(exports.ExperimentalCapabilities || (exports.ExperimentalCapabilities = {}));
 const QuantumTaskAdditionalAttributeName = {
     QUEUE_INFO: "QueueInfo",
 };
@@ -368,653 +359,716 @@ const SearchQuantumTasksFilterOperator = {
     LTE: "LTE",
 };
 
-const se_CancelJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/job/{jobArn}/cancel");
-    b.p("jobArn", () => input.jobArn, "{jobArn}", false);
-    let body;
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_CancelQuantumTaskCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/quantum-task/{quantumTaskArn}/cancel");
-    b.p("quantumTaskArn", () => input.quantumTaskArn, "{quantumTaskArn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_CreateJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/job");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        algorithmSpecification: (_) => smithyClient._json(_),
-        associations: (_) => smithyClient._json(_),
-        checkpointConfig: (_) => smithyClient._json(_),
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        deviceConfig: (_) => smithyClient._json(_),
-        hyperParameters: (_) => smithyClient._json(_),
-        inputDataConfig: (_) => smithyClient._json(_),
-        instanceConfig: (_) => smithyClient._json(_),
-        jobName: [],
-        outputDataConfig: (_) => smithyClient._json(_),
-        roleArn: [],
-        stoppingCondition: (_) => smithyClient._json(_),
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateQuantumTaskCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/quantum-task");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        action: (_) => smithyClient.LazyJsonString.from(_),
-        associations: (_) => smithyClient._json(_),
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        deviceArn: [],
-        deviceParameters: (_) => smithyClient.LazyJsonString.from(_),
-        experimentalCapabilities: (_) => smithyClient._json(_),
-        jobToken: [],
-        outputS3Bucket: [],
-        outputS3KeyPrefix: [],
-        shots: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetDeviceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/device/{deviceArn}");
-    b.p("deviceArn", () => input.deviceArn, "{deviceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/job/{jobArn}");
-    b.p("jobArn", () => input.jobArn, "{jobArn}", false);
-    const query = smithyClient.map({
-        [_aAN]: [() => input.additionalAttributeNames !== void 0, () => input[_aAN] || []],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_GetQuantumTaskCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/quantum-task/{quantumTaskArn}");
-    b.p("quantumTaskArn", () => input.quantumTaskArn, "{quantumTaskArn}", false);
-    const query = smithyClient.map({
-        [_aAN]: [() => input.additionalAttributeNames !== void 0, () => input[_aAN] || []],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_SearchDevicesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/devices");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filters: (_) => smithyClient._json(_),
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_SearchJobsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/jobs");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filters: (_) => smithyClient._json(_),
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_SearchQuantumTasksCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/quantum-tasks");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filters: (_) => smithyClient._json(_),
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const de_CancelJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        cancellationStatus: smithyClient.expectString,
-        jobArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CancelQuantumTaskCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        cancellationStatus: smithyClient.expectString,
-        quantumTaskArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateJobCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        jobArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateQuantumTaskCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        quantumTaskArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetDeviceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        deviceArn: smithyClient.expectString,
-        deviceCapabilities: smithyClient.LazyJsonString.from,
-        deviceName: smithyClient.expectString,
-        deviceQueueInfo: smithyClient._json,
-        deviceStatus: smithyClient.expectString,
-        deviceType: smithyClient.expectString,
-        providerName: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        algorithmSpecification: smithyClient._json,
-        associations: smithyClient._json,
-        billableDuration: smithyClient.expectInt32,
-        checkpointConfig: smithyClient._json,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        deviceConfig: smithyClient._json,
-        endedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        events: (_) => de_JobEvents(_),
-        failureReason: smithyClient.expectString,
-        hyperParameters: smithyClient._json,
-        inputDataConfig: smithyClient._json,
-        instanceConfig: smithyClient._json,
-        jobArn: smithyClient.expectString,
-        jobName: smithyClient.expectString,
-        outputDataConfig: smithyClient._json,
-        queueInfo: smithyClient._json,
-        roleArn: smithyClient.expectString,
-        startedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        status: smithyClient.expectString,
-        stoppingCondition: smithyClient._json,
-        tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetQuantumTaskCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        actionMetadata: smithyClient._json,
-        associations: smithyClient._json,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        deviceArn: smithyClient.expectString,
-        deviceParameters: smithyClient.LazyJsonString.from,
-        endedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        experimentalCapabilities: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
-        failureReason: smithyClient.expectString,
-        jobArn: smithyClient.expectString,
-        numSuccessfulShots: smithyClient.expectLong,
-        outputS3Bucket: smithyClient.expectString,
-        outputS3Directory: smithyClient.expectString,
-        quantumTaskArn: smithyClient.expectString,
-        queueInfo: smithyClient._json,
-        shots: smithyClient.expectLong,
-        status: smithyClient.expectString,
-        tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_SearchDevicesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        devices: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_SearchJobsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        jobs: (_) => de_JobSummaryList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_SearchQuantumTasksCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        nextToken: smithyClient.expectString,
-        quantumTasks: (_) => de_QuantumTaskSummaryList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.braket#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.braket#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServiceException":
-        case "com.amazonaws.braket#InternalServiceException":
-            throw await de_InternalServiceExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.braket#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.braket#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.braket#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "DeviceOfflineException":
-        case "com.amazonaws.braket#DeviceOfflineException":
-            throw await de_DeviceOfflineExceptionRes(parsedOutput);
-        case "DeviceRetiredException":
-        case "com.amazonaws.braket#DeviceRetiredException":
-            throw await de_DeviceRetiredExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.braket#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(BraketServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_DeviceOfflineExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new DeviceOfflineException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_DeviceRetiredExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new DeviceRetiredException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServiceExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServiceException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        programSetValidationFailures: smithyClient._json,
-        reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_JobEventDetails = (output, context) => {
-    return smithyClient.take(output, {
-        eventType: smithyClient.expectString,
-        message: smithyClient.expectString,
-        timeOfEvent: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-    });
-};
-const de_JobEvents = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_JobEventDetails(entry);
-    });
-    return retVal;
-};
-const de_JobSummary = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        device: smithyClient.expectString,
-        endedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        jobArn: smithyClient.expectString,
-        jobName: smithyClient.expectString,
-        startedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        status: smithyClient.expectString,
-        tags: smithyClient._json,
-    });
-};
-const de_JobSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_JobSummary(entry);
-    });
-    return retVal;
-};
-const de_QuantumTaskSummary = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        deviceArn: smithyClient.expectString,
-        endedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        outputS3Bucket: smithyClient.expectString,
-        outputS3Directory: smithyClient.expectString,
-        quantumTaskArn: smithyClient.expectString,
-        shots: smithyClient.expectLong,
-        status: smithyClient.expectString,
-        tags: smithyClient._json,
-    });
-};
-const de_QuantumTaskSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_QuantumTaskSummary(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
+const _A = "Association";
+const _ADE = "AccessDeniedException";
+const _AM = "ActionMetadata";
+const _AS = "AlgorithmSpecification";
+const _As = "Associations";
+const _CE = "ConflictException";
+const _CI = "ContainerImage";
+const _CJ = "CancelJob";
+const _CJR = "CancelJobRequest";
+const _CJRa = "CancelJobResponse";
+const _CJRr = "CreateJobRequest";
+const _CJRre = "CreateJobResponse";
+const _CJr = "CreateJob";
+const _CQT = "CancelQuantumTask";
+const _CQTR = "CancelQuantumTaskRequest";
+const _CQTRa = "CancelQuantumTaskResponse";
+const _CQTRr = "CreateQuantumTaskRequest";
+const _CQTRre = "CreateQuantumTaskResponse";
+const _CQTr = "CreateQuantumTask";
+const _DC = "DeviceConfig";
+const _DOE = "DeviceOfflineException";
+const _DQI = "DeviceQueueInfo";
+const _DQIL = "DeviceQueueInfoList";
+const _DRE = "DeviceRetiredException";
+const _DS = "DataSource";
+const _DSL = "DeviceSummaryList";
+const _DSe = "DeviceSummary";
+const _EC = "ExperimentalCapabilities";
+const _GD = "GetDevice";
+const _GDR = "GetDeviceRequest";
+const _GDRe = "GetDeviceResponse";
+const _GJ = "GetJob";
+const _GJR = "GetJobRequest";
+const _GJRe = "GetJobResponse";
+const _GQT = "GetQuantumTask";
+const _GQTR = "GetQuantumTaskRequest";
+const _GQTRe = "GetQuantumTaskResponse";
+const _HJQI = "HybridJobQueueInfo";
+const _IC = "InstanceConfig";
+const _ICL = "InputConfigList";
+const _IFC = "InputFileConfig";
+const _ISE = "InternalServiceException";
+const _JCC = "JobCheckpointConfig";
+const _JE = "JobEvents";
+const _JED = "JobEventDetails";
+const _JODC = "JobOutputDataConfig";
+const _JS = "JobSummary";
+const _JSC = "JobStoppingCondition";
+const _JSL = "JobSummaryList";
+const _JV = "JsonValue";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _PSVF = "ProgramSetValidationFailure";
+const _PSVFL = "ProgramSetValidationFailuresList";
+const _QTQI = "QuantumTaskQueueInfo";
+const _QTS = "QuantumTaskSummary";
+const _QTSL = "QuantumTaskSummaryList";
+const _RNFE = "ResourceNotFoundException";
+const _SD = "SearchDevices";
+const _SDF = "SearchDevicesFilter";
+const _SDFL = "SearchDevicesFilterList";
+const _SDR = "SearchDevicesRequest";
+const _SDRe = "SearchDevicesResponse";
+const _SDS = "S3DataSource";
+const _SJ = "SearchJobs";
+const _SJF = "SearchJobsFilter";
+const _SJFL = "SearchJobsFilterList";
+const _SJR = "SearchJobsRequest";
+const _SJRe = "SearchJobsResponse";
+const _SMC = "ScriptModeConfig";
+const _SQEE = "ServiceQuotaExceededException";
+const _SQT = "SearchQuantumTasks";
+const _SQTF = "SearchQuantumTasksFilter";
+const _SQTFL = "SearchQuantumTasksFilterList";
+const _SQTR = "SearchQuantumTasksRequest";
+const _SQTRe = "SearchQuantumTasksResponse";
+const _TE = "ThrottlingException";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _VE = "ValidationException";
+const _a = "application/json";
 const _aAN = "additionalAttributeNames";
+const _aM = "actionMetadata";
+const _aS = "algorithmSpecification";
+const _aT = "actionType";
+const _ac = "action";
+const _ar = "arn";
+const _as = "associations";
+const _bD = "billableDuration";
+const _c = "client";
+const _cA = "createdAt";
+const _cC = "checkpointConfig";
+const _cI = "containerImage";
+const _cN = "channelName";
+const _cS = "cancellationStatus";
+const _cT = "clientToken";
+const _cTo = "contentType";
+const _cTom = "compressionType";
+const _d = "device";
+const _dA = "deviceArn";
+const _dC = "deviceConfig";
+const _dCe = "deviceCapabilities";
+const _dN = "deviceName";
+const _dP = "deviceParameters";
+const _dQI = "deviceQueueInfo";
+const _dS = "deviceStatus";
+const _dSa = "dataSource";
+const _dT = "deviceType";
+const _de = "devices";
+const _e = "error";
+const _eA = "endedAt";
+const _eC = "executableCount";
+const _eCx = "experimentalCapabilities";
+const _eP = "entryPoint";
+const _eT = "eventType";
+const _en = "enabled";
+const _er = "errors";
+const _ev = "events";
+const _f = "filters";
+const _fR = "failureReason";
+const _h = "http";
+const _hE = "httpError";
+const _hP = "hyperParameters";
+const _hQ = "httpQuery";
+const _iC = "instanceConfig";
+const _iCn = "instanceCount";
+const _iDC = "inputDataConfig";
+const _iI = "inputsIndex";
+const _iT = "instanceType";
+const _j = "jobs";
+const _jA = "jobArn";
+const _jN = "jobName";
+const _jT = "jobToken";
+const _kKI = "kmsKeyId";
+const _lP = "localPath";
+const _m = "message";
+const _mR = "maxResults";
+const _mRIS = "maxRuntimeInSeconds";
+const _mT = "mediaType";
+const _n = "name";
+const _nSS = "numSuccessfulShots";
+const _nT = "nextToken";
+const _o = "operator";
+const _oDC = "outputDataConfig";
+const _oSB = "outputS3Bucket";
+const _oSD = "outputS3Directory";
+const _oSKP = "outputS3KeyPrefix";
+const _p = "position";
+const _pC = "programCount";
+const _pI = "programIndex";
+const _pN = "providerName";
+const _pSVF = "programSetValidationFailures";
+const _q = "queue";
+const _qI = "queueInfo";
+const _qP = "queuePriority";
+const _qS = "queueSize";
+const _qT = "quantumTasks";
+const _qTA = "quantumTaskArn";
+const _r = "reason";
+const _rA = "roleArn";
+const _rAe = "resourceArn";
+const _s = "shots";
+const _sA = "startedAt";
+const _sC = "stoppingCondition";
+const _sDS = "s3DataSource";
+const _sMC = "scriptModeConfig";
+const _sP = "s3Path";
+const _sU = "s3Uri";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.braket";
+const _st = "status";
+const _t = "type";
 const _tK = "tagKeys";
+const _tOE = "timeOfEvent";
+const _ta = "tags";
+const _u = "uri";
+const _v = "values";
+const _vSIG = "volumeSizeInGb";
+const n0 = "com.amazonaws.braket";
+var JsonValue = [
+    0,
+    n0,
+    _JV,
+    {
+        [_mT]: _a,
+    },
+    0,
+];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var ActionMetadata = [3, n0, _AM, 0, [_aT, _pC, _eC], [0, 1, 1]];
+var AlgorithmSpecification = [
+    3,
+    n0,
+    _AS,
+    0,
+    [_sMC, _cI],
+    [() => ScriptModeConfig, () => ContainerImage],
+];
+var Association = [3, n0, _A, 0, [_ar, _t], [0, 0]];
+var CancelJobRequest = [3, n0, _CJR, 0, [_jA], [[0, 1]]];
+var CancelJobResponse = [3, n0, _CJRa, 0, [_jA, _cS], [0, 0]];
+var CancelQuantumTaskRequest = [
+    3,
+    n0,
+    _CQTR,
+    0,
+    [_qTA, _cT],
+    [
+        [0, 1],
+        [0, 4],
+    ],
+];
+var CancelQuantumTaskResponse = [3, n0, _CQTRa, 0, [_qTA, _cS], [0, 0]];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var ContainerImage = [3, n0, _CI, 0, [_u], [0]];
+var CreateJobRequest = [
+    3,
+    n0,
+    _CJRr,
+    0,
+    [_cT, _aS, _iDC, _oDC, _cC, _jN, _rA, _sC, _iC, _hP, _dC, _ta, _as],
+    [
+        [0, 4],
+        () => AlgorithmSpecification,
+        () => InputConfigList,
+        () => JobOutputDataConfig,
+        () => JobCheckpointConfig,
+        0,
+        0,
+        () => JobStoppingCondition,
+        () => InstanceConfig,
+        128 | 0,
+        () => DeviceConfig,
+        128 | 0,
+        () => Associations,
+    ],
+];
+var CreateJobResponse = [3, n0, _CJRre, 0, [_jA], [0]];
+var CreateQuantumTaskRequest = [
+    3,
+    n0,
+    _CQTRr,
+    0,
+    [_cT, _dA, _dP, _s, _oSB, _oSKP, _ac, _ta, _jT, _as, _eCx],
+    [
+        [0, 4],
+        0,
+        [() => JsonValue, 0],
+        1,
+        0,
+        0,
+        [() => JsonValue, 0],
+        128 | 0,
+        0,
+        () => Associations,
+        () => ExperimentalCapabilities,
+    ],
+];
+var CreateQuantumTaskResponse = [3, n0, _CQTRre, 0, [_qTA], [0]];
+var DataSource = [3, n0, _DS, 0, [_sDS], [() => S3DataSource]];
+var DeviceConfig = [3, n0, _DC, 0, [_d], [0]];
+var DeviceOfflineException = [
+    -3,
+    n0,
+    _DOE,
+    {
+        [_e]: _c,
+        [_hE]: 424,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DeviceOfflineException, DeviceOfflineException$1);
+var DeviceQueueInfo = [3, n0, _DQI, 0, [_q, _qS, _qP], [0, 0, 0]];
+var DeviceRetiredException = [
+    -3,
+    n0,
+    _DRE,
+    {
+        [_e]: _c,
+        [_hE]: 410,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DeviceRetiredException, DeviceRetiredException$1);
+var DeviceSummary = [3, n0, _DSe, 0, [_dA, _dN, _pN, _dT, _dS], [0, 0, 0, 0, 0]];
+var GetDeviceRequest = [3, n0, _GDR, 0, [_dA], [[0, 1]]];
+var GetDeviceResponse = [
+    3,
+    n0,
+    _GDRe,
+    0,
+    [_dA, _dN, _pN, _dT, _dS, _dCe, _dQI],
+    [0, 0, 0, 0, 0, [() => JsonValue, 0], () => DeviceQueueInfoList],
+];
+var GetJobRequest = [
+    3,
+    n0,
+    _GJR,
+    0,
+    [_jA, _aAN],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _aAN,
+            },
+        ],
+    ],
+];
+var GetJobResponse = [
+    3,
+    n0,
+    _GJRe,
+    0,
+    [_st, _jA, _rA, _fR, _jN, _hP, _iDC, _oDC, _sC, _cC, _aS, _iC, _cA, _sA, _eA, _bD, _dC, _ev, _ta, _qI, _as],
+    [
+        0,
+        0,
+        0,
+        0,
+        0,
+        128 | 0,
+        () => InputConfigList,
+        () => JobOutputDataConfig,
+        () => JobStoppingCondition,
+        () => JobCheckpointConfig,
+        () => AlgorithmSpecification,
+        () => InstanceConfig,
+        5,
+        5,
+        5,
+        1,
+        () => DeviceConfig,
+        () => JobEvents,
+        128 | 0,
+        () => HybridJobQueueInfo,
+        () => Associations,
+    ],
+];
+var GetQuantumTaskRequest = [
+    3,
+    n0,
+    _GQTR,
+    0,
+    [_qTA, _aAN],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _aAN,
+            },
+        ],
+    ],
+];
+var GetQuantumTaskResponse = [
+    3,
+    n0,
+    _GQTRe,
+    0,
+    [_qTA, _st, _fR, _dA, _dP, _s, _oSB, _oSD, _cA, _eA, _ta, _jA, _qI, _as, _nSS, _aM, _eCx],
+    [
+        0,
+        0,
+        0,
+        0,
+        [() => JsonValue, 0],
+        1,
+        0,
+        0,
+        5,
+        5,
+        128 | 0,
+        0,
+        () => QuantumTaskQueueInfo,
+        () => Associations,
+        1,
+        () => ActionMetadata,
+        () => ExperimentalCapabilities,
+    ],
+];
+var HybridJobQueueInfo = [3, n0, _HJQI, 0, [_q, _p, _m], [0, 0, 0]];
+var InputFileConfig = [3, n0, _IFC, 0, [_cN, _cTo, _dSa], [0, 0, () => DataSource]];
+var InstanceConfig = [3, n0, _IC, 0, [_iT, _vSIG, _iCn], [0, 1, 1]];
+var InternalServiceException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServiceException, InternalServiceException$1);
+var JobCheckpointConfig = [3, n0, _JCC, 0, [_lP, _sU], [0, 0]];
+var JobEventDetails = [3, n0, _JED, 0, [_eT, _tOE, _m], [0, 5, 0]];
+var JobOutputDataConfig = [3, n0, _JODC, 0, [_kKI, _sP], [0, 0]];
+var JobStoppingCondition = [3, n0, _JSC, 0, [_mRIS], [1]];
+var JobSummary = [
+    3,
+    n0,
+    _JS,
+    0,
+    [_st, _jA, _jN, _d, _cA, _sA, _eA, _ta],
+    [0, 0, 0, 0, 5, 5, 5, 128 | 0],
+];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rAe], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_ta], [128 | 0]];
+var ProgramSetValidationFailure = [3, n0, _PSVF, 0, [_pI, _iI, _er], [1, 1, 64 | 0]];
+var QuantumTaskQueueInfo = [3, n0, _QTQI, 0, [_q, _p, _qP, _m], [0, 0, 0, 0]];
+var QuantumTaskSummary = [
+    3,
+    n0,
+    _QTS,
+    0,
+    [_qTA, _st, _dA, _s, _oSB, _oSD, _cA, _eA, _ta],
+    [0, 0, 0, 1, 0, 0, 5, 5, 128 | 0],
+];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var S3DataSource = [3, n0, _SDS, 0, [_sU], [0]];
+var ScriptModeConfig = [3, n0, _SMC, 0, [_eP, _sU, _cTom], [0, 0, 0]];
+var SearchDevicesFilter = [3, n0, _SDF, 0, [_n, _v], [0, 64 | 0]];
+var SearchDevicesRequest = [
+    3,
+    n0,
+    _SDR,
+    0,
+    [_nT, _mR, _f],
+    [0, 1, () => SearchDevicesFilterList],
+];
+var SearchDevicesResponse = [3, n0, _SDRe, 0, [_de, _nT], [() => DeviceSummaryList, 0]];
+var SearchJobsFilter = [3, n0, _SJF, 0, [_n, _v, _o], [0, 64 | 0, 0]];
+var SearchJobsRequest = [
+    3,
+    n0,
+    _SJR,
+    0,
+    [_nT, _mR, _f],
+    [0, 1, () => SearchJobsFilterList],
+];
+var SearchJobsResponse = [3, n0, _SJRe, 0, [_j, _nT], [() => JobSummaryList, 0]];
+var SearchQuantumTasksFilter = [3, n0, _SQTF, 0, [_n, _v, _o], [0, 64 | 0, 0]];
+var SearchQuantumTasksRequest = [
+    3,
+    n0,
+    _SQTR,
+    0,
+    [_nT, _mR, _f],
+    [0, 1, () => SearchQuantumTasksFilterList],
+];
+var SearchQuantumTasksResponse = [
+    3,
+    n0,
+    _SQTRe,
+    0,
+    [_qT, _nT],
+    [() => QuantumTaskSummaryList, 0],
+];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var TagResourceRequest = [3, n0, _TRR, 0, [_rAe, _ta], [[0, 1], 128 | 0]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_rAe, _tK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m, _r, _pSVF],
+    [0, 0, () => ProgramSetValidationFailuresList],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var BraketServiceException = [-3, _sm, "BraketServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(BraketServiceException, BraketServiceException$1);
+var Associations = [1, n0, _As, 0, () => Association];
+var DeviceQueueInfoList = [1, n0, _DQIL, 0, () => DeviceQueueInfo];
+var DeviceSummaryList = [1, n0, _DSL, 0, () => DeviceSummary];
+var InputConfigList = [1, n0, _ICL, 0, () => InputFileConfig];
+var JobEvents = [1, n0, _JE, 0, () => JobEventDetails];
+var JobSummaryList = [1, n0, _JSL, 0, () => JobSummary];
+var ProgramSetValidationFailuresList = [1, n0, _PSVFL, 0, () => ProgramSetValidationFailure];
+var QuantumTaskSummaryList = [1, n0, _QTSL, 0, () => QuantumTaskSummary];
+var SearchDevicesFilterList = [1, n0, _SDFL, 0, () => SearchDevicesFilter];
+var SearchJobsFilterList = [1, n0, _SJFL, 0, () => SearchJobsFilter];
+var SearchQuantumTasksFilterList = [1, n0, _SQTFL, 0, () => SearchQuantumTasksFilter];
+var ExperimentalCapabilities = [3, n0, _EC, 0, [_en], [0]];
+var CancelJob = [
+    9,
+    n0,
+    _CJ,
+    {
+        [_h]: ["PUT", "/job/{jobArn}/cancel", 200],
+    },
+    () => CancelJobRequest,
+    () => CancelJobResponse,
+];
+var CancelQuantumTask = [
+    9,
+    n0,
+    _CQT,
+    {
+        [_h]: ["PUT", "/quantum-task/{quantumTaskArn}/cancel", 200],
+    },
+    () => CancelQuantumTaskRequest,
+    () => CancelQuantumTaskResponse,
+];
+var CreateJob = [
+    9,
+    n0,
+    _CJr,
+    {
+        [_h]: ["POST", "/job", 201],
+    },
+    () => CreateJobRequest,
+    () => CreateJobResponse,
+];
+var CreateQuantumTask = [
+    9,
+    n0,
+    _CQTr,
+    {
+        [_h]: ["POST", "/quantum-task", 201],
+    },
+    () => CreateQuantumTaskRequest,
+    () => CreateQuantumTaskResponse,
+];
+var GetDevice = [
+    9,
+    n0,
+    _GD,
+    {
+        [_h]: ["GET", "/device/{deviceArn}", 200],
+    },
+    () => GetDeviceRequest,
+    () => GetDeviceResponse,
+];
+var GetJob = [
+    9,
+    n0,
+    _GJ,
+    {
+        [_h]: ["GET", "/job/{jobArn}", 200],
+    },
+    () => GetJobRequest,
+    () => GetJobResponse,
+];
+var GetQuantumTask = [
+    9,
+    n0,
+    _GQT,
+    {
+        [_h]: ["GET", "/quantum-task/{quantumTaskArn}", 200],
+    },
+    () => GetQuantumTaskRequest,
+    () => GetQuantumTaskResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags/{resourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var SearchDevices = [
+    9,
+    n0,
+    _SD,
+    {
+        [_h]: ["POST", "/devices", 200],
+    },
+    () => SearchDevicesRequest,
+    () => SearchDevicesResponse,
+];
+var SearchJobs = [
+    9,
+    n0,
+    _SJ,
+    {
+        [_h]: ["POST", "/jobs", 200],
+    },
+    () => SearchJobsRequest,
+    () => SearchJobsResponse,
+];
+var SearchQuantumTasks = [
+    9,
+    n0,
+    _SQT,
+    {
+        [_h]: ["POST", "/quantum-tasks", 200],
+    },
+    () => SearchQuantumTasksRequest,
+    () => SearchQuantumTasksResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/tags/{resourceArn}", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/tags/{resourceArn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
 
 class CancelJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "CancelJob", {})
     .n("BraketClient", "CancelJobCommand")
-    .f(void 0, void 0)
-    .ser(se_CancelJobCommand)
-    .de(de_CancelJobCommand)
+    .sc(CancelJob)
     .build() {
 }
 
@@ -1022,16 +1076,11 @@ class CancelQuantumTaskCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "CancelQuantumTask", {})
     .n("BraketClient", "CancelQuantumTaskCommand")
-    .f(void 0, void 0)
-    .ser(se_CancelQuantumTaskCommand)
-    .de(de_CancelQuantumTaskCommand)
+    .sc(CancelQuantumTask)
     .build() {
 }
 
@@ -1039,16 +1088,11 @@ class CreateJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "CreateJob", {})
     .n("BraketClient", "CreateJobCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateJobCommand)
-    .de(de_CreateJobCommand)
+    .sc(CreateJob)
     .build() {
 }
 
@@ -1056,16 +1100,11 @@ class CreateQuantumTaskCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "CreateQuantumTask", {})
     .n("BraketClient", "CreateQuantumTaskCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateQuantumTaskCommand)
-    .de(de_CreateQuantumTaskCommand)
+    .sc(CreateQuantumTask)
     .build() {
 }
 
@@ -1073,16 +1112,11 @@ class GetDeviceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "GetDevice", {})
     .n("BraketClient", "GetDeviceCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDeviceCommand)
-    .de(de_GetDeviceCommand)
+    .sc(GetDevice)
     .build() {
 }
 
@@ -1090,16 +1124,11 @@ class GetJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "GetJob", {})
     .n("BraketClient", "GetJobCommand")
-    .f(void 0, void 0)
-    .ser(se_GetJobCommand)
-    .de(de_GetJobCommand)
+    .sc(GetJob)
     .build() {
 }
 
@@ -1107,16 +1136,11 @@ class GetQuantumTaskCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "GetQuantumTask", {})
     .n("BraketClient", "GetQuantumTaskCommand")
-    .f(void 0, void 0)
-    .ser(se_GetQuantumTaskCommand)
-    .de(de_GetQuantumTaskCommand)
+    .sc(GetQuantumTask)
     .build() {
 }
 
@@ -1124,16 +1148,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "ListTagsForResource", {})
     .n("BraketClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1141,16 +1160,11 @@ class SearchDevicesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "SearchDevices", {})
     .n("BraketClient", "SearchDevicesCommand")
-    .f(void 0, void 0)
-    .ser(se_SearchDevicesCommand)
-    .de(de_SearchDevicesCommand)
+    .sc(SearchDevices)
     .build() {
 }
 
@@ -1158,16 +1172,11 @@ class SearchJobsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "SearchJobs", {})
     .n("BraketClient", "SearchJobsCommand")
-    .f(void 0, void 0)
-    .ser(se_SearchJobsCommand)
-    .de(de_SearchJobsCommand)
+    .sc(SearchJobs)
     .build() {
 }
 
@@ -1175,16 +1184,11 @@ class SearchQuantumTasksCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "SearchQuantumTasks", {})
     .n("BraketClient", "SearchQuantumTasksCommand")
-    .f(void 0, void 0)
-    .ser(se_SearchQuantumTasksCommand)
-    .de(de_SearchQuantumTasksCommand)
+    .sc(SearchQuantumTasks)
     .build() {
 }
 
@@ -1192,16 +1196,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "TagResource", {})
     .n("BraketClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1209,16 +1208,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Braket", "UntagResource", {})
     .n("BraketClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1255,20 +1249,20 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AssociationType = AssociationType;
 exports.Braket = Braket;
 exports.BraketClient = BraketClient;
-exports.BraketServiceException = BraketServiceException;
+exports.BraketServiceException = BraketServiceException$1;
 exports.CancelJobCommand = CancelJobCommand;
 exports.CancelQuantumTaskCommand = CancelQuantumTaskCommand;
 exports.CancellationStatus = CancellationStatus;
 exports.CompressionType = CompressionType;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.CreateJobCommand = CreateJobCommand;
 exports.CreateQuantumTaskCommand = CreateQuantumTaskCommand;
-exports.DeviceOfflineException = DeviceOfflineException;
-exports.DeviceRetiredException = DeviceRetiredException;
+exports.DeviceOfflineException = DeviceOfflineException$1;
+exports.DeviceRetiredException = DeviceRetiredException$1;
 exports.DeviceStatus = DeviceStatus;
 exports.DeviceType = DeviceType;
 exports.ExperimentalCapabilitiesEnablementType = ExperimentalCapabilitiesEnablementType;
@@ -1276,7 +1270,7 @@ exports.GetDeviceCommand = GetDeviceCommand;
 exports.GetJobCommand = GetJobCommand;
 exports.GetQuantumTaskCommand = GetQuantumTaskCommand;
 exports.HybridJobAdditionalAttributeName = HybridJobAdditionalAttributeName;
-exports.InternalServiceException = InternalServiceException;
+exports.InternalServiceException = InternalServiceException$1;
 exports.JobEventType = JobEventType;
 exports.JobPrimaryStatus = JobPrimaryStatus;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
@@ -1284,17 +1278,17 @@ exports.QuantumTaskAdditionalAttributeName = QuantumTaskAdditionalAttributeName;
 exports.QuantumTaskStatus = QuantumTaskStatus;
 exports.QueueName = QueueName;
 exports.QueuePriority = QueuePriority;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.SearchDevicesCommand = SearchDevicesCommand;
 exports.SearchJobsCommand = SearchJobsCommand;
 exports.SearchJobsFilterOperator = SearchJobsFilterOperator;
 exports.SearchQuantumTasksCommand = SearchQuantumTasksCommand;
 exports.SearchQuantumTasksFilterOperator = SearchQuantumTasksFilterOperator;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.ValidationExceptionReason = ValidationExceptionReason;
 exports._InstanceType = _InstanceType;
 exports.paginateSearchDevices = paginateSearchDevices;