@aws-sdk/client-s3vectors 3.891.0 → 3.894.0

package/dist-cjs/index.js

@@ -1,11 +1,1633 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3VectorsServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./S3VectorsClient"), exports);
-tslib_1.__exportStar(require("./S3Vectors"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-var S3VectorsServiceException_1 = require("./models/S3VectorsServiceException");
-Object.defineProperty(exports, "S3VectorsServiceException", { enumerable: true, get: function () { return S3VectorsServiceException_1.S3VectorsServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AccessDeniedException: () => AccessDeniedException,
+  ConflictException: () => ConflictException,
+  CreateIndexCommand: () => CreateIndexCommand,
+  CreateVectorBucketCommand: () => CreateVectorBucketCommand,
+  DataType: () => DataType,
+  DeleteIndexCommand: () => DeleteIndexCommand,
+  DeleteVectorBucketCommand: () => DeleteVectorBucketCommand,
+  DeleteVectorBucketPolicyCommand: () => DeleteVectorBucketPolicyCommand,
+  DeleteVectorsCommand: () => DeleteVectorsCommand,
+  DistanceMetric: () => DistanceMetric,
+  GetIndexCommand: () => GetIndexCommand,
+  GetVectorBucketCommand: () => GetVectorBucketCommand,
+  GetVectorBucketPolicyCommand: () => GetVectorBucketPolicyCommand,
+  GetVectorsCommand: () => GetVectorsCommand,
+  InternalServerException: () => InternalServerException,
+  KmsDisabledException: () => KmsDisabledException,
+  KmsInvalidKeyUsageException: () => KmsInvalidKeyUsageException,
+  KmsInvalidStateException: () => KmsInvalidStateException,
+  KmsNotFoundException: () => KmsNotFoundException,
+  ListIndexesCommand: () => ListIndexesCommand,
+  ListVectorBucketsCommand: () => ListVectorBucketsCommand,
+  ListVectorsCommand: () => ListVectorsCommand,
+  NotFoundException: () => NotFoundException,
+  PutVectorBucketPolicyCommand: () => PutVectorBucketPolicyCommand,
+  PutVectorsCommand: () => PutVectorsCommand,
+  QueryVectorsCommand: () => QueryVectorsCommand,
+  S3Vectors: () => S3Vectors,
+  S3VectorsClient: () => S3VectorsClient,
+  S3VectorsServiceException: () => S3VectorsServiceException,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  ServiceUnavailableException: () => ServiceUnavailableException,
+  SseType: () => SseType,
+  TooManyRequestsException: () => TooManyRequestsException,
+  ValidationException: () => ValidationException,
+  VectorData: () => VectorData,
+  __Client: () => import_smithy_client.Client,
+  paginateListIndexes: () => paginateListIndexes,
+  paginateListVectorBuckets: () => paginateListVectorBuckets,
+  paginateListVectors: () => paginateListVectors
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/S3VectorsClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_core = require("@smithy/core");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return Object.assign(options, {
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "s3vectors"
+  });
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" }
+};
+
+// src/S3VectorsClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+
+// src/auth/httpAuthExtensionConfiguration.ts
+var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
+  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+  let _credentials = runtimeConfig.credentials;
+  return {
+    setHttpAuthScheme(httpAuthScheme) {
+      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+      if (index === -1) {
+        _httpAuthSchemes.push(httpAuthScheme);
+      } else {
+        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+      }
+    },
+    httpAuthSchemes() {
+      return _httpAuthSchemes;
+    },
+    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+      _httpAuthSchemeProvider = httpAuthSchemeProvider;
+    },
+    httpAuthSchemeProvider() {
+      return _httpAuthSchemeProvider;
+    },
+    setCredentials(credentials) {
+      _credentials = credentials;
+    },
+    credentials() {
+      return _credentials;
+    }
+  };
+}, "getHttpAuthExtensionConfiguration");
+var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
+  return {
+    httpAuthSchemes: config.httpAuthSchemes(),
+    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+    credentials: config.credentials()
+  };
+}, "resolveHttpAuthRuntimeConfig");
+
+// src/runtimeExtensions.ts
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = Object.assign(
+    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
+    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
+    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
+    getHttpAuthExtensionConfiguration(runtimeConfig)
+  );
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return Object.assign(
+    runtimeConfig,
+    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
+    resolveHttpAuthRuntimeConfig(extensionConfiguration)
+  );
+}, "resolveRuntimeExtensions");
+
+// src/S3VectorsClient.ts
+var S3VectorsClient = class extends import_smithy_client.Client {
+  static {
+    __name(this, "S3VectorsClient");
+  }
+  /**
+   * The resolved configuration of S3VectorsClient class. This is resolved and normalized from the {@link S3VectorsClientConfig | constructor configuration interface}.
+   */
+  config;
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    super(_config_0);
+    this.initConfig = _config_0;
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
+    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
+    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
+    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use(
+      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
+        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultS3VectorsHttpAuthSchemeParametersProvider,
+        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
+          "aws.auth#sigv4": config.credentials
+        }), "identityProviderConfigProvider")
+      })
+    );
+    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+
+// src/S3Vectors.ts
+
+
+// src/commands/CreateIndexCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+
+// src/protocols/Aws_restJson1.ts
+var import_core2 = require("@aws-sdk/core");
+
+
+
+// src/models/S3VectorsServiceException.ts
+
+var S3VectorsServiceException = class _S3VectorsServiceException extends import_smithy_client.ServiceException {
+  static {
+    __name(this, "S3VectorsServiceException");
+  }
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _S3VectorsServiceException.prototype);
+  }
+};
+
+// src/models/models_0.ts
+var AccessDeniedException = class _AccessDeniedException extends S3VectorsServiceException {
+  static {
+    __name(this, "AccessDeniedException");
+  }
+  name = "AccessDeniedException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+  }
+};
+var ConflictException = class _ConflictException extends S3VectorsServiceException {
+  static {
+    __name(this, "ConflictException");
+  }
+  name = "ConflictException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+  }
+};
+var DataType = {
+  FLOAT32: "float32"
+};
+var DistanceMetric = {
+  COSINE: "cosine",
+  EUCLIDEAN: "euclidean"
+};
+var InternalServerException = class _InternalServerException extends S3VectorsServiceException {
+  static {
+    __name(this, "InternalServerException");
+  }
+  name = "InternalServerException";
+  $fault = "server";
+  $retryable = {};
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+  }
+};
+var NotFoundException = class _NotFoundException extends S3VectorsServiceException {
+  static {
+    __name(this, "NotFoundException");
+  }
+  name = "NotFoundException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _NotFoundException.prototype);
+  }
+};
+var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends S3VectorsServiceException {
+  static {
+    __name(this, "ServiceQuotaExceededException");
+  }
+  name = "ServiceQuotaExceededException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+  }
+};
+var ServiceUnavailableException = class _ServiceUnavailableException extends S3VectorsServiceException {
+  static {
+    __name(this, "ServiceUnavailableException");
+  }
+  name = "ServiceUnavailableException";
+  $fault = "server";
+  $retryable = {};
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceUnavailableException",
+      $fault: "server",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ServiceUnavailableException.prototype);
+  }
+};
+var TooManyRequestsException = class _TooManyRequestsException extends S3VectorsServiceException {
+  static {
+    __name(this, "TooManyRequestsException");
+  }
+  name = "TooManyRequestsException";
+  $fault = "client";
+  $retryable = {
+    throttling: true
+  };
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyRequestsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _TooManyRequestsException.prototype);
+  }
+};
+var ValidationException = class _ValidationException extends S3VectorsServiceException {
+  static {
+    __name(this, "ValidationException");
+  }
+  name = "ValidationException";
+  $fault = "client";
+  /**
+   * <p>A list of specific validation failures that are encountered during input processing. Each entry in the list contains a path to the field that failed validation and a detailed message that explains why the validation failed. To satisfy multiple constraints, a field can appear multiple times in this list if it failed. You can use the information to identify and fix the specific validation issues in your request.</p>
+   * @public
+   */
+  fieldList;
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.fieldList = opts.fieldList;
+  }
+};
+var SseType = {
+  AES256: "AES256",
+  AWS_KMS: "aws:kms"
+};
+var KmsDisabledException = class _KmsDisabledException extends S3VectorsServiceException {
+  static {
+    __name(this, "KmsDisabledException");
+  }
+  name = "KmsDisabledException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "KmsDisabledException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _KmsDisabledException.prototype);
+  }
+};
+var KmsInvalidKeyUsageException = class _KmsInvalidKeyUsageException extends S3VectorsServiceException {
+  static {
+    __name(this, "KmsInvalidKeyUsageException");
+  }
+  name = "KmsInvalidKeyUsageException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "KmsInvalidKeyUsageException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _KmsInvalidKeyUsageException.prototype);
+  }
+};
+var KmsInvalidStateException = class _KmsInvalidStateException extends S3VectorsServiceException {
+  static {
+    __name(this, "KmsInvalidStateException");
+  }
+  name = "KmsInvalidStateException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "KmsInvalidStateException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _KmsInvalidStateException.prototype);
+  }
+};
+var KmsNotFoundException = class _KmsNotFoundException extends S3VectorsServiceException {
+  static {
+    __name(this, "KmsNotFoundException");
+  }
+  name = "KmsNotFoundException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "KmsNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _KmsNotFoundException.prototype);
+  }
+};
+var VectorData;
+((VectorData2) => {
+  VectorData2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.float32 !== void 0) return visitor.float32(value.float32);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(VectorData || (VectorData = {}));
+
+// src/protocols/Aws_restJson1.ts
+var se_CreateIndexCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/CreateIndex");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      dataType: [],
+      dimension: [],
+      distanceMetric: [],
+      indexName: [],
+      metadataConfiguration: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "metadataConfiguration"),
+      vectorBucketArn: [],
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateIndexCommand");
+var se_CreateVectorBucketCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/CreateVectorBucket");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      encryptionConfiguration: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "encryptionConfiguration"),
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateVectorBucketCommand");
+var se_DeleteIndexCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteIndex");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      indexArn: [],
+      indexName: [],
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteIndexCommand");
+var se_DeleteVectorBucketCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteVectorBucket");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      vectorBucketArn: [],
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteVectorBucketCommand");
+var se_DeleteVectorBucketPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteVectorBucketPolicy");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      vectorBucketArn: [],
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteVectorBucketPolicyCommand");
+var se_DeleteVectorsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteVectors");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      indexArn: [],
+      indexName: [],
+      keys: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "keys"),
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteVectorsCommand");
+var se_GetIndexCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetIndex");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      indexArn: [],
+      indexName: [],
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetIndexCommand");
+var se_GetVectorBucketCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetVectorBucket");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      vectorBucketArn: [],
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetVectorBucketCommand");
+var se_GetVectorBucketPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetVectorBucketPolicy");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      vectorBucketArn: [],
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetVectorBucketPolicyCommand");
+var se_GetVectorsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetVectors");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      indexArn: [],
+      indexName: [],
+      keys: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "keys"),
+      returnData: [],
+      returnMetadata: [],
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetVectorsCommand");
+var se_ListIndexesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListIndexes");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: [],
+      prefix: [],
+      vectorBucketArn: [],
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListIndexesCommand");
+var se_ListVectorBucketsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListVectorBuckets");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: [],
+      prefix: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListVectorBucketsCommand");
+var se_ListVectorsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListVectors");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      indexArn: [],
+      indexName: [],
+      maxResults: [],
+      nextToken: [],
+      returnData: [],
+      returnMetadata: [],
+      segmentCount: [],
+      segmentIndex: [],
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListVectorsCommand");
+var se_PutVectorBucketPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/PutVectorBucketPolicy");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      policy: [],
+      vectorBucketArn: [],
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_PutVectorBucketPolicyCommand");
+var se_PutVectorsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/PutVectors");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      indexArn: [],
+      indexName: [],
+      vectorBucketName: [],
+      vectors: /* @__PURE__ */ __name((_) => se_PutVectorsInputList(_, context), "vectors")
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_PutVectorsCommand");
+var se_QueryVectorsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/QueryVectors");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      filter: /* @__PURE__ */ __name((_) => se_Document(_, context), "filter"),
+      indexArn: [],
+      indexName: [],
+      queryVector: /* @__PURE__ */ __name((_) => se_VectorData(_, context), "queryVector"),
+      returnDistance: [],
+      returnMetadata: [],
+      topK: [],
+      vectorBucketName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_QueryVectorsCommand");
+var de_CreateIndexCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_CreateIndexCommand");
+var de_CreateVectorBucketCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_CreateVectorBucketCommand");
+var de_DeleteIndexCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteIndexCommand");
+var de_DeleteVectorBucketCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteVectorBucketCommand");
+var de_DeleteVectorBucketPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteVectorBucketPolicyCommand");
+var de_DeleteVectorsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteVectorsCommand");
+var de_GetIndexCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    index: /* @__PURE__ */ __name((_) => de_Index(_, context), "index")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetIndexCommand");
+var de_GetVectorBucketCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    vectorBucket: /* @__PURE__ */ __name((_) => de_VectorBucket(_, context), "vectorBucket")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetVectorBucketCommand");
+var de_GetVectorBucketPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    policy: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetVectorBucketPolicyCommand");
+var de_GetVectorsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    vectors: /* @__PURE__ */ __name((_) => de_GetVectorsOutputList(_, context), "vectors")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetVectorsCommand");
+var de_ListIndexesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    indexes: /* @__PURE__ */ __name((_) => de_ListIndexesOutputList(_, context), "indexes"),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListIndexesCommand");
+var de_ListVectorBucketsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    vectorBuckets: /* @__PURE__ */ __name((_) => de_ListVectorBucketsOutputList(_, context), "vectorBuckets")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListVectorBucketsCommand");
+var de_ListVectorsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    vectors: /* @__PURE__ */ __name((_) => de_ListVectorsOutputList(_, context), "vectors")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListVectorsCommand");
+var de_PutVectorBucketPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PutVectorBucketPolicyCommand");
+var de_PutVectorsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PutVectorsCommand");
+var de_QueryVectorsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    vectors: /* @__PURE__ */ __name((_) => de_QueryVectorsOutputList(_, context), "vectors")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_QueryVectorsCommand");
+var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
+  };
+  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.s3vectors#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.s3vectors#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.s3vectors#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.s3vectors#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.s3vectors#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.s3vectors#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.s3vectors#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.s3vectors#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    case "KmsDisabledException":
+    case "com.amazonaws.s3vectors#KmsDisabledException":
+      throw await de_KmsDisabledExceptionRes(parsedOutput, context);
+    case "KmsInvalidKeyUsageException":
+    case "com.amazonaws.s3vectors#KmsInvalidKeyUsageException":
+      throw await de_KmsInvalidKeyUsageExceptionRes(parsedOutput, context);
+    case "KmsInvalidStateException":
+    case "com.amazonaws.s3vectors#KmsInvalidStateException":
+      throw await de_KmsInvalidStateExceptionRes(parsedOutput, context);
+    case "KmsNotFoundException":
+    case "com.amazonaws.s3vectors#KmsNotFoundException":
+      throw await de_KmsNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(S3VectorsServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_KmsDisabledExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new KmsDisabledException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_KmsDisabledExceptionRes");
+var de_KmsInvalidKeyUsageExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new KmsInvalidKeyUsageException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_KmsInvalidKeyUsageExceptionRes");
+var de_KmsInvalidStateExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new KmsInvalidStateException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_KmsInvalidStateExceptionRes");
+var de_KmsNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new KmsNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_KmsNotFoundExceptionRes");
+var de_NotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new NotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_NotFoundExceptionRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_ServiceUnavailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceUnavailableException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceUnavailableExceptionRes");
+var de_TooManyRequestsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new TooManyRequestsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TooManyRequestsExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    fieldList: import_smithy_client._json,
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var se_Float32VectorData = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.serializeFloat)(entry);
+  });
+}, "se_Float32VectorData");
+var se_PutInputVector = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    data: /* @__PURE__ */ __name((_) => se_VectorData(_, context), "data"),
+    key: [],
+    metadata: /* @__PURE__ */ __name((_) => se_VectorMetadata(_, context), "metadata")
+  });
+}, "se_PutInputVector");
+var se_PutVectorsInputList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_PutInputVector(entry, context);
+  });
+}, "se_PutVectorsInputList");
+var se_VectorData = /* @__PURE__ */ __name((input, context) => {
+  return VectorData.visit(input, {
+    float32: /* @__PURE__ */ __name((value) => ({ float32: se_Float32VectorData(value, context) }), "float32"),
+    _: /* @__PURE__ */ __name((name, value) => ({ [name]: value }), "_")
+  });
+}, "se_VectorData");
+var se_VectorMetadata = /* @__PURE__ */ __name((input, context) => {
+  return input;
+}, "se_VectorMetadata");
+var se_Document = /* @__PURE__ */ __name((input, context) => {
+  return input;
+}, "se_Document");
+var de_Float32VectorData = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.limitedParseFloat32)(entry);
+  });
+  return retVal;
+}, "de_Float32VectorData");
+var de_GetOutputVector = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    data: /* @__PURE__ */ __name((_) => de_VectorData((0, import_core2.awsExpectUnion)(_), context), "data"),
+    key: import_smithy_client.expectString,
+    metadata: /* @__PURE__ */ __name((_) => de_VectorMetadata(_, context), "metadata")
+  });
+}, "de_GetOutputVector");
+var de_GetVectorsOutputList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_GetOutputVector(entry, context);
+  });
+  return retVal;
+}, "de_GetVectorsOutputList");
+var de_Index = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    creationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "creationTime"),
+    dataType: import_smithy_client.expectString,
+    dimension: import_smithy_client.expectInt32,
+    distanceMetric: import_smithy_client.expectString,
+    indexArn: import_smithy_client.expectString,
+    indexName: import_smithy_client.expectString,
+    metadataConfiguration: import_smithy_client._json,
+    vectorBucketName: import_smithy_client.expectString
+  });
+}, "de_Index");
+var de_IndexSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    creationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "creationTime"),
+    indexArn: import_smithy_client.expectString,
+    indexName: import_smithy_client.expectString,
+    vectorBucketName: import_smithy_client.expectString
+  });
+}, "de_IndexSummary");
+var de_ListIndexesOutputList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_IndexSummary(entry, context);
+  });
+  return retVal;
+}, "de_ListIndexesOutputList");
+var de_ListOutputVector = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    data: /* @__PURE__ */ __name((_) => de_VectorData((0, import_core2.awsExpectUnion)(_), context), "data"),
+    key: import_smithy_client.expectString,
+    metadata: /* @__PURE__ */ __name((_) => de_VectorMetadata(_, context), "metadata")
+  });
+}, "de_ListOutputVector");
+var de_ListVectorBucketsOutputList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_VectorBucketSummary(entry, context);
+  });
+  return retVal;
+}, "de_ListVectorBucketsOutputList");
+var de_ListVectorsOutputList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ListOutputVector(entry, context);
+  });
+  return retVal;
+}, "de_ListVectorsOutputList");
+var de_QueryOutputVector = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    data: /* @__PURE__ */ __name((_) => de_VectorData((0, import_core2.awsExpectUnion)(_), context), "data"),
+    distance: import_smithy_client.limitedParseFloat32,
+    key: import_smithy_client.expectString,
+    metadata: /* @__PURE__ */ __name((_) => de_VectorMetadata(_, context), "metadata")
+  });
+}, "de_QueryOutputVector");
+var de_QueryVectorsOutputList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_QueryOutputVector(entry, context);
+  });
+  return retVal;
+}, "de_QueryVectorsOutputList");
+var de_VectorBucket = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    creationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "creationTime"),
+    encryptionConfiguration: import_smithy_client._json,
+    vectorBucketArn: import_smithy_client.expectString,
+    vectorBucketName: import_smithy_client.expectString
+  });
+}, "de_VectorBucket");
+var de_VectorBucketSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    creationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "creationTime"),
+    vectorBucketArn: import_smithy_client.expectString,
+    vectorBucketName: import_smithy_client.expectString
+  });
+}, "de_VectorBucketSummary");
+var de_VectorData = /* @__PURE__ */ __name((output, context) => {
+  if (output.float32 != null) {
+    return {
+      float32: de_Float32VectorData(output.float32, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_VectorData");
+var de_VectorMetadata = /* @__PURE__ */ __name((output, context) => {
+  return output;
+}, "de_VectorMetadata");
+var deserializeMetadata = /* @__PURE__ */ __name((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"]
+}), "deserializeMetadata");
+
+// src/commands/CreateIndexCommand.ts
+var CreateIndexCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "CreateIndex", {}).n("S3VectorsClient", "CreateIndexCommand").f(void 0, void 0).ser(se_CreateIndexCommand).de(de_CreateIndexCommand).build() {
+  static {
+    __name(this, "CreateIndexCommand");
+  }
+};
+
+// src/commands/CreateVectorBucketCommand.ts
+
+
+
+var CreateVectorBucketCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "CreateVectorBucket", {}).n("S3VectorsClient", "CreateVectorBucketCommand").f(void 0, void 0).ser(se_CreateVectorBucketCommand).de(de_CreateVectorBucketCommand).build() {
+  static {
+    __name(this, "CreateVectorBucketCommand");
+  }
+};
+
+// src/commands/DeleteIndexCommand.ts
+
+
+
+var DeleteIndexCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "DeleteIndex", {}).n("S3VectorsClient", "DeleteIndexCommand").f(void 0, void 0).ser(se_DeleteIndexCommand).de(de_DeleteIndexCommand).build() {
+  static {
+    __name(this, "DeleteIndexCommand");
+  }
+};
+
+// src/commands/DeleteVectorBucketCommand.ts
+
+
+
+var DeleteVectorBucketCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "DeleteVectorBucket", {}).n("S3VectorsClient", "DeleteVectorBucketCommand").f(void 0, void 0).ser(se_DeleteVectorBucketCommand).de(de_DeleteVectorBucketCommand).build() {
+  static {
+    __name(this, "DeleteVectorBucketCommand");
+  }
+};
+
+// src/commands/DeleteVectorBucketPolicyCommand.ts
+
+
+
+var DeleteVectorBucketPolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "DeleteVectorBucketPolicy", {}).n("S3VectorsClient", "DeleteVectorBucketPolicyCommand").f(void 0, void 0).ser(se_DeleteVectorBucketPolicyCommand).de(de_DeleteVectorBucketPolicyCommand).build() {
+  static {
+    __name(this, "DeleteVectorBucketPolicyCommand");
+  }
+};
+
+// src/commands/DeleteVectorsCommand.ts
+
+
+
+var DeleteVectorsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "DeleteVectors", {}).n("S3VectorsClient", "DeleteVectorsCommand").f(void 0, void 0).ser(se_DeleteVectorsCommand).de(de_DeleteVectorsCommand).build() {
+  static {
+    __name(this, "DeleteVectorsCommand");
+  }
+};
+
+// src/commands/GetIndexCommand.ts
+
+
+
+var GetIndexCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "GetIndex", {}).n("S3VectorsClient", "GetIndexCommand").f(void 0, void 0).ser(se_GetIndexCommand).de(de_GetIndexCommand).build() {
+  static {
+    __name(this, "GetIndexCommand");
+  }
+};
+
+// src/commands/GetVectorBucketCommand.ts
+
+
+
+var GetVectorBucketCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "GetVectorBucket", {}).n("S3VectorsClient", "GetVectorBucketCommand").f(void 0, void 0).ser(se_GetVectorBucketCommand).de(de_GetVectorBucketCommand).build() {
+  static {
+    __name(this, "GetVectorBucketCommand");
+  }
+};
+
+// src/commands/GetVectorBucketPolicyCommand.ts
+
+
+
+var GetVectorBucketPolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "GetVectorBucketPolicy", {}).n("S3VectorsClient", "GetVectorBucketPolicyCommand").f(void 0, void 0).ser(se_GetVectorBucketPolicyCommand).de(de_GetVectorBucketPolicyCommand).build() {
+  static {
+    __name(this, "GetVectorBucketPolicyCommand");
+  }
+};
+
+// src/commands/GetVectorsCommand.ts
+
+
+
+var GetVectorsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "GetVectors", {}).n("S3VectorsClient", "GetVectorsCommand").f(void 0, void 0).ser(se_GetVectorsCommand).de(de_GetVectorsCommand).build() {
+  static {
+    __name(this, "GetVectorsCommand");
+  }
+};
+
+// src/commands/ListIndexesCommand.ts
+
+
+
+var ListIndexesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "ListIndexes", {}).n("S3VectorsClient", "ListIndexesCommand").f(void 0, void 0).ser(se_ListIndexesCommand).de(de_ListIndexesCommand).build() {
+  static {
+    __name(this, "ListIndexesCommand");
+  }
+};
+
+// src/commands/ListVectorBucketsCommand.ts
+
+
+
+var ListVectorBucketsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "ListVectorBuckets", {}).n("S3VectorsClient", "ListVectorBucketsCommand").f(void 0, void 0).ser(se_ListVectorBucketsCommand).de(de_ListVectorBucketsCommand).build() {
+  static {
+    __name(this, "ListVectorBucketsCommand");
+  }
+};
+
+// src/commands/ListVectorsCommand.ts
+
+
+
+var ListVectorsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "ListVectors", {}).n("S3VectorsClient", "ListVectorsCommand").f(void 0, void 0).ser(se_ListVectorsCommand).de(de_ListVectorsCommand).build() {
+  static {
+    __name(this, "ListVectorsCommand");
+  }
+};
+
+// src/commands/PutVectorBucketPolicyCommand.ts
+
+
+
+var PutVectorBucketPolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "PutVectorBucketPolicy", {}).n("S3VectorsClient", "PutVectorBucketPolicyCommand").f(void 0, void 0).ser(se_PutVectorBucketPolicyCommand).de(de_PutVectorBucketPolicyCommand).build() {
+  static {
+    __name(this, "PutVectorBucketPolicyCommand");
+  }
+};
+
+// src/commands/PutVectorsCommand.ts
+
+
+
+var PutVectorsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "PutVectors", {}).n("S3VectorsClient", "PutVectorsCommand").f(void 0, void 0).ser(se_PutVectorsCommand).de(de_PutVectorsCommand).build() {
+  static {
+    __name(this, "PutVectorsCommand");
+  }
+};
+
+// src/commands/QueryVectorsCommand.ts
+
+
+
+var QueryVectorsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("S3Vectors", "QueryVectors", {}).n("S3VectorsClient", "QueryVectorsCommand").f(void 0, void 0).ser(se_QueryVectorsCommand).de(de_QueryVectorsCommand).build() {
+  static {
+    __name(this, "QueryVectorsCommand");
+  }
+};
+
+// src/S3Vectors.ts
+var commands = {
+  CreateIndexCommand,
+  CreateVectorBucketCommand,
+  DeleteIndexCommand,
+  DeleteVectorBucketCommand,
+  DeleteVectorBucketPolicyCommand,
+  DeleteVectorsCommand,
+  GetIndexCommand,
+  GetVectorBucketCommand,
+  GetVectorBucketPolicyCommand,
+  GetVectorsCommand,
+  ListIndexesCommand,
+  ListVectorBucketsCommand,
+  ListVectorsCommand,
+  PutVectorBucketPolicyCommand,
+  PutVectorsCommand,
+  QueryVectorsCommand
+};
+var S3Vectors = class extends S3VectorsClient {
+  static {
+    __name(this, "S3Vectors");
+  }
+};
+(0, import_smithy_client.createAggregatedClient)(commands, S3Vectors);
+
+// src/pagination/ListIndexesPaginator.ts
+
+var paginateListIndexes = (0, import_core.createPaginator)(S3VectorsClient, ListIndexesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListVectorBucketsPaginator.ts
+
+var paginateListVectorBuckets = (0, import_core.createPaginator)(S3VectorsClient, ListVectorBucketsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListVectorsPaginator.ts
+
+var paginateListVectors = (0, import_core.createPaginator)(S3VectorsClient, ListVectorsCommand, "nextToken", "nextToken", "maxResults");
+// Annotate the CommonJS export names for ESM import in node:
+
+0 && (module.exports = {
+  S3VectorsServiceException,
+  __Client,
+  S3VectorsClient,
+  S3Vectors,
+  $Command,
+  CreateIndexCommand,
+  CreateVectorBucketCommand,
+  DeleteIndexCommand,
+  DeleteVectorBucketCommand,
+  DeleteVectorBucketPolicyCommand,
+  DeleteVectorsCommand,
+  GetIndexCommand,
+  GetVectorBucketCommand,
+  GetVectorBucketPolicyCommand,
+  GetVectorsCommand,
+  ListIndexesCommand,
+  ListVectorBucketsCommand,
+  ListVectorsCommand,
+  PutVectorBucketPolicyCommand,
+  PutVectorsCommand,
+  QueryVectorsCommand,
+  paginateListIndexes,
+  paginateListVectorBuckets,
+  paginateListVectors,
+  AccessDeniedException,
+  ConflictException,
+  DataType,
+  DistanceMetric,
+  InternalServerException,
+  NotFoundException,
+  ServiceQuotaExceededException,
+  ServiceUnavailableException,
+  TooManyRequestsException,
+  ValidationException,
+  SseType,
+  KmsDisabledException,
+  KmsInvalidKeyUsageException,
+  KmsInvalidStateException,
+  KmsNotFoundException,
+  VectorData
+});
+