@supabase/storage-js 2.79.1-canary.1 → 2.80.0

package/dist/main/lib/vectors/StorageVectorsClient.d.ts

@@ -0,0 +1,310 @@
+import VectorIndexApi, { CreateIndexOptions } from './VectorIndexApi';
+import VectorDataApi from './VectorDataApi';
+import { Fetch } from './fetch';
+import VectorBucketApi from './VectorBucketApi';
+import { DeleteVectorsOptions, GetVectorsOptions, ListIndexesOptions, ListVectorsOptions, PutVectorsOptions, QueryVectorsOptions } from './types';
+/**
+ * Configuration options for the Storage Vectors client
+ */
+export interface StorageVectorsClientOptions {
+    /**
+     * Custom headers to include in all requests
+     */
+    headers?: {
+        [key: string]: string;
+    };
+    /**
+     * Custom fetch implementation (optional)
+     * Useful for testing or custom request handling
+     */
+    fetch?: Fetch;
+}
+/**
+ * Main client for interacting with S3 Vectors API
+ * Provides access to bucket, index, and vector data operations
+ *
+ * **Usage Patterns:**
+ *
+ * 1. **Via StorageClient (recommended for most use cases):**
+ * ```typescript
+ * import { StorageClient } from '@supabase/storage-js'
+ *
+ * const storageClient = new StorageClient(url, headers)
+ * const vectors = storageClient.vectors
+ *
+ * // Use vector operations
+ * await vectors.createBucket('embeddings-prod')
+ * const bucket = vectors.from('embeddings-prod')
+ * await bucket.createIndex({ ... })
+ * ```
+ *
+ * 2. **Standalone (for vector-only applications):**
+ * ```typescript
+ * import { StorageVectorsClient } from '@supabase/storage-js'
+ *
+ * const vectorsClient = new StorageVectorsClient('https://api.example.com', {
+ *   headers: { 'Authorization': 'Bearer token' }
+ * })
+ *
+ * // Access bucket operations
+ * await vectorsClient.createBucket('embeddings-prod')
+ *
+ * // Access index operations via buckets
+ * const bucket = vectorsClient.from('embeddings-prod')
+ * await bucket.createIndex({
+ *   indexName: 'documents',
+ *   dataType: 'float32',
+ *   dimension: 1536,
+ *   distanceMetric: 'cosine'
+ * })
+ *
+ * // Access vector operations via index
+ * const index = bucket.index('documents')
+ * await index.putVectors({
+ *   vectors: [
+ *     { key: 'doc-1', data: { float32: [...] }, metadata: { title: 'Intro' } }
+ *   ]
+ * })
+ *
+ * // Query similar vectors
+ * const { data } = await index.queryVectors({
+ *   queryVector: { float32: [...] },
+ *   topK: 5,
+ *   returnDistance: true
+ * })
+ * ```
+ */
+export declare class StorageVectorsClient extends VectorBucketApi {
+    constructor(url: string, options?: StorageVectorsClientOptions);
+    /**
+     * Access operations for a specific vector bucket
+     * Returns a scoped client for index and vector operations within the bucket
+     *
+     * @param vectorBucketName - Name of the vector bucket
+     * @returns Bucket-scoped client with index and vector operations
+     *
+     * @example
+     * ```typescript
+     * const bucket = client.bucket('embeddings-prod')
+     *
+     * // Create an index in this bucket
+     * await bucket.createIndex({
+     *   indexName: 'documents-openai',
+     *   dataType: 'float32',
+     *   dimension: 1536,
+     *   distanceMetric: 'cosine'
+     * })
+     *
+     * // List indexes in this bucket
+     * const { data } = await bucket.listIndexes()
+     * ```
+     */
+    from(vectorBucketName: string): VectorBucketScope;
+}
+/**
+ * Scoped client for operations within a specific vector bucket
+ * Provides index management and access to vector operations
+ */
+export declare class VectorBucketScope extends VectorIndexApi {
+    private vectorBucketName;
+    constructor(url: string, headers: {
+        [key: string]: string;
+    }, vectorBucketName: string, fetch?: Fetch);
+    /**
+     * Creates a new vector index in this bucket
+     * Convenience method that automatically includes the bucket name
+     *
+     * @param options - Index configuration (vectorBucketName is automatically set)
+     * @returns Promise with empty response on success or error
+     *
+     * @example
+     * ```typescript
+     * const bucket = client.bucket('embeddings-prod')
+     * await bucket.createIndex({
+     *   indexName: 'documents-openai',
+     *   dataType: 'float32',
+     *   dimension: 1536,
+     *   distanceMetric: 'cosine',
+     *   metadataConfiguration: {
+     *     nonFilterableMetadataKeys: ['raw_text']
+     *   }
+     * })
+     * ```
+     */
+    createIndex(options: Omit<CreateIndexOptions, 'vectorBucketName'>): Promise<import("./types").ApiResponse<undefined>>;
+    /**
+     * Lists indexes in this bucket
+     * Convenience method that automatically includes the bucket name
+     *
+     * @param options - Listing options (vectorBucketName is automatically set)
+     * @returns Promise with list of indexes or error
+     *
+     * @example
+     * ```typescript
+     * const bucket = client.bucket('embeddings-prod')
+     * const { data } = await bucket.listIndexes({ prefix: 'documents-' })
+     * ```
+     */
+    listIndexes(options?: Omit<ListIndexesOptions, 'vectorBucketName'>): Promise<import("./types").ApiResponse<import("./types").ListIndexesResponse>>;
+    /**
+     * Retrieves metadata for a specific index in this bucket
+     * Convenience method that automatically includes the bucket name
+     *
+     * @param indexName - Name of the index to retrieve
+     * @returns Promise with index metadata or error
+     *
+     * @example
+     * ```typescript
+     * const bucket = client.bucket('embeddings-prod')
+     * const { data } = await bucket.getIndex('documents-openai')
+     * console.log('Dimension:', data?.index.dimension)
+     * ```
+     */
+    getIndex(indexName: string): Promise<import("./types").ApiResponse<{
+        index: import("./types").VectorIndex;
+    }>>;
+    /**
+     * Deletes an index from this bucket
+     * Convenience method that automatically includes the bucket name
+     *
+     * @param indexName - Name of the index to delete
+     * @returns Promise with empty response on success or error
+     *
+     * @example
+     * ```typescript
+     * const bucket = client.bucket('embeddings-prod')
+     * await bucket.deleteIndex('old-index')
+     * ```
+     */
+    deleteIndex(indexName: string): Promise<import("./types").ApiResponse<undefined>>;
+    /**
+     * Access operations for a specific index within this bucket
+     * Returns a scoped client for vector data operations
+     *
+     * @param indexName - Name of the index
+     * @returns Index-scoped client with vector data operations
+     *
+     * @example
+     * ```typescript
+     * const index = client.bucket('embeddings-prod').index('documents-openai')
+     *
+     * // Insert vectors
+     * await index.putVectors({
+     *   vectors: [
+     *     { key: 'doc-1', data: { float32: [...] }, metadata: { title: 'Intro' } }
+     *   ]
+     * })
+     *
+     * // Query similar vectors
+     * const { data } = await index.queryVectors({
+     *   queryVector: { float32: [...] },
+     *   topK: 5
+     * })
+     * ```
+     */
+    index(indexName: string): VectorIndexScope;
+}
+/**
+ * Scoped client for operations within a specific vector index
+ * Provides vector data operations (put, get, list, query, delete)
+ */
+export declare class VectorIndexScope extends VectorDataApi {
+    private vectorBucketName;
+    private indexName;
+    constructor(url: string, headers: {
+        [key: string]: string;
+    }, vectorBucketName: string, indexName: string, fetch?: Fetch);
+    /**
+     * Inserts or updates vectors in this index
+     * Convenience method that automatically includes bucket and index names
+     *
+     * @param options - Vector insertion options (bucket and index names automatically set)
+     * @returns Promise with empty response on success or error
+     *
+     * @example
+     * ```typescript
+     * const index = client.bucket('embeddings-prod').index('documents-openai')
+     * await index.putVectors({
+     *   vectors: [
+     *     {
+     *       key: 'doc-1',
+     *       data: { float32: [0.1, 0.2, ...] },
+     *       metadata: { title: 'Introduction', page: 1 }
+     *     }
+     *   ]
+     * })
+     * ```
+     */
+    putVectors(options: Omit<PutVectorsOptions, 'vectorBucketName' | 'indexName'>): Promise<import("./types").ApiResponse<undefined>>;
+    /**
+     * Retrieves vectors by keys from this index
+     * Convenience method that automatically includes bucket and index names
+     *
+     * @param options - Vector retrieval options (bucket and index names automatically set)
+     * @returns Promise with array of vectors or error
+     *
+     * @example
+     * ```typescript
+     * const index = client.bucket('embeddings-prod').index('documents-openai')
+     * const { data } = await index.getVectors({
+     *   keys: ['doc-1', 'doc-2'],
+     *   returnMetadata: true
+     * })
+     * ```
+     */
+    getVectors(options: Omit<GetVectorsOptions, 'vectorBucketName' | 'indexName'>): Promise<import("./types").ApiResponse<import("./types").GetVectorsResponse>>;
+    /**
+     * Lists vectors in this index with pagination
+     * Convenience method that automatically includes bucket and index names
+     *
+     * @param options - Listing options (bucket and index names automatically set)
+     * @returns Promise with array of vectors and pagination token
+     *
+     * @example
+     * ```typescript
+     * const index = client.bucket('embeddings-prod').index('documents-openai')
+     * const { data } = await index.listVectors({
+     *   maxResults: 500,
+     *   returnMetadata: true
+     * })
+     * ```
+     */
+    listVectors(options?: Omit<ListVectorsOptions, 'vectorBucketName' | 'indexName'>): Promise<import("./types").ApiResponse<import("./types").ListVectorsResponse>>;
+    /**
+     * Queries for similar vectors in this index
+     * Convenience method that automatically includes bucket and index names
+     *
+     * @param options - Query options (bucket and index names automatically set)
+     * @returns Promise with array of similar vectors ordered by distance
+     *
+     * @example
+     * ```typescript
+     * const index = client.bucket('embeddings-prod').index('documents-openai')
+     * const { data } = await index.queryVectors({
+     *   queryVector: { float32: [0.1, 0.2, ...] },
+     *   topK: 5,
+     *   filter: { category: 'technical' },
+     *   returnDistance: true,
+     *   returnMetadata: true
+     * })
+     * ```
+     */
+    queryVectors(options: Omit<QueryVectorsOptions, 'vectorBucketName' | 'indexName'>): Promise<import("./types").ApiResponse<import("./types").QueryVectorsResponse>>;
+    /**
+     * Deletes vectors by keys from this index
+     * Convenience method that automatically includes bucket and index names
+     *
+     * @param options - Deletion options (bucket and index names automatically set)
+     * @returns Promise with empty response on success or error
+     *
+     * @example
+     * ```typescript
+     * const index = client.bucket('embeddings-prod').index('documents-openai')
+     * await index.deleteVectors({
+     *   keys: ['doc-1', 'doc-2', 'doc-3']
+     * })
+     * ```
+     */
+    deleteVectors(options: Omit<DeleteVectorsOptions, 'vectorBucketName' | 'indexName'>): Promise<import("./types").ApiResponse<undefined>>;
+}
+//# sourceMappingURL=StorageVectorsClient.d.ts.map

package/dist/main/lib/vectors/StorageVectorsClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageVectorsClient.d.ts","sourceRoot":"","sources":["../../../../src/lib/vectors/StorageVectorsClient.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,EAAE,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,aAAa,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,eAAe,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,SAAS,CAAA;AAEhB;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;OAEG;IACH,OAAO,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;IACnC;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAA;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,qBAAa,oBAAqB,SAAQ,eAAe;gBAC3C,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,2BAAgC;IAIlE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,IAAI,CAAC,gBAAgB,EAAE,MAAM,GAAG,iBAAiB;CAGlD;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,cAAc;IACnD,OAAO,CAAC,gBAAgB,CAAQ;gBAG9B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,EAClC,gBAAgB,EAAE,MAAM,EACxB,KAAK,CAAC,EAAE,KAAK;IAMf;;;;;;;;;;;;;;;;;;;;OAoBG;IACY,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;IAOhF;;;;;;;;;;;;OAYG;IACY,WAAW,CAAC,OAAO,GAAE,IAAI,CAAC,kBAAkB,EAAE,kBAAkB,CAAM;IAOrF;;;;;;;;;;;;;OAaG;IACY,QAAQ,CAAC,SAAS,EAAE,MAAM;;;IAIzC;;;;;;;;;;;;OAYG;IACY,WAAW,CAAC,SAAS,EAAE,MAAM;IAI5C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB;CAS3C;AAED;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,aAAa;IACjD,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,SAAS,CAAQ;gBAGvB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,EAClC,gBAAgB,EAAE,MAAM,EACxB,SAAS,EAAE,MAAM,EACjB,KAAK,CAAC,EAAE,KAAK;IAOf;;;;;;;;;;;;;;;;;;;;OAoBG;IACY,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,iBAAiB,EAAE,kBAAkB,GAAG,WAAW,CAAC;IAQ5F;;;;;;;;;;;;;;;OAeG;IACY,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,iBAAiB,EAAE,kBAAkB,GAAG,WAAW,CAAC;IAQ5F;;;;;;;;;;;;;;;OAeG;IACY,WAAW,CACxB,OAAO,GAAE,IAAI,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,WAAW,CAAM;IAS1E;;;;;;;;;;;;;;;;;;OAkBG;IACY,YAAY,CACzB,OAAO,EAAE,IAAI,CAAC,mBAAmB,EAAE,kBAAkB,GAAG,WAAW,CAAC;IAStE;;;;;;;;;;;;;;OAcG;IACY,aAAa,CAC1B,OAAO,EAAE,IAAI,CAAC,oBAAoB,EAAE,kBAAkB,GAAG,WAAW,CAAC;CAQxE"}

package/dist/main/lib/vectors/StorageVectorsClient.js

@@ -0,0 +1,366 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorIndexScope = exports.VectorBucketScope = exports.StorageVectorsClient = void 0;
+const tslib_1 = require("tslib");
+const VectorIndexApi_1 = tslib_1.__importDefault(require("./VectorIndexApi"));
+const VectorDataApi_1 = tslib_1.__importDefault(require("./VectorDataApi"));
+const VectorBucketApi_1 = tslib_1.__importDefault(require("./VectorBucketApi"));
+/**
+ * Main client for interacting with S3 Vectors API
+ * Provides access to bucket, index, and vector data operations
+ *
+ * **Usage Patterns:**
+ *
+ * 1. **Via StorageClient (recommended for most use cases):**
+ * ```typescript
+ * import { StorageClient } from '@supabase/storage-js'
+ *
+ * const storageClient = new StorageClient(url, headers)
+ * const vectors = storageClient.vectors
+ *
+ * // Use vector operations
+ * await vectors.createBucket('embeddings-prod')
+ * const bucket = vectors.from('embeddings-prod')
+ * await bucket.createIndex({ ... })
+ * ```
+ *
+ * 2. **Standalone (for vector-only applications):**
+ * ```typescript
+ * import { StorageVectorsClient } from '@supabase/storage-js'
+ *
+ * const vectorsClient = new StorageVectorsClient('https://api.example.com', {
+ *   headers: { 'Authorization': 'Bearer token' }
+ * })
+ *
+ * // Access bucket operations
+ * await vectorsClient.createBucket('embeddings-prod')
+ *
+ * // Access index operations via buckets
+ * const bucket = vectorsClient.from('embeddings-prod')
+ * await bucket.createIndex({
+ *   indexName: 'documents',
+ *   dataType: 'float32',
+ *   dimension: 1536,
+ *   distanceMetric: 'cosine'
+ * })
+ *
+ * // Access vector operations via index
+ * const index = bucket.index('documents')
+ * await index.putVectors({
+ *   vectors: [
+ *     { key: 'doc-1', data: { float32: [...] }, metadata: { title: 'Intro' } }
+ *   ]
+ * })
+ *
+ * // Query similar vectors
+ * const { data } = await index.queryVectors({
+ *   queryVector: { float32: [...] },
+ *   topK: 5,
+ *   returnDistance: true
+ * })
+ * ```
+ */
+class StorageVectorsClient extends VectorBucketApi_1.default {
+    constructor(url, options = {}) {
+        super(url, options.headers || {}, options.fetch);
+    }
+    /**
+     * Access operations for a specific vector bucket
+     * Returns a scoped client for index and vector operations within the bucket
+     *
+     * @param vectorBucketName - Name of the vector bucket
+     * @returns Bucket-scoped client with index and vector operations
+     *
+     * @example
+     * ```typescript
+     * const bucket = client.bucket('embeddings-prod')
+     *
+     * // Create an index in this bucket
+     * await bucket.createIndex({
+     *   indexName: 'documents-openai',
+     *   dataType: 'float32',
+     *   dimension: 1536,
+     *   distanceMetric: 'cosine'
+     * })
+     *
+     * // List indexes in this bucket
+     * const { data } = await bucket.listIndexes()
+     * ```
+     */
+    from(vectorBucketName) {
+        return new VectorBucketScope(this.url, this.headers, vectorBucketName, this.fetch);
+    }
+}
+exports.StorageVectorsClient = StorageVectorsClient;
+/**
+ * Scoped client for operations within a specific vector bucket
+ * Provides index management and access to vector operations
+ */
+class VectorBucketScope extends VectorIndexApi_1.default {
+    constructor(url, headers, vectorBucketName, fetch) {
+        super(url, headers, fetch);
+        this.vectorBucketName = vectorBucketName;
+    }
+    /**
+     * Creates a new vector index in this bucket
+     * Convenience method that automatically includes the bucket name
+     *
+     * @param options - Index configuration (vectorBucketName is automatically set)
+     * @returns Promise with empty response on success or error
+     *
+     * @example
+     * ```typescript
+     * const bucket = client.bucket('embeddings-prod')
+     * await bucket.createIndex({
+     *   indexName: 'documents-openai',
+     *   dataType: 'float32',
+     *   dimension: 1536,
+     *   distanceMetric: 'cosine',
+     *   metadataConfiguration: {
+     *     nonFilterableMetadataKeys: ['raw_text']
+     *   }
+     * })
+     * ```
+     */
+    createIndex(options) {
+        const _super = Object.create(null, {
+            createIndex: { get: () => super.createIndex }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return _super.createIndex.call(this, Object.assign(Object.assign({}, options), { vectorBucketName: this.vectorBucketName }));
+        });
+    }
+    /**
+     * Lists indexes in this bucket
+     * Convenience method that automatically includes the bucket name
+     *
+     * @param options - Listing options (vectorBucketName is automatically set)
+     * @returns Promise with list of indexes or error
+     *
+     * @example
+     * ```typescript
+     * const bucket = client.bucket('embeddings-prod')
+     * const { data } = await bucket.listIndexes({ prefix: 'documents-' })
+     * ```
+     */
+    listIndexes() {
+        const _super = Object.create(null, {
+            listIndexes: { get: () => super.listIndexes }
+        });
+        return tslib_1.__awaiter(this, arguments, void 0, function* (options = {}) {
+            return _super.listIndexes.call(this, Object.assign(Object.assign({}, options), { vectorBucketName: this.vectorBucketName }));
+        });
+    }
+    /**
+     * Retrieves metadata for a specific index in this bucket
+     * Convenience method that automatically includes the bucket name
+     *
+     * @param indexName - Name of the index to retrieve
+     * @returns Promise with index metadata or error
+     *
+     * @example
+     * ```typescript
+     * const bucket = client.bucket('embeddings-prod')
+     * const { data } = await bucket.getIndex('documents-openai')
+     * console.log('Dimension:', data?.index.dimension)
+     * ```
+     */
+    getIndex(indexName) {
+        const _super = Object.create(null, {
+            getIndex: { get: () => super.getIndex }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return _super.getIndex.call(this, this.vectorBucketName, indexName);
+        });
+    }
+    /**
+     * Deletes an index from this bucket
+     * Convenience method that automatically includes the bucket name
+     *
+     * @param indexName - Name of the index to delete
+     * @returns Promise with empty response on success or error
+     *
+     * @example
+     * ```typescript
+     * const bucket = client.bucket('embeddings-prod')
+     * await bucket.deleteIndex('old-index')
+     * ```
+     */
+    deleteIndex(indexName) {
+        const _super = Object.create(null, {
+            deleteIndex: { get: () => super.deleteIndex }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return _super.deleteIndex.call(this, this.vectorBucketName, indexName);
+        });
+    }
+    /**
+     * Access operations for a specific index within this bucket
+     * Returns a scoped client for vector data operations
+     *
+     * @param indexName - Name of the index
+     * @returns Index-scoped client with vector data operations
+     *
+     * @example
+     * ```typescript
+     * const index = client.bucket('embeddings-prod').index('documents-openai')
+     *
+     * // Insert vectors
+     * await index.putVectors({
+     *   vectors: [
+     *     { key: 'doc-1', data: { float32: [...] }, metadata: { title: 'Intro' } }
+     *   ]
+     * })
+     *
+     * // Query similar vectors
+     * const { data } = await index.queryVectors({
+     *   queryVector: { float32: [...] },
+     *   topK: 5
+     * })
+     * ```
+     */
+    index(indexName) {
+        return new VectorIndexScope(this.url, this.headers, this.vectorBucketName, indexName, this.fetch);
+    }
+}
+exports.VectorBucketScope = VectorBucketScope;
+/**
+ * Scoped client for operations within a specific vector index
+ * Provides vector data operations (put, get, list, query, delete)
+ */
+class VectorIndexScope extends VectorDataApi_1.default {
+    constructor(url, headers, vectorBucketName, indexName, fetch) {
+        super(url, headers, fetch);
+        this.vectorBucketName = vectorBucketName;
+        this.indexName = indexName;
+    }
+    /**
+     * Inserts or updates vectors in this index
+     * Convenience method that automatically includes bucket and index names
+     *
+     * @param options - Vector insertion options (bucket and index names automatically set)
+     * @returns Promise with empty response on success or error
+     *
+     * @example
+     * ```typescript
+     * const index = client.bucket('embeddings-prod').index('documents-openai')
+     * await index.putVectors({
+     *   vectors: [
+     *     {
+     *       key: 'doc-1',
+     *       data: { float32: [0.1, 0.2, ...] },
+     *       metadata: { title: 'Introduction', page: 1 }
+     *     }
+     *   ]
+     * })
+     * ```
+     */
+    putVectors(options) {
+        const _super = Object.create(null, {
+            putVectors: { get: () => super.putVectors }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return _super.putVectors.call(this, Object.assign(Object.assign({}, options), { vectorBucketName: this.vectorBucketName, indexName: this.indexName }));
+        });
+    }
+    /**
+     * Retrieves vectors by keys from this index
+     * Convenience method that automatically includes bucket and index names
+     *
+     * @param options - Vector retrieval options (bucket and index names automatically set)
+     * @returns Promise with array of vectors or error
+     *
+     * @example
+     * ```typescript
+     * const index = client.bucket('embeddings-prod').index('documents-openai')
+     * const { data } = await index.getVectors({
+     *   keys: ['doc-1', 'doc-2'],
+     *   returnMetadata: true
+     * })
+     * ```
+     */
+    getVectors(options) {
+        const _super = Object.create(null, {
+            getVectors: { get: () => super.getVectors }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return _super.getVectors.call(this, Object.assign(Object.assign({}, options), { vectorBucketName: this.vectorBucketName, indexName: this.indexName }));
+        });
+    }
+    /**
+     * Lists vectors in this index with pagination
+     * Convenience method that automatically includes bucket and index names
+     *
+     * @param options - Listing options (bucket and index names automatically set)
+     * @returns Promise with array of vectors and pagination token
+     *
+     * @example
+     * ```typescript
+     * const index = client.bucket('embeddings-prod').index('documents-openai')
+     * const { data } = await index.listVectors({
+     *   maxResults: 500,
+     *   returnMetadata: true
+     * })
+     * ```
+     */
+    listVectors() {
+        const _super = Object.create(null, {
+            listVectors: { get: () => super.listVectors }
+        });
+        return tslib_1.__awaiter(this, arguments, void 0, function* (options = {}) {
+            return _super.listVectors.call(this, Object.assign(Object.assign({}, options), { vectorBucketName: this.vectorBucketName, indexName: this.indexName }));
+        });
+    }
+    /**
+     * Queries for similar vectors in this index
+     * Convenience method that automatically includes bucket and index names
+     *
+     * @param options - Query options (bucket and index names automatically set)
+     * @returns Promise with array of similar vectors ordered by distance
+     *
+     * @example
+     * ```typescript
+     * const index = client.bucket('embeddings-prod').index('documents-openai')
+     * const { data } = await index.queryVectors({
+     *   queryVector: { float32: [0.1, 0.2, ...] },
+     *   topK: 5,
+     *   filter: { category: 'technical' },
+     *   returnDistance: true,
+     *   returnMetadata: true
+     * })
+     * ```
+     */
+    queryVectors(options) {
+        const _super = Object.create(null, {
+            queryVectors: { get: () => super.queryVectors }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return _super.queryVectors.call(this, Object.assign(Object.assign({}, options), { vectorBucketName: this.vectorBucketName, indexName: this.indexName }));
+        });
+    }
+    /**
+     * Deletes vectors by keys from this index
+     * Convenience method that automatically includes bucket and index names
+     *
+     * @param options - Deletion options (bucket and index names automatically set)
+     * @returns Promise with empty response on success or error
+     *
+     * @example
+     * ```typescript
+     * const index = client.bucket('embeddings-prod').index('documents-openai')
+     * await index.deleteVectors({
+     *   keys: ['doc-1', 'doc-2', 'doc-3']
+     * })
+     * ```
+     */
+    deleteVectors(options) {
+        const _super = Object.create(null, {
+            deleteVectors: { get: () => super.deleteVectors }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return _super.deleteVectors.call(this, Object.assign(Object.assign({}, options), { vectorBucketName: this.vectorBucketName, indexName: this.indexName }));
+        });
+    }
+}
+exports.VectorIndexScope = VectorIndexScope;
+//# sourceMappingURL=StorageVectorsClient.js.map

package/dist/main/lib/vectors/StorageVectorsClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageVectorsClient.js","sourceRoot":"","sources":["../../../../src/lib/vectors/StorageVectorsClient.ts"],"names":[],"mappings":"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"}