@ductape/sdk 0.0.4-v51 → 0.0.4-v52

package/dist/vector/types/connection.interface.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Vector Database Connection Types
+ *
+ * Connection-related interfaces for vector databases.
+ */
+import { VectorDBType, DistanceMetric, VectorIndexType } from './enums';
+/**
+ * Environment-specific vector database configuration
+ */
+export interface IVectorEnvConfig {
+    /** Environment slug (e.g., 'dev', 'staging', 'prd') */
+    slug: string;
+    /** API endpoint URL */
+    endpoint?: string;
+    /** API key */
+    apiKey?: string;
+    /** Cloud region (for managed services) */
+    region?: string;
+    /** Index/collection name */
+    index?: string;
+    /** Namespace for multi-tenancy */
+    namespace?: string;
+    /** Whether this environment is active */
+    active?: boolean;
+}
+/**
+ * Vector database configuration
+ */
+export interface IVectorConfig {
+    /** Unique vector store tag */
+    tag: string;
+    /** Human-readable name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Vector database type */
+    type: VectorDBType;
+    /** Vector dimensions */
+    dimensions: number;
+    /** Distance metric for similarity */
+    metric?: DistanceMetric;
+    /** Index type */
+    indexType?: VectorIndexType;
+    /** Environment configurations */
+    envs?: IVectorEnvConfig[];
+}
+/**
+ * Connection configuration for a vector database
+ */
+export interface IVectorConnectionConfig {
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Vector store tag */
+    vector: string;
+    /** Optional namespace override */
+    namespace?: string;
+    /** Connection options */
+    options?: IVectorConnectionOptions;
+}
+/**
+ * Connection options
+ */
+export interface IVectorConnectionOptions {
+    /** Connection timeout in ms */
+    timeout?: number;
+    /** Enable SSL/TLS */
+    ssl?: boolean;
+    /** Number of retries */
+    retries?: number;
+    /** Retry delay in ms */
+    retryDelay?: number;
+    /** Custom headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Connection result
+ */
+export interface IVectorConnectionResult {
+    /** Whether connection was successful */
+    connected: boolean;
+    /** Index/collection name */
+    index?: string;
+    /** Vector dimensions */
+    dimensions?: number;
+    /** Number of vectors in index */
+    vectorCount?: number;
+    /** Latency in ms */
+    latency?: number;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Connection context (internal state)
+ */
+export interface IVectorConnectionContext {
+    /** Vector store tag */
+    vector: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database type */
+    type: VectorDBType;
+    /** API endpoint */
+    endpoint: string;
+    /** Index/collection name */
+    index: string;
+    /** Namespace */
+    namespace?: string;
+    /** Dimensions */
+    dimensions: number;
+    /** Metric */
+    metric: DistanceMetric;
+    /** Whether connected */
+    connected: boolean;
+}
+/**
+ * Service configuration
+ */
+export interface IVectorServiceConfig {
+    /** Workspace ID */
+    workspace_id: string;
+    /** Public key for authentication */
+    public_key: string;
+    /** User ID */
+    user_id: string;
+    /** Authentication token */
+    token: string;
+    /** Environment type (staging, production, local) */
+    env_type: string;
+}
+/**
+ * Test connection result
+ */
+export interface IVectorTestConnectionResult {
+    /** Whether the connection test passed */
+    success: boolean;
+    /** Response time in ms */
+    latency: number;
+    /** Index information */
+    index?: {
+        name: string;
+        dimensions: number;
+        metric: string;
+        vectorCount: number;
+    };
+    /** Error message if failed */
+    error?: string;
+}

package/dist/vector/types/connection.interface.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Vector Database Connection Types
+ *
+ * Connection-related interfaces for vector databases.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=connection.interface.js.map

package/dist/vector/types/connection.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.interface.js","sourceRoot":"","sources":["../../../src/vector/types/connection.interface.ts"],"names":[],"mappings":";AAAA;;;;GAIG"}

package/dist/vector/types/embedding.interface.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Embedding Provider Types
+ *
+ * Interfaces for embedding generation providers.
+ */
+/**
+ * Supported embedding providers
+ */
+export type EmbeddingProvider = 'openai' | 'anthropic' | 'cohere' | 'huggingface' | 'voyage' | 'jina' | 'local' | 'custom';
+/**
+ * Embedding model configuration
+ */
+export interface IEmbeddingModelConfig {
+    /** Provider name */
+    provider: EmbeddingProvider;
+    /** Model identifier */
+    model: string;
+    /** API key (can be pulled from secrets) */
+    apiKey?: string;
+    /** API base URL */
+    baseUrl?: string;
+    /** Output dimensions (for models that support it) */
+    dimensions?: number;
+    /** Request timeout in ms */
+    timeout?: number;
+    /** Batch size for batch embedding */
+    batchSize?: number;
+    /** Custom headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Embedding request options
+ */
+export interface IEmbedOptions {
+    /** Input type hint (for providers that support it) */
+    inputType?: 'search_document' | 'search_query' | 'classification' | 'clustering';
+    /** Truncation strategy */
+    truncation?: boolean | 'start' | 'end';
+    /** Custom parameters */
+    params?: Record<string, unknown>;
+}
+/**
+ * Embedding result for a single text
+ */
+export interface IEmbeddingResult {
+    /** Text that was embedded */
+    text: string;
+    /** Embedding vector */
+    embedding: number[];
+    /** Token count (if available) */
+    tokenCount?: number;
+}
+/**
+ * Batch embedding result
+ */
+export interface IBatchEmbeddingResult {
+    /** Embeddings */
+    embeddings: IEmbeddingResult[];
+    /** Total tokens used */
+    totalTokens?: number;
+    /** Model used */
+    model: string;
+    /** Provider used */
+    provider: EmbeddingProvider;
+}
+/**
+ * Embedding provider interface
+ */
+export interface IEmbeddingProvider {
+    /** Provider name */
+    readonly provider: EmbeddingProvider;
+    /** Model name */
+    readonly model: string;
+    /** Output dimensions */
+    readonly dimensions: number;
+    /** Generate embedding for single text */
+    embed(text: string, options?: IEmbedOptions): Promise<number[]>;
+    /** Generate embeddings for multiple texts */
+    embedBatch(texts: string[], options?: IEmbedOptions): Promise<number[][]>;
+    /** Get token count for text (if supported) */
+    countTokens?(text: string): Promise<number>;
+}
+/**
+ * OpenAI embedding config
+ */
+export interface IOpenAIEmbeddingConfig extends IEmbeddingModelConfig {
+    provider: 'openai';
+    /** Model: text-embedding-ada-002, text-embedding-3-small, text-embedding-3-large */
+    model: string;
+    /** Encoding format */
+    encodingFormat?: 'float' | 'base64';
+}
+/**
+ * Cohere embedding config
+ */
+export interface ICohereEmbeddingConfig extends IEmbeddingModelConfig {
+    provider: 'cohere';
+    /** Model: embed-english-v3.0, embed-multilingual-v3.0, etc. */
+    model: string;
+    /** Input type */
+    inputType?: 'search_document' | 'search_query' | 'classification' | 'clustering';
+    /** Truncation */
+    truncate?: 'NONE' | 'START' | 'END';
+}
+/**
+ * Voyage AI embedding config
+ */
+export interface IVoyageEmbeddingConfig extends IEmbeddingModelConfig {
+    provider: 'voyage';
+    /** Model: voyage-large-2, voyage-code-2, etc. */
+    model: string;
+    /** Input type */
+    inputType?: 'document' | 'query';
+}
+/**
+ * Jina embedding config
+ */
+export interface IJinaEmbeddingConfig extends IEmbeddingModelConfig {
+    provider: 'jina';
+    /** Model: jina-embeddings-v2-base-en, jina-embeddings-v2-small-en, etc. */
+    model: string;
+}
+/**
+ * HuggingFace embedding config
+ */
+export interface IHuggingFaceEmbeddingConfig extends IEmbeddingModelConfig {
+    provider: 'huggingface';
+    /** Model ID or URL */
+    model: string;
+    /** Use HuggingFace Inference API */
+    useInferenceAPI?: boolean;
+}
+/**
+ * Local embedding config (for self-hosted models)
+ */
+export interface ILocalEmbeddingConfig extends IEmbeddingModelConfig {
+    provider: 'local';
+    /** Model path or identifier */
+    model: string;
+    /** Device to use (cpu, cuda, mps) */
+    device?: string;
+    /** Pooling strategy */
+    pooling?: 'mean' | 'cls' | 'max';
+}

package/dist/vector/types/embedding.interface.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Embedding Provider Types
+ *
+ * Interfaces for embedding generation providers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=embedding.interface.js.map

package/dist/vector/types/embedding.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding.interface.js","sourceRoot":"","sources":["../../../src/vector/types/embedding.interface.ts"],"names":[],"mappings":";AAAA;;;;GAIG"}

package/dist/vector/types/enums.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Vector Database Enums
+ *
+ * Enumerations for vector database types and operations.
+ */
+/**
+ * Supported vector database types
+ */
+export declare enum VectorDBType {
+    /** Pinecone - Managed vector database */
+    PINECONE = "pinecone",
+    /** Qdrant - Open-source vector search engine */
+    QDRANT = "qdrant",
+    /** Weaviate - AI-native vector database */
+    WEAVIATE = "weaviate",
+    /** ChromaDB - Open-source embedding database */
+    CHROMA = "chroma",
+    /** Milvus - Open-source vector database */
+    MILVUS = "milvus",
+    /** pgvector - PostgreSQL extension for vectors */
+    PGVECTOR = "pgvector",
+    /** In-memory vector store (for development/testing) */
+    MEMORY = "memory"
+}
+/**
+ * Distance metric types for similarity search
+ */
+export declare enum DistanceMetric {
+    /** Cosine similarity (angle between vectors) */
+    COSINE = "cosine",
+    /** Euclidean distance (L2 norm) */
+    EUCLIDEAN = "euclidean",
+    /** Dot product (inner product) */
+    DOT_PRODUCT = "dotproduct",
+    /** Manhattan distance (L1 norm) */
+    MANHATTAN = "manhattan",
+    /** Hamming distance (for binary vectors) */
+    HAMMING = "hamming"
+}
+/**
+ * Index types for vector databases
+ */
+export declare enum VectorIndexType {
+    /** Flat index (exact search) */
+    FLAT = "flat",
+    /** IVF (Inverted File Index) */
+    IVF = "ivf",
+    /** HNSW (Hierarchical Navigable Small World) */
+    HNSW = "hnsw",
+    /** Product Quantization */
+    PQ = "pq",
+    /** IVF with Product Quantization */
+    IVF_PQ = "ivf_pq",
+    /** Annoy (Approximate Nearest Neighbors Oh Yeah) */
+    ANNOY = "annoy"
+}
+/**
+ * Vector error types
+ */
+export declare enum VectorErrorType {
+    /** Connection error */
+    CONNECTION_ERROR = "connection_error",
+    /** Configuration error */
+    CONFIGURATION_ERROR = "configuration_error",
+    /** Authentication error */
+    AUTHENTICATION_ERROR = "authentication_error",
+    /** Collection not found */
+    COLLECTION_NOT_FOUND = "collection_not_found",
+    /** Vector not found */
+    VECTOR_NOT_FOUND = "vector_not_found",
+    /** Dimension mismatch */
+    DIMENSION_MISMATCH = "dimension_mismatch",
+    /** Invalid operation */
+    INVALID_OPERATION = "invalid_operation",
+    /** Rate limit exceeded */
+    RATE_LIMIT_ERROR = "rate_limit_error",
+    /** Timeout error */
+    TIMEOUT_ERROR = "timeout_error",
+    /** Unknown error */
+    UNKNOWN_ERROR = "unknown_error"
+}
+/**
+ * Vector database features
+ */
+export declare enum VectorFeature {
+    /** Supports metadata filtering */
+    METADATA_FILTERING = "metadata_filtering",
+    /** Supports namespace/partition */
+    NAMESPACES = "namespaces",
+    /** Supports hybrid search (vector + keyword) */
+    HYBRID_SEARCH = "hybrid_search",
+    /** Supports batch operations */
+    BATCH_OPERATIONS = "batch_operations",
+    /** Supports index management */
+    INDEX_MANAGEMENT = "index_management",
+    /** Supports vector updates */
+    VECTOR_UPDATES = "vector_updates",
+    /** Supports sparse vectors */
+    SPARSE_VECTORS = "sparse_vectors",
+    /** Supports multi-vector queries */
+    MULTI_VECTOR = "multi_vector",
+    /** Supports aggregations */
+    AGGREGATIONS = "aggregations"
+}

package/dist/vector/types/enums.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Vector Database Enums
+ *
+ * Enumerations for vector database types and operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorFeature = exports.VectorErrorType = exports.VectorIndexType = exports.DistanceMetric = exports.VectorDBType = void 0;
+/**
+ * Supported vector database types
+ */
+var VectorDBType;
+(function (VectorDBType) {
+    /** Pinecone - Managed vector database */
+    VectorDBType["PINECONE"] = "pinecone";
+    /** Qdrant - Open-source vector search engine */
+    VectorDBType["QDRANT"] = "qdrant";
+    /** Weaviate - AI-native vector database */
+    VectorDBType["WEAVIATE"] = "weaviate";
+    /** ChromaDB - Open-source embedding database */
+    VectorDBType["CHROMA"] = "chroma";
+    /** Milvus - Open-source vector database */
+    VectorDBType["MILVUS"] = "milvus";
+    /** pgvector - PostgreSQL extension for vectors */
+    VectorDBType["PGVECTOR"] = "pgvector";
+    /** In-memory vector store (for development/testing) */
+    VectorDBType["MEMORY"] = "memory";
+})(VectorDBType || (exports.VectorDBType = VectorDBType = {}));
+/**
+ * Distance metric types for similarity search
+ */
+var DistanceMetric;
+(function (DistanceMetric) {
+    /** Cosine similarity (angle between vectors) */
+    DistanceMetric["COSINE"] = "cosine";
+    /** Euclidean distance (L2 norm) */
+    DistanceMetric["EUCLIDEAN"] = "euclidean";
+    /** Dot product (inner product) */
+    DistanceMetric["DOT_PRODUCT"] = "dotproduct";
+    /** Manhattan distance (L1 norm) */
+    DistanceMetric["MANHATTAN"] = "manhattan";
+    /** Hamming distance (for binary vectors) */
+    DistanceMetric["HAMMING"] = "hamming";
+})(DistanceMetric || (exports.DistanceMetric = DistanceMetric = {}));
+/**
+ * Index types for vector databases
+ */
+var VectorIndexType;
+(function (VectorIndexType) {
+    /** Flat index (exact search) */
+    VectorIndexType["FLAT"] = "flat";
+    /** IVF (Inverted File Index) */
+    VectorIndexType["IVF"] = "ivf";
+    /** HNSW (Hierarchical Navigable Small World) */
+    VectorIndexType["HNSW"] = "hnsw";
+    /** Product Quantization */
+    VectorIndexType["PQ"] = "pq";
+    /** IVF with Product Quantization */
+    VectorIndexType["IVF_PQ"] = "ivf_pq";
+    /** Annoy (Approximate Nearest Neighbors Oh Yeah) */
+    VectorIndexType["ANNOY"] = "annoy";
+})(VectorIndexType || (exports.VectorIndexType = VectorIndexType = {}));
+/**
+ * Vector error types
+ */
+var VectorErrorType;
+(function (VectorErrorType) {
+    /** Connection error */
+    VectorErrorType["CONNECTION_ERROR"] = "connection_error";
+    /** Configuration error */
+    VectorErrorType["CONFIGURATION_ERROR"] = "configuration_error";
+    /** Authentication error */
+    VectorErrorType["AUTHENTICATION_ERROR"] = "authentication_error";
+    /** Collection not found */
+    VectorErrorType["COLLECTION_NOT_FOUND"] = "collection_not_found";
+    /** Vector not found */
+    VectorErrorType["VECTOR_NOT_FOUND"] = "vector_not_found";
+    /** Dimension mismatch */
+    VectorErrorType["DIMENSION_MISMATCH"] = "dimension_mismatch";
+    /** Invalid operation */
+    VectorErrorType["INVALID_OPERATION"] = "invalid_operation";
+    /** Rate limit exceeded */
+    VectorErrorType["RATE_LIMIT_ERROR"] = "rate_limit_error";
+    /** Timeout error */
+    VectorErrorType["TIMEOUT_ERROR"] = "timeout_error";
+    /** Unknown error */
+    VectorErrorType["UNKNOWN_ERROR"] = "unknown_error";
+})(VectorErrorType || (exports.VectorErrorType = VectorErrorType = {}));
+/**
+ * Vector database features
+ */
+var VectorFeature;
+(function (VectorFeature) {
+    /** Supports metadata filtering */
+    VectorFeature["METADATA_FILTERING"] = "metadata_filtering";
+    /** Supports namespace/partition */
+    VectorFeature["NAMESPACES"] = "namespaces";
+    /** Supports hybrid search (vector + keyword) */
+    VectorFeature["HYBRID_SEARCH"] = "hybrid_search";
+    /** Supports batch operations */
+    VectorFeature["BATCH_OPERATIONS"] = "batch_operations";
+    /** Supports index management */
+    VectorFeature["INDEX_MANAGEMENT"] = "index_management";
+    /** Supports vector updates */
+    VectorFeature["VECTOR_UPDATES"] = "vector_updates";
+    /** Supports sparse vectors */
+    VectorFeature["SPARSE_VECTORS"] = "sparse_vectors";
+    /** Supports multi-vector queries */
+    VectorFeature["MULTI_VECTOR"] = "multi_vector";
+    /** Supports aggregations */
+    VectorFeature["AGGREGATIONS"] = "aggregations";
+})(VectorFeature || (exports.VectorFeature = VectorFeature = {}));
+//# sourceMappingURL=enums.js.map

package/dist/vector/types/enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../src/vector/types/enums.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH;;GAEG;AACH,IAAY,YAeX;AAfD,WAAY,YAAY;IACtB,yCAAyC;IACzC,qCAAqB,CAAA;IACrB,gDAAgD;IAChD,iCAAiB,CAAA;IACjB,2CAA2C;IAC3C,qCAAqB,CAAA;IACrB,gDAAgD;IAChD,iCAAiB,CAAA;IACjB,2CAA2C;IAC3C,iCAAiB,CAAA;IACjB,kDAAkD;IAClD,qCAAqB,CAAA;IACrB,uDAAuD;IACvD,iCAAiB,CAAA;AACnB,CAAC,EAfW,YAAY,4BAAZ,YAAY,QAevB;AAED;;GAEG;AACH,IAAY,cAWX;AAXD,WAAY,cAAc;IACxB,gDAAgD;IAChD,mCAAiB,CAAA;IACjB,mCAAmC;IACnC,yCAAuB,CAAA;IACvB,kCAAkC;IAClC,4CAA0B,CAAA;IAC1B,mCAAmC;IACnC,yCAAuB,CAAA;IACvB,4CAA4C;IAC5C,qCAAmB,CAAA;AACrB,CAAC,EAXW,cAAc,8BAAd,cAAc,QAWzB;AAED;;GAEG;AACH,IAAY,eAaX;AAbD,WAAY,eAAe;IACzB,gCAAgC;IAChC,gCAAa,CAAA;IACb,gCAAgC;IAChC,8BAAW,CAAA;IACX,gDAAgD;IAChD,gCAAa,CAAA;IACb,2BAA2B;IAC3B,4BAAS,CAAA;IACT,oCAAoC;IACpC,oCAAiB,CAAA;IACjB,oDAAoD;IACpD,kCAAe,CAAA;AACjB,CAAC,EAbW,eAAe,+BAAf,eAAe,QAa1B;AAED;;GAEG;AACH,IAAY,eAqBX;AArBD,WAAY,eAAe;IACzB,uBAAuB;IACvB,wDAAqC,CAAA;IACrC,0BAA0B;IAC1B,8DAA2C,CAAA;IAC3C,2BAA2B;IAC3B,gEAA6C,CAAA;IAC7C,2BAA2B;IAC3B,gEAA6C,CAAA;IAC7C,uBAAuB;IACvB,wDAAqC,CAAA;IACrC,yBAAyB;IACzB,4DAAyC,CAAA;IACzC,wBAAwB;IACxB,0DAAuC,CAAA;IACvC,0BAA0B;IAC1B,wDAAqC,CAAA;IACrC,oBAAoB;IACpB,kDAA+B,CAAA;IAC/B,oBAAoB;IACpB,kDAA+B,CAAA;AACjC,CAAC,EArBW,eAAe,+BAAf,eAAe,QAqB1B;AAED;;GAEG;AACH,IAAY,aAmBX;AAnBD,WAAY,aAAa;IACvB,kCAAkC;IAClC,0DAAyC,CAAA;IACzC,mCAAmC;IACnC,0CAAyB,CAAA;IACzB,gDAAgD;IAChD,gDAA+B,CAAA;IAC/B,gCAAgC;IAChC,sDAAqC,CAAA;IACrC,gCAAgC;IAChC,sDAAqC,CAAA;IACrC,8BAA8B;IAC9B,kDAAiC,CAAA;IACjC,8BAA8B;IAC9B,kDAAiC,CAAA;IACjC,oCAAoC;IACpC,8CAA6B,CAAA;IAC7B,4BAA4B;IAC5B,8CAA6B,CAAA;AAC/B,CAAC,EAnBW,aAAa,6BAAb,aAAa,QAmBxB"}

package/dist/vector/types/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Vector Database Types Index
+ *
+ * Export all vector database types.
+ */
+export { VectorDBType, DistanceMetric, VectorIndexType, VectorErrorType, VectorFeature, } from './enums';
+export type { IVectorEnvConfig, IVectorConfig, IVectorConnectionConfig, IVectorConnectionOptions, IVectorConnectionResult, IVectorConnectionContext, IVectorServiceConfig, IVectorTestConnectionResult, } from './connection.interface';
+export type { VectorMetadata, IVector, ISparseVector, IUpsertVectorsOptions, IUpsertVectorsResult, IMetadataFilter, MetadataFilterOperator, IMetadataFilterGroup, IQueryVectorsOptions, IQueryMatch, IQueryVectorsResult, IFetchVectorsOptions, IFetchVectorsResult, IUpdateVectorOptions, IUpdateVectorResult, IDeleteVectorsOptions, IDeleteVectorsResult, IListVectorsOptions, IListVectorsResult, INamespaceInfo, IListNamespacesResult, IVectorIndexInfo, ICreateIndexOptions, ICreateIndexResult, IDeleteIndexOptions, IDeleteIndexResult, IVectorIndexStats, } from './vector.interface';
+export type { EmbeddingProvider, IEmbeddingModelConfig, IEmbedOptions, IEmbeddingResult, IBatchEmbeddingResult, IEmbeddingProvider, IOpenAIEmbeddingConfig, ICohereEmbeddingConfig, IVoyageEmbeddingConfig, IJinaEmbeddingConfig, IHuggingFaceEmbeddingConfig, ILocalEmbeddingConfig, } from './embedding.interface';

package/dist/vector/types/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Vector Database Types Index
+ *
+ * Export all vector database types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorFeature = exports.VectorErrorType = exports.VectorIndexType = exports.DistanceMetric = exports.VectorDBType = void 0;
+// Enums
+var enums_1 = require("./enums");
+Object.defineProperty(exports, "VectorDBType", { enumerable: true, get: function () { return enums_1.VectorDBType; } });
+Object.defineProperty(exports, "DistanceMetric", { enumerable: true, get: function () { return enums_1.DistanceMetric; } });
+Object.defineProperty(exports, "VectorIndexType", { enumerable: true, get: function () { return enums_1.VectorIndexType; } });
+Object.defineProperty(exports, "VectorErrorType", { enumerable: true, get: function () { return enums_1.VectorErrorType; } });
+Object.defineProperty(exports, "VectorFeature", { enumerable: true, get: function () { return enums_1.VectorFeature; } });
+//# sourceMappingURL=index.js.map

package/dist/vector/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/vector/types/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,QAAQ;AACR,iCAMiB;AALf,qGAAA,YAAY,OAAA;AACZ,uGAAA,cAAc,OAAA;AACd,wGAAA,eAAe,OAAA;AACf,wGAAA,eAAe,OAAA;AACf,sGAAA,aAAa,OAAA"}