@aws-sdk/client-s3vectors 3.928.0 → 3.930.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -89,6 +88,7 @@ class S3VectorsClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -108,14 +108,14 @@ class S3VectorsClient extends smithyClient.Client {
     }
 }
 
-class S3VectorsServiceException extends smithyClient.ServiceException {
+let S3VectorsServiceException$1 = class S3VectorsServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, S3VectorsServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends S3VectorsServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends S3VectorsServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -126,8 +126,8 @@ class AccessDeniedException extends S3VectorsServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
-class ConflictException extends S3VectorsServiceException {
+};
+let ConflictException$1 = class ConflictException extends S3VectorsServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     constructor(opts) {
@@ -138,7 +138,7 @@ class ConflictException extends S3VectorsServiceException {
         });
         Object.setPrototypeOf(this, ConflictException.prototype);
     }
-}
+};
 const DataType = {
     FLOAT32: "float32",
 };
@@ -146,7 +146,7 @@ const DistanceMetric = {
     COSINE: "cosine",
     EUCLIDEAN: "euclidean",
 };
-class InternalServerException extends S3VectorsServiceException {
+let InternalServerException$1 = class InternalServerException extends S3VectorsServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     $retryable = {};
@@ -158,8 +158,8 @@ class InternalServerException extends S3VectorsServiceException {
         });
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
-}
-class NotFoundException extends S3VectorsServiceException {
+};
+let NotFoundException$1 = class NotFoundException extends S3VectorsServiceException$1 {
     name = "NotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -170,8 +170,8 @@ class NotFoundException extends S3VectorsServiceException {
         });
         Object.setPrototypeOf(this, NotFoundException.prototype);
     }
-}
-class RequestTimeoutException extends S3VectorsServiceException {
+};
+let RequestTimeoutException$1 = class RequestTimeoutException extends S3VectorsServiceException$1 {
     name = "RequestTimeoutException";
     $fault = "client";
     $retryable = {};
@@ -183,8 +183,8 @@ class RequestTimeoutException extends S3VectorsServiceException {
         });
         Object.setPrototypeOf(this, RequestTimeoutException.prototype);
     }
-}
-class ServiceQuotaExceededException extends S3VectorsServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends S3VectorsServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     constructor(opts) {
@@ -195,8 +195,8 @@ class ServiceQuotaExceededException extends S3VectorsServiceException {
         });
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
     }
-}
-class ServiceUnavailableException extends S3VectorsServiceException {
+};
+let ServiceUnavailableException$1 = class ServiceUnavailableException extends S3VectorsServiceException$1 {
     name = "ServiceUnavailableException";
     $fault = "server";
     $retryable = {};
@@ -208,8 +208,8 @@ class ServiceUnavailableException extends S3VectorsServiceException {
         });
         Object.setPrototypeOf(this, ServiceUnavailableException.prototype);
     }
-}
-class TooManyRequestsException extends S3VectorsServiceException {
+};
+let TooManyRequestsException$1 = class TooManyRequestsException extends S3VectorsServiceException$1 {
     name = "TooManyRequestsException";
     $fault = "client";
     $retryable = {
@@ -223,8 +223,8 @@ class TooManyRequestsException extends S3VectorsServiceException {
         });
         Object.setPrototypeOf(this, TooManyRequestsException.prototype);
     }
-}
-class ValidationException extends S3VectorsServiceException {
+};
+let ValidationException$1 = class ValidationException extends S3VectorsServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     fieldList;
@@ -237,12 +237,12 @@ class ValidationException extends S3VectorsServiceException {
         Object.setPrototypeOf(this, ValidationException.prototype);
         this.fieldList = opts.fieldList;
     }
-}
+};
 const SseType = {
     AES256: "AES256",
     AWS_KMS: "aws:kms",
 };
-class KmsDisabledException extends S3VectorsServiceException {
+let KmsDisabledException$1 = class KmsDisabledException extends S3VectorsServiceException$1 {
     name = "KmsDisabledException";
     $fault = "client";
     constructor(opts) {
@@ -253,8 +253,8 @@ class KmsDisabledException extends S3VectorsServiceException {
         });
         Object.setPrototypeOf(this, KmsDisabledException.prototype);
     }
-}
-class KmsInvalidKeyUsageException extends S3VectorsServiceException {
+};
+let KmsInvalidKeyUsageException$1 = class KmsInvalidKeyUsageException extends S3VectorsServiceException$1 {
     name = "KmsInvalidKeyUsageException";
     $fault = "client";
     constructor(opts) {
@@ -265,8 +265,8 @@ class KmsInvalidKeyUsageException extends S3VectorsServiceException {
         });
         Object.setPrototypeOf(this, KmsInvalidKeyUsageException.prototype);
     }
-}
-class KmsInvalidStateException extends S3VectorsServiceException {
+};
+let KmsInvalidStateException$1 = class KmsInvalidStateException extends S3VectorsServiceException$1 {
     name = "KmsInvalidStateException";
     $fault = "client";
     constructor(opts) {
@@ -277,8 +277,8 @@ class KmsInvalidStateException extends S3VectorsServiceException {
         });
         Object.setPrototypeOf(this, KmsInvalidStateException.prototype);
     }
-}
-class KmsNotFoundException extends S3VectorsServiceException {
+};
+let KmsNotFoundException$1 = class KmsNotFoundException extends S3VectorsServiceException$1 {
     name = "KmsNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -289,873 +289,582 @@ class KmsNotFoundException extends S3VectorsServiceException {
         });
         Object.setPrototypeOf(this, KmsNotFoundException.prototype);
     }
-}
-exports.VectorData = void 0;
-(function (VectorData) {
-    VectorData.visit = (value, visitor) => {
-        if (value.float32 !== undefined)
-            return visitor.float32(value.float32);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(exports.VectorData || (exports.VectorData = {}));
-
-const se_CreateIndexCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateIndex");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        dataType: [],
-        dimension: [],
-        distanceMetric: [],
-        indexName: [],
-        metadataConfiguration: (_) => smithyClient._json(_),
-        vectorBucketArn: [],
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
 };
-const se_CreateVectorBucketCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateVectorBucket");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        encryptionConfiguration: (_) => smithyClient._json(_),
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteIndexCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteIndex");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        indexArn: [],
-        indexName: [],
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteVectorBucketCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteVectorBucket");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        vectorBucketArn: [],
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteVectorBucketPolicyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteVectorBucketPolicy");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        vectorBucketArn: [],
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteVectorsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteVectors");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        indexArn: [],
-        indexName: [],
-        keys: (_) => smithyClient._json(_),
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetIndexCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetIndex");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        indexArn: [],
-        indexName: [],
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetVectorBucketCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetVectorBucket");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        vectorBucketArn: [],
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetVectorBucketPolicyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetVectorBucketPolicy");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        vectorBucketArn: [],
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetVectorsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetVectors");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        indexArn: [],
-        indexName: [],
-        keys: (_) => smithyClient._json(_),
-        returnData: [],
-        returnMetadata: [],
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListIndexesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListIndexes");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-        prefix: [],
-        vectorBucketArn: [],
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListVectorBucketsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListVectorBuckets");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-        prefix: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListVectorsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListVectors");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        indexArn: [],
-        indexName: [],
-        maxResults: [],
-        nextToken: [],
-        returnData: [],
-        returnMetadata: [],
-        segmentCount: [],
-        segmentIndex: [],
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_PutVectorBucketPolicyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/PutVectorBucketPolicy");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        policy: [],
-        vectorBucketArn: [],
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_PutVectorsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/PutVectors");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        indexArn: [],
-        indexName: [],
-        vectorBucketName: [],
-        vectors: (_) => se_PutVectorsInputList(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_QueryVectorsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/QueryVectors");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filter: (_) => se_Document(_),
-        indexArn: [],
-        indexName: [],
-        queryVector: (_) => se_VectorData(_),
-        returnDistance: [],
-        returnMetadata: [],
-        topK: [],
-        vectorBucketName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_CreateIndexCommand = 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, {
-        indexArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateVectorBucketCommand = 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, {
-        vectorBucketArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteIndexCommand = 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_DeleteVectorBucketCommand = 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_DeleteVectorBucketPolicyCommand = 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_DeleteVectorsCommand = 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_GetIndexCommand = 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, {
-        index: (_) => de_Index(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetVectorBucketCommand = 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, {
-        vectorBucket: (_) => de_VectorBucket(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetVectorBucketPolicyCommand = 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, {
-        policy: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetVectorsCommand = 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, {
-        vectors: (_) => de_GetVectorsOutputList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListIndexesCommand = 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, {
-        indexes: (_) => de_ListIndexesOutputList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListVectorBucketsCommand = 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,
-        vectorBuckets: (_) => de_ListVectorBucketsOutputList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListVectorsCommand = 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,
-        vectors: (_) => de_ListVectorsOutputList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_PutVectorBucketPolicyCommand = 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_PutVectorsCommand = 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_QueryVectorsCommand = 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, {
-        distanceMetric: smithyClient.expectString,
-        vectors: (_) => de_QueryVectorsOutputList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.s3vectors#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.s3vectors#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.s3vectors#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "NotFoundException":
-        case "com.amazonaws.s3vectors#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput);
-        case "RequestTimeoutException":
-        case "com.amazonaws.s3vectors#RequestTimeoutException":
-            throw await de_RequestTimeoutExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.s3vectors#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.s3vectors#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput);
-        case "TooManyRequestsException":
-        case "com.amazonaws.s3vectors#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.s3vectors#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "KmsDisabledException":
-        case "com.amazonaws.s3vectors#KmsDisabledException":
-            throw await de_KmsDisabledExceptionRes(parsedOutput);
-        case "KmsInvalidKeyUsageException":
-        case "com.amazonaws.s3vectors#KmsInvalidKeyUsageException":
-            throw await de_KmsInvalidKeyUsageExceptionRes(parsedOutput);
-        case "KmsInvalidStateException":
-        case "com.amazonaws.s3vectors#KmsInvalidStateException":
-            throw await de_KmsInvalidStateExceptionRes(parsedOutput);
-        case "KmsNotFoundException":
-        case "com.amazonaws.s3vectors#KmsNotFoundException":
-            throw await de_KmsNotFoundExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(S3VectorsServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_KmsDisabledExceptionRes = 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 KmsDisabledException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_KmsInvalidKeyUsageExceptionRes = 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 KmsInvalidKeyUsageException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_KmsInvalidStateExceptionRes = 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 KmsInvalidStateException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_KmsNotFoundExceptionRes = 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 KmsNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_NotFoundExceptionRes = 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 NotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_RequestTimeoutExceptionRes = 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 RequestTimeoutException({
-        $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_ServiceUnavailableExceptionRes = 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 ServiceUnavailableException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_TooManyRequestsExceptionRes = 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 TooManyRequestsException({
-        $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, {
-        fieldList: smithyClient._json,
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_Float32VectorData = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.serializeFloat(entry);
-    });
-};
-const se_PutInputVector = (input, context) => {
-    return smithyClient.take(input, {
-        data: (_) => se_VectorData(_),
-        key: [],
-        metadata: (_) => se_VectorMetadata(_),
-    });
-};
-const se_PutVectorsInputList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_PutInputVector(entry);
-    });
-};
-const se_VectorData = (input, context) => {
-    return exports.VectorData.visit(input, {
-        float32: (value) => ({ float32: se_Float32VectorData(value) }),
-        _: (name, value) => ({ [name]: value }),
-    });
-};
-const se_VectorMetadata = (input, context) => {
-    return input;
-};
-const se_Document = (input, context) => {
-    return input;
-};
-const de_Float32VectorData = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.limitedParseFloat32(entry);
-    });
-    return retVal;
-};
-const de_GetOutputVector = (output, context) => {
-    return smithyClient.take(output, {
-        data: (_) => de_VectorData(core$1.awsExpectUnion(_)),
-        key: smithyClient.expectString,
-        metadata: (_) => de_VectorMetadata(_),
-    });
-};
-const de_GetVectorsOutputList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_GetOutputVector(entry);
-    });
-    return retVal;
-};
-const de_Index = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        dataType: smithyClient.expectString,
-        dimension: smithyClient.expectInt32,
-        distanceMetric: smithyClient.expectString,
-        indexArn: smithyClient.expectString,
-        indexName: smithyClient.expectString,
-        metadataConfiguration: smithyClient._json,
-        vectorBucketName: smithyClient.expectString,
-    });
-};
-const de_IndexSummary = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        indexArn: smithyClient.expectString,
-        indexName: smithyClient.expectString,
-        vectorBucketName: smithyClient.expectString,
-    });
-};
-const de_ListIndexesOutputList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_IndexSummary(entry);
-    });
-    return retVal;
-};
-const de_ListOutputVector = (output, context) => {
-    return smithyClient.take(output, {
-        data: (_) => de_VectorData(core$1.awsExpectUnion(_)),
-        key: smithyClient.expectString,
-        metadata: (_) => de_VectorMetadata(_),
-    });
-};
-const de_ListVectorBucketsOutputList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_VectorBucketSummary(entry);
-    });
-    return retVal;
-};
-const de_ListVectorsOutputList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ListOutputVector(entry);
-    });
-    return retVal;
-};
-const de_QueryOutputVector = (output, context) => {
-    return smithyClient.take(output, {
-        data: (_) => de_VectorData(core$1.awsExpectUnion(_)),
-        distance: smithyClient.limitedParseFloat32,
-        key: smithyClient.expectString,
-        metadata: (_) => de_VectorMetadata(_),
-    });
-};
-const de_QueryVectorsOutputList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_QueryOutputVector(entry);
-    });
-    return retVal;
-};
-const de_VectorBucket = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        encryptionConfiguration: smithyClient._json,
-        vectorBucketArn: smithyClient.expectString,
-        vectorBucketName: smithyClient.expectString,
-    });
-};
-const de_VectorBucketSummary = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        vectorBucketArn: smithyClient.expectString,
-        vectorBucketName: smithyClient.expectString,
-    });
-};
-const de_VectorData = (output, context) => {
-    if (output.float32 != null) {
-        return {
-            float32: de_Float32VectorData(output.float32),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_VectorMetadata = (output, context) => {
-    return output;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
+
+const _ADE = "AccessDeniedException";
+const _CE = "ConflictException";
+const _CI = "CreateIndex";
+const _CII = "CreateIndexInput";
+const _CIO = "CreateIndexOutput";
+const _CVB = "CreateVectorBucket";
+const _CVBI = "CreateVectorBucketInput";
+const _CVBO = "CreateVectorBucketOutput";
+const _DI = "DeleteIndex";
+const _DII = "DeleteIndexInput";
+const _DIO = "DeleteIndexOutput";
+const _DV = "DeleteVectors";
+const _DVB = "DeleteVectorBucket";
+const _DVBI = "DeleteVectorBucketInput";
+const _DVBO = "DeleteVectorBucketOutput";
+const _DVBP = "DeleteVectorBucketPolicy";
+const _DVBPI = "DeleteVectorBucketPolicyInput";
+const _DVBPO = "DeleteVectorBucketPolicyOutput";
+const _DVI = "DeleteVectorsInput";
+const _DVO = "DeleteVectorsOutput";
+const _EC = "EncryptionConfiguration";
+const _GI = "GetIndex";
+const _GII = "GetIndexInput";
+const _GIO = "GetIndexOutput";
+const _GOV = "GetOutputVector";
+const _GV = "GetVectors";
+const _GVB = "GetVectorBucket";
+const _GVBI = "GetVectorBucketInput";
+const _GVBO = "GetVectorBucketOutput";
+const _GVBP = "GetVectorBucketPolicy";
+const _GVBPI = "GetVectorBucketPolicyInput";
+const _GVBPO = "GetVectorBucketPolicyOutput";
+const _GVI = "GetVectorsInput";
+const _GVO = "GetVectorsOutput";
+const _GVOL = "GetVectorsOutputList";
+const _I = "Index";
+const _IS = "IndexSummary";
+const _ISE = "InternalServerException";
+const _KDE = "KmsDisabledException";
+const _KIKUE = "KmsInvalidKeyUsageException";
+const _KISE = "KmsInvalidStateException";
+const _KNFE = "KmsNotFoundException";
+const _LI = "ListIndexes";
+const _LII = "ListIndexesInput";
+const _LIO = "ListIndexesOutput";
+const _LIOL = "ListIndexesOutputList";
+const _LOV = "ListOutputVector";
+const _LV = "ListVectors";
+const _LVB = "ListVectorBuckets";
+const _LVBI = "ListVectorBucketsInput";
+const _LVBO = "ListVectorBucketsOutput";
+const _LVBOL = "ListVectorBucketsOutputList";
+const _LVI = "ListVectorsInput";
+const _LVO = "ListVectorsOutput";
+const _LVOL = "ListVectorsOutputList";
+const _MC = "MetadataConfiguration";
+const _NFE = "NotFoundException";
+const _PIV = "PutInputVector";
+const _PV = "PutVectors";
+const _PVBP = "PutVectorBucketPolicy";
+const _PVBPI = "PutVectorBucketPolicyInput";
+const _PVBPO = "PutVectorBucketPolicyOutput";
+const _PVI = "PutVectorsInput";
+const _PVIL = "PutVectorsInputList";
+const _PVO = "PutVectorsOutput";
+const _QOV = "QueryOutputVector";
+const _QV = "QueryVectors";
+const _QVI = "QueryVectorsInput";
+const _QVO = "QueryVectorsOutput";
+const _QVOL = "QueryVectorsOutputList";
+const _RTE = "RequestTimeoutException";
+const _SQEE = "ServiceQuotaExceededException";
+const _SUE = "ServiceUnavailableException";
+const _TMRE = "TooManyRequestsException";
+const _VB = "VectorBucket";
+const _VBS = "VectorBucketSummary";
+const _VD = "VectorData";
+const _VE = "ValidationException";
+const _VEF = "ValidationExceptionField";
+const _VEFL = "ValidationExceptionFieldList";
+const _c = "client";
+const _cT = "creationTime";
+const _d = "dimension";
+const _dM = "distanceMetric";
+const _dT = "dataType";
+const _da = "data";
+const _di = "distance";
+const _e = "error";
+const _eC = "encryptionConfiguration";
+const _f = "filter";
+const _fL = "fieldList";
+const _fl = "float32";
+const _h = "http";
+const _hE = "httpError";
+const _i = "index";
+const _iA = "indexArn";
+const _iN = "indexName";
+const _in = "indexes";
+const _k = "keys";
+const _kKA = "kmsKeyArn";
+const _ke = "key";
+const _m = "message";
+const _mC = "metadataConfiguration";
+const _mR = "maxResults";
+const _me = "metadata";
+const _nFMK = "nonFilterableMetadataKeys";
+const _nT = "nextToken";
+const _p = "policy";
+const _pa = "path";
+const _pr = "prefix";
+const _qV = "queryVector";
+const _rD = "returnData";
+const _rDe = "returnDistance";
+const _rM = "returnMetadata";
+const _s = "server";
+const _sC = "segmentCount";
+const _sI = "segmentIndex";
+const _sT = "sseType";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.s3vectors";
+const _tK = "topK";
+const _v = "vectors";
+const _vB = "vectorBucket";
+const _vBA = "vectorBucketArn";
+const _vBN = "vectorBucketName";
+const _vBe = "vectorBuckets";
+const n0 = "com.amazonaws.s3vectors";
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateIndexInput = [
+    3,
+    n0,
+    _CII,
+    0,
+    [_vBN, _vBA, _iN, _dT, _d, _dM, _mC],
+    [0, 0, 0, 0, 1, 0, () => MetadataConfiguration],
+];
+var CreateIndexOutput = [3, n0, _CIO, 0, [_iA], [0]];
+var CreateVectorBucketInput = [
+    3,
+    n0,
+    _CVBI,
+    0,
+    [_vBN, _eC],
+    [0, () => EncryptionConfiguration],
+];
+var CreateVectorBucketOutput = [3, n0, _CVBO, 0, [_vBA], [0]];
+var DeleteIndexInput = [3, n0, _DII, 0, [_vBN, _iN, _iA], [0, 0, 0]];
+var DeleteIndexOutput = [3, n0, _DIO, 0, [], []];
+var DeleteVectorBucketInput = [3, n0, _DVBI, 0, [_vBN, _vBA], [0, 0]];
+var DeleteVectorBucketOutput = [3, n0, _DVBO, 0, [], []];
+var DeleteVectorBucketPolicyInput = [3, n0, _DVBPI, 0, [_vBN, _vBA], [0, 0]];
+var DeleteVectorBucketPolicyOutput = [3, n0, _DVBPO, 0, [], []];
+var DeleteVectorsInput = [3, n0, _DVI, 0, [_vBN, _iN, _iA, _k], [0, 0, 0, 64 | 0]];
+var DeleteVectorsOutput = [3, n0, _DVO, 0, [], []];
+var EncryptionConfiguration = [3, n0, _EC, 0, [_sT, _kKA], [0, 0]];
+var GetIndexInput = [3, n0, _GII, 0, [_vBN, _iN, _iA], [0, 0, 0]];
+var GetIndexOutput = [3, n0, _GIO, 0, [_i], [() => Index]];
+var GetOutputVector = [3, n0, _GOV, 0, [_ke, _da, _me], [0, () => VectorData, 15]];
+var GetVectorBucketInput = [3, n0, _GVBI, 0, [_vBN, _vBA], [0, 0]];
+var GetVectorBucketOutput = [3, n0, _GVBO, 0, [_vB], [() => VectorBucket]];
+var GetVectorBucketPolicyInput = [3, n0, _GVBPI, 0, [_vBN, _vBA], [0, 0]];
+var GetVectorBucketPolicyOutput = [3, n0, _GVBPO, 0, [_p], [0]];
+var GetVectorsInput = [
+    3,
+    n0,
+    _GVI,
+    0,
+    [_vBN, _iN, _iA, _k, _rD, _rM],
+    [0, 0, 0, 64 | 0, 2, 2],
+];
+var GetVectorsOutput = [3, n0, _GVO, 0, [_v], [() => GetVectorsOutputList]];
+var Index = [
+    3,
+    n0,
+    _I,
+    0,
+    [_vBN, _iN, _iA, _cT, _dT, _d, _dM, _mC],
+    [0, 0, 0, 4, 0, 1, 0, () => MetadataConfiguration],
+];
+var IndexSummary = [3, n0, _IS, 0, [_vBN, _iN, _iA, _cT], [0, 0, 0, 4]];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var KmsDisabledException = [
+    -3,
+    n0,
+    _KDE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(KmsDisabledException, KmsDisabledException$1);
+var KmsInvalidKeyUsageException = [
+    -3,
+    n0,
+    _KIKUE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(KmsInvalidKeyUsageException, KmsInvalidKeyUsageException$1);
+var KmsInvalidStateException = [
+    -3,
+    n0,
+    _KISE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(KmsInvalidStateException, KmsInvalidStateException$1);
+var KmsNotFoundException = [
+    -3,
+    n0,
+    _KNFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(KmsNotFoundException, KmsNotFoundException$1);
+var ListIndexesInput = [3, n0, _LII, 0, [_vBN, _vBA, _mR, _nT, _pr], [0, 0, 1, 0, 0]];
+var ListIndexesOutput = [3, n0, _LIO, 0, [_nT, _in], [0, () => ListIndexesOutputList]];
+var ListOutputVector = [3, n0, _LOV, 0, [_ke, _da, _me], [0, () => VectorData, 15]];
+var ListVectorBucketsInput = [3, n0, _LVBI, 0, [_mR, _nT, _pr], [1, 0, 0]];
+var ListVectorBucketsOutput = [
+    3,
+    n0,
+    _LVBO,
+    0,
+    [_nT, _vBe],
+    [0, () => ListVectorBucketsOutputList],
+];
+var ListVectorsInput = [
+    3,
+    n0,
+    _LVI,
+    0,
+    [_vBN, _iN, _iA, _mR, _nT, _sC, _sI, _rD, _rM],
+    [0, 0, 0, 1, 0, 1, 1, 2, 2],
+];
+var ListVectorsOutput = [3, n0, _LVO, 0, [_nT, _v], [0, () => ListVectorsOutputList]];
+var MetadataConfiguration = [3, n0, _MC, 0, [_nFMK], [64 | 0]];
+var NotFoundException = [
+    -3,
+    n0,
+    _NFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(NotFoundException, NotFoundException$1);
+var PutInputVector = [3, n0, _PIV, 0, [_ke, _da, _me], [0, () => VectorData, 15]];
+var PutVectorBucketPolicyInput = [3, n0, _PVBPI, 0, [_vBN, _vBA, _p], [0, 0, 0]];
+var PutVectorBucketPolicyOutput = [3, n0, _PVBPO, 0, [], []];
+var PutVectorsInput = [
+    3,
+    n0,
+    _PVI,
+    0,
+    [_vBN, _iN, _iA, _v],
+    [0, 0, 0, () => PutVectorsInputList],
+];
+var PutVectorsOutput = [3, n0, _PVO, 0, [], []];
+var QueryOutputVector = [
+    3,
+    n0,
+    _QOV,
+    0,
+    [_ke, _da, _me, _di],
+    [0, () => VectorData, 15, 1],
+];
+var QueryVectorsInput = [
+    3,
+    n0,
+    _QVI,
+    0,
+    [_vBN, _iN, _iA, _tK, _qV, _f, _rM, _rDe],
+    [0, 0, 0, 1, () => VectorData, 15, 2, 2],
+];
+var QueryVectorsOutput = [3, n0, _QVO, 0, [_v, _dM], [() => QueryVectorsOutputList, 0]];
+var RequestTimeoutException = [
+    -3,
+    n0,
+    _RTE,
+    {
+        [_e]: _c,
+        [_hE]: 408,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(RequestTimeoutException, RequestTimeoutException$1);
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var ServiceUnavailableException = [
+    -3,
+    n0,
+    _SUE,
+    {
+        [_e]: _s,
+        [_hE]: 503,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceUnavailableException, ServiceUnavailableException$1);
+var TooManyRequestsException = [
+    -3,
+    n0,
+    _TMRE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyRequestsException, TooManyRequestsException$1);
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+    },
+    [_m, _fL],
+    [0, () => ValidationExceptionFieldList],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var ValidationExceptionField = [3, n0, _VEF, 0, [_pa, _m], [0, 0]];
+var VectorBucket = [
+    3,
+    n0,
+    _VB,
+    0,
+    [_vBN, _vBA, _cT, _eC],
+    [0, 0, 4, () => EncryptionConfiguration],
+];
+var VectorBucketSummary = [3, n0, _VBS, 0, [_vBN, _vBA, _cT], [0, 0, 4]];
+var S3VectorsServiceException = [-3, _sm, "S3VectorsServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(S3VectorsServiceException, S3VectorsServiceException$1);
+var GetVectorsOutputList = [1, n0, _GVOL, 0, () => GetOutputVector];
+var ListIndexesOutputList = [1, n0, _LIOL, 0, () => IndexSummary];
+var ListVectorBucketsOutputList = [1, n0, _LVBOL, 0, () => VectorBucketSummary];
+var ListVectorsOutputList = [1, n0, _LVOL, 0, () => ListOutputVector];
+var PutVectorsInputList = [1, n0, _PVIL, 0, () => PutInputVector];
+var QueryVectorsOutputList = [1, n0, _QVOL, 0, () => QueryOutputVector];
+var ValidationExceptionFieldList = [1, n0, _VEFL, 0, () => ValidationExceptionField];
+var VectorData = [3, n0, _VD, 0, [_fl], [64 | 1]];
+var CreateIndex = [
+    9,
+    n0,
+    _CI,
+    {
+        [_h]: ["POST", "/CreateIndex", 200],
+    },
+    () => CreateIndexInput,
+    () => CreateIndexOutput,
+];
+var CreateVectorBucket = [
+    9,
+    n0,
+    _CVB,
+    {
+        [_h]: ["POST", "/CreateVectorBucket", 200],
+    },
+    () => CreateVectorBucketInput,
+    () => CreateVectorBucketOutput,
+];
+var DeleteIndex = [
+    9,
+    n0,
+    _DI,
+    {
+        [_h]: ["POST", "/DeleteIndex", 200],
+    },
+    () => DeleteIndexInput,
+    () => DeleteIndexOutput,
+];
+var DeleteVectorBucket = [
+    9,
+    n0,
+    _DVB,
+    {
+        [_h]: ["POST", "/DeleteVectorBucket", 200],
+    },
+    () => DeleteVectorBucketInput,
+    () => DeleteVectorBucketOutput,
+];
+var DeleteVectorBucketPolicy = [
+    9,
+    n0,
+    _DVBP,
+    {
+        [_h]: ["POST", "/DeleteVectorBucketPolicy", 200],
+    },
+    () => DeleteVectorBucketPolicyInput,
+    () => DeleteVectorBucketPolicyOutput,
+];
+var DeleteVectors = [
+    9,
+    n0,
+    _DV,
+    {
+        [_h]: ["POST", "/DeleteVectors", 200],
+    },
+    () => DeleteVectorsInput,
+    () => DeleteVectorsOutput,
+];
+var GetIndex = [
+    9,
+    n0,
+    _GI,
+    {
+        [_h]: ["POST", "/GetIndex", 200],
+    },
+    () => GetIndexInput,
+    () => GetIndexOutput,
+];
+var GetVectorBucket = [
+    9,
+    n0,
+    _GVB,
+    {
+        [_h]: ["POST", "/GetVectorBucket", 200],
+    },
+    () => GetVectorBucketInput,
+    () => GetVectorBucketOutput,
+];
+var GetVectorBucketPolicy = [
+    9,
+    n0,
+    _GVBP,
+    {
+        [_h]: ["POST", "/GetVectorBucketPolicy", 200],
+    },
+    () => GetVectorBucketPolicyInput,
+    () => GetVectorBucketPolicyOutput,
+];
+var GetVectors = [
+    9,
+    n0,
+    _GV,
+    {
+        [_h]: ["POST", "/GetVectors", 200],
+    },
+    () => GetVectorsInput,
+    () => GetVectorsOutput,
+];
+var ListIndexes = [
+    9,
+    n0,
+    _LI,
+    {
+        [_h]: ["POST", "/ListIndexes", 200],
+    },
+    () => ListIndexesInput,
+    () => ListIndexesOutput,
+];
+var ListVectorBuckets = [
+    9,
+    n0,
+    _LVB,
+    {
+        [_h]: ["POST", "/ListVectorBuckets", 200],
+    },
+    () => ListVectorBucketsInput,
+    () => ListVectorBucketsOutput,
+];
+var ListVectors = [
+    9,
+    n0,
+    _LV,
+    {
+        [_h]: ["POST", "/ListVectors", 200],
+    },
+    () => ListVectorsInput,
+    () => ListVectorsOutput,
+];
+var PutVectorBucketPolicy = [
+    9,
+    n0,
+    _PVBP,
+    {
+        [_h]: ["POST", "/PutVectorBucketPolicy", 200],
+    },
+    () => PutVectorBucketPolicyInput,
+    () => PutVectorBucketPolicyOutput,
+];
+var PutVectors = [
+    9,
+    n0,
+    _PV,
+    {
+        [_h]: ["POST", "/PutVectors", 200],
+    },
+    () => PutVectorsInput,
+    () => PutVectorsOutput,
+];
+var QueryVectors = [
+    9,
+    n0,
+    _QV,
+    {
+        [_h]: ["POST", "/QueryVectors", 200],
+    },
+    () => QueryVectorsInput,
+    () => QueryVectorsOutput,
+];
 
 class CreateIndexCommand 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("S3Vectors", "CreateIndex", {})
     .n("S3VectorsClient", "CreateIndexCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateIndexCommand)
-    .de(de_CreateIndexCommand)
+    .sc(CreateIndex)
     .build() {
 }
 
@@ -1163,16 +872,11 @@ class CreateVectorBucketCommand 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("S3Vectors", "CreateVectorBucket", {})
     .n("S3VectorsClient", "CreateVectorBucketCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateVectorBucketCommand)
-    .de(de_CreateVectorBucketCommand)
+    .sc(CreateVectorBucket)
     .build() {
 }
 
@@ -1180,16 +884,11 @@ class DeleteIndexCommand 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("S3Vectors", "DeleteIndex", {})
     .n("S3VectorsClient", "DeleteIndexCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteIndexCommand)
-    .de(de_DeleteIndexCommand)
+    .sc(DeleteIndex)
     .build() {
 }
 
@@ -1197,16 +896,11 @@ class DeleteVectorBucketCommand 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("S3Vectors", "DeleteVectorBucket", {})
     .n("S3VectorsClient", "DeleteVectorBucketCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteVectorBucketCommand)
-    .de(de_DeleteVectorBucketCommand)
+    .sc(DeleteVectorBucket)
     .build() {
 }
 
@@ -1214,16 +908,11 @@ class DeleteVectorBucketPolicyCommand 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("S3Vectors", "DeleteVectorBucketPolicy", {})
     .n("S3VectorsClient", "DeleteVectorBucketPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteVectorBucketPolicyCommand)
-    .de(de_DeleteVectorBucketPolicyCommand)
+    .sc(DeleteVectorBucketPolicy)
     .build() {
 }
 
@@ -1231,16 +920,11 @@ class DeleteVectorsCommand 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("S3Vectors", "DeleteVectors", {})
     .n("S3VectorsClient", "DeleteVectorsCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteVectorsCommand)
-    .de(de_DeleteVectorsCommand)
+    .sc(DeleteVectors)
     .build() {
 }
 
@@ -1248,16 +932,11 @@ class GetIndexCommand 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("S3Vectors", "GetIndex", {})
     .n("S3VectorsClient", "GetIndexCommand")
-    .f(void 0, void 0)
-    .ser(se_GetIndexCommand)
-    .de(de_GetIndexCommand)
+    .sc(GetIndex)
     .build() {
 }
 
@@ -1265,16 +944,11 @@ class GetVectorBucketCommand 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("S3Vectors", "GetVectorBucket", {})
     .n("S3VectorsClient", "GetVectorBucketCommand")
-    .f(void 0, void 0)
-    .ser(se_GetVectorBucketCommand)
-    .de(de_GetVectorBucketCommand)
+    .sc(GetVectorBucket)
     .build() {
 }
 
@@ -1282,16 +956,11 @@ class GetVectorBucketPolicyCommand 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("S3Vectors", "GetVectorBucketPolicy", {})
     .n("S3VectorsClient", "GetVectorBucketPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_GetVectorBucketPolicyCommand)
-    .de(de_GetVectorBucketPolicyCommand)
+    .sc(GetVectorBucketPolicy)
     .build() {
 }
 
@@ -1299,16 +968,11 @@ class GetVectorsCommand 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("S3Vectors", "GetVectors", {})
     .n("S3VectorsClient", "GetVectorsCommand")
-    .f(void 0, void 0)
-    .ser(se_GetVectorsCommand)
-    .de(de_GetVectorsCommand)
+    .sc(GetVectors)
     .build() {
 }
 
@@ -1316,16 +980,11 @@ class ListIndexesCommand 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("S3Vectors", "ListIndexes", {})
     .n("S3VectorsClient", "ListIndexesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListIndexesCommand)
-    .de(de_ListIndexesCommand)
+    .sc(ListIndexes)
     .build() {
 }
 
@@ -1333,16 +992,11 @@ class ListVectorBucketsCommand 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("S3Vectors", "ListVectorBuckets", {})
     .n("S3VectorsClient", "ListVectorBucketsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListVectorBucketsCommand)
-    .de(de_ListVectorBucketsCommand)
+    .sc(ListVectorBuckets)
     .build() {
 }
 
@@ -1350,16 +1004,11 @@ class ListVectorsCommand 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("S3Vectors", "ListVectors", {})
     .n("S3VectorsClient", "ListVectorsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListVectorsCommand)
-    .de(de_ListVectorsCommand)
+    .sc(ListVectors)
     .build() {
 }
 
@@ -1367,16 +1016,11 @@ class PutVectorBucketPolicyCommand 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("S3Vectors", "PutVectorBucketPolicy", {})
     .n("S3VectorsClient", "PutVectorBucketPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_PutVectorBucketPolicyCommand)
-    .de(de_PutVectorBucketPolicyCommand)
+    .sc(PutVectorBucketPolicy)
     .build() {
 }
 
@@ -1384,16 +1028,11 @@ class PutVectorsCommand 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("S3Vectors", "PutVectors", {})
     .n("S3VectorsClient", "PutVectorsCommand")
-    .f(void 0, void 0)
-    .ser(se_PutVectorsCommand)
-    .de(de_PutVectorsCommand)
+    .sc(PutVectors)
     .build() {
 }
 
@@ -1401,16 +1040,11 @@ class QueryVectorsCommand 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("S3Vectors", "QueryVectors", {})
     .n("S3VectorsClient", "QueryVectorsCommand")
-    .f(void 0, void 0)
-    .ser(se_QueryVectorsCommand)
-    .de(de_QueryVectorsCommand)
+    .sc(QueryVectors)
     .build() {
 }
 
@@ -1450,8 +1084,8 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
-exports.ConflictException = ConflictException;
+exports.AccessDeniedException = AccessDeniedException$1;
+exports.ConflictException = ConflictException$1;
 exports.CreateIndexCommand = CreateIndexCommand;
 exports.CreateVectorBucketCommand = CreateVectorBucketCommand;
 exports.DataType = DataType;
@@ -1464,27 +1098,27 @@ exports.GetIndexCommand = GetIndexCommand;
 exports.GetVectorBucketCommand = GetVectorBucketCommand;
 exports.GetVectorBucketPolicyCommand = GetVectorBucketPolicyCommand;
 exports.GetVectorsCommand = GetVectorsCommand;
-exports.InternalServerException = InternalServerException;
-exports.KmsDisabledException = KmsDisabledException;
-exports.KmsInvalidKeyUsageException = KmsInvalidKeyUsageException;
-exports.KmsInvalidStateException = KmsInvalidStateException;
-exports.KmsNotFoundException = KmsNotFoundException;
+exports.InternalServerException = InternalServerException$1;
+exports.KmsDisabledException = KmsDisabledException$1;
+exports.KmsInvalidKeyUsageException = KmsInvalidKeyUsageException$1;
+exports.KmsInvalidStateException = KmsInvalidStateException$1;
+exports.KmsNotFoundException = KmsNotFoundException$1;
 exports.ListIndexesCommand = ListIndexesCommand;
 exports.ListVectorBucketsCommand = ListVectorBucketsCommand;
 exports.ListVectorsCommand = ListVectorsCommand;
-exports.NotFoundException = NotFoundException;
+exports.NotFoundException = NotFoundException$1;
 exports.PutVectorBucketPolicyCommand = PutVectorBucketPolicyCommand;
 exports.PutVectorsCommand = PutVectorsCommand;
 exports.QueryVectorsCommand = QueryVectorsCommand;
-exports.RequestTimeoutException = RequestTimeoutException;
+exports.RequestTimeoutException = RequestTimeoutException$1;
 exports.S3Vectors = S3Vectors;
 exports.S3VectorsClient = S3VectorsClient;
-exports.S3VectorsServiceException = S3VectorsServiceException;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
-exports.ServiceUnavailableException = ServiceUnavailableException;
+exports.S3VectorsServiceException = S3VectorsServiceException$1;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
+exports.ServiceUnavailableException = ServiceUnavailableException$1;
 exports.SseType = SseType;
-exports.TooManyRequestsException = TooManyRequestsException;
-exports.ValidationException = ValidationException;
+exports.TooManyRequestsException = TooManyRequestsException$1;
+exports.ValidationException = ValidationException$1;
 exports.paginateListIndexes = paginateListIndexes;
 exports.paginateListVectorBuckets = paginateListVectorBuckets;
 exports.paginateListVectors = paginateListVectors;