@memvid/sdk 2.0.113

package/dist/embeddings.d.ts

@@ -0,0 +1,156 @@
+/**
+ * External embedding provider support for Memvid SDK (Node.js).
+ *
+ * This module provides classes for generating embeddings using external providers
+ * like OpenAI, allowing users to use their own embedding models with Memvid.
+ *
+ * @example
+ * ```typescript
+ * import { create } from 'memvid-sdk';
+ * import { OpenAIEmbeddings } from 'memvid-sdk/embeddings';
+ *
+ * // Initialize embedding provider
+ * const embedder = new OpenAIEmbeddings(); // Uses OPENAI_API_KEY env var
+ *
+ * // Create memory with external embeddings
+ * const mem = await create('knowledge.mv2', 'basic');
+ *
+ * // Store documents with embeddings
+ * const docs = [
+ *   { title: 'Doc 1', label: 'notes', text: 'Content 1...' },
+ *   { title: 'Doc 2', label: 'notes', text: 'Content 2...' },
+ * ];
+ * const embeddings = await embedder.embedDocuments(docs.map(d => d.text));
+ * // Use embeddings with putMany when available
+ * ```
+ */
+/**
+ * Model dimension mappings for common embedding models.
+ */
+export declare const MODEL_DIMENSIONS: Record<string, number>;
+/**
+ * Abstract interface for embedding providers.
+ */
+export interface EmbeddingProvider {
+    /** Embedding dimension for this model. */
+    readonly dimension: number;
+    /** Model name/identifier. */
+    readonly modelName: string;
+    /**
+     * Generate embeddings for a list of documents.
+     * @param texts - List of text documents to embed
+     * @returns Promise resolving to list of embedding vectors
+     */
+    embedDocuments(texts: string[]): Promise<number[][]>;
+    /**
+     * Generate embedding for a single query.
+     * @param text - Query text to embed
+     * @returns Promise resolving to embedding vector
+     */
+    embedQuery(text: string): Promise<number[]>;
+}
+/**
+ * OpenAI embedding provider configuration.
+ */
+export interface OpenAIEmbeddingsConfig {
+    /** OpenAI API key. If not provided, uses OPENAI_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: 'text-embedding-3-small' */
+    model?: string;
+    /** Number of texts to embed in a single API call. Default: 100 */
+    batchSize?: number;
+}
+/**
+ * OpenAI embedding provider.
+ *
+ * Uses OpenAI's text-embedding models to generate embeddings.
+ * Compatible with text-embedding-3-small, text-embedding-3-large, and text-embedding-ada-002.
+ *
+ * @example
+ * ```typescript
+ * const embedder = new OpenAIEmbeddings(); // Uses OPENAI_API_KEY
+ * const embedder = new OpenAIEmbeddings({ model: 'text-embedding-3-large' });
+ * const vectors = await embedder.embedDocuments(['Hello', 'World']);
+ * ```
+ */
+export declare class OpenAIEmbeddings implements EmbeddingProvider {
+    private readonly _apiKey;
+    private readonly _model;
+    private readonly _batchSize;
+    constructor(config?: OpenAIEmbeddingsConfig);
+    get dimension(): number;
+    get modelName(): string;
+    embedDocuments(texts: string[]): Promise<number[][]>;
+    embedQuery(text: string): Promise<number[]>;
+}
+/**
+ * Cohere embedding provider configuration.
+ */
+export interface CohereEmbeddingsConfig {
+    /** Cohere API key. If not provided, uses COHERE_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: 'embed-english-v3.0' */
+    model?: string;
+    /** Input type for documents. Default: 'search_document' */
+    inputType?: 'search_document' | 'search_query' | 'classification' | 'clustering';
+}
+/**
+ * Cohere embedding provider.
+ *
+ * @example
+ * ```typescript
+ * const embedder = new CohereEmbeddings(); // Uses COHERE_API_KEY
+ * const vectors = await embedder.embedDocuments(['Hello', 'World']);
+ * ```
+ */
+export declare class CohereEmbeddings implements EmbeddingProvider {
+    private readonly _apiKey;
+    private readonly _model;
+    private readonly _inputType;
+    constructor(config?: CohereEmbeddingsConfig);
+    get dimension(): number;
+    get modelName(): string;
+    embedDocuments(texts: string[]): Promise<number[][]>;
+    embedQuery(text: string): Promise<number[]>;
+}
+/**
+ * Voyage AI embedding provider configuration.
+ */
+export interface VoyageEmbeddingsConfig {
+    /** Voyage API key. If not provided, uses VOYAGE_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: 'voyage-3' */
+    model?: string;
+}
+/**
+ * Voyage AI embedding provider.
+ *
+ * @example
+ * ```typescript
+ * const embedder = new VoyageEmbeddings(); // Uses VOYAGE_API_KEY
+ * const vectors = await embedder.embedDocuments(['Hello', 'World']);
+ * ```
+ */
+export declare class VoyageEmbeddings implements EmbeddingProvider {
+    private readonly _apiKey;
+    private readonly _model;
+    constructor(config?: VoyageEmbeddingsConfig);
+    get dimension(): number;
+    get modelName(): string;
+    embedDocuments(texts: string[]): Promise<number[][]>;
+    embedQuery(text: string): Promise<number[]>;
+}
+/**
+ * Factory function to create an embedding provider.
+ *
+ * @param provider - One of: 'openai', 'cohere', 'voyage'
+ * @param config - Provider-specific configuration
+ * @returns EmbeddingProvider instance
+ *
+ * @example
+ * ```typescript
+ * const embedder = getEmbedder('openai');
+ * const embedder = getEmbedder('cohere', { model: 'embed-multilingual-v3.0' });
+ * ```
+ */
+export declare function getEmbedder(provider: 'openai' | 'cohere' | 'voyage', config?: Record<string, unknown>): EmbeddingProvider;

package/dist/embeddings.js

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * External embedding provider support for Memvid SDK (Node.js).
+ *
+ * This module provides classes for generating embeddings using external providers
+ * like OpenAI, allowing users to use their own embedding models with Memvid.
+ *
+ * @example
+ * ```typescript
+ * import { create } from 'memvid-sdk';
+ * import { OpenAIEmbeddings } from 'memvid-sdk/embeddings';
+ *
+ * // Initialize embedding provider
+ * const embedder = new OpenAIEmbeddings(); // Uses OPENAI_API_KEY env var
+ *
+ * // Create memory with external embeddings
+ * const mem = await create('knowledge.mv2', 'basic');
+ *
+ * // Store documents with embeddings
+ * const docs = [
+ *   { title: 'Doc 1', label: 'notes', text: 'Content 1...' },
+ *   { title: 'Doc 2', label: 'notes', text: 'Content 2...' },
+ * ];
+ * const embeddings = await embedder.embedDocuments(docs.map(d => d.text));
+ * // Use embeddings with putMany when available
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoyageEmbeddings = exports.CohereEmbeddings = exports.OpenAIEmbeddings = exports.MODEL_DIMENSIONS = void 0;
+exports.getEmbedder = getEmbedder;
+/**
+ * Model dimension mappings for common embedding models.
+ */
+exports.MODEL_DIMENSIONS = {
+    // OpenAI models
+    'text-embedding-3-small': 1536,
+    'text-embedding-3-large': 3072,
+    'text-embedding-ada-002': 1536,
+    // Cohere models
+    'embed-english-v3.0': 1024,
+    'embed-multilingual-v3.0': 1024,
+    'embed-english-light-v3.0': 384,
+    'embed-multilingual-light-v3.0': 384,
+    // Voyage models
+    'voyage-3': 1024,
+    'voyage-3-lite': 512,
+    'voyage-code-3': 1024,
+};
+/**
+ * OpenAI embedding provider.
+ *
+ * Uses OpenAI's text-embedding models to generate embeddings.
+ * Compatible with text-embedding-3-small, text-embedding-3-large, and text-embedding-ada-002.
+ *
+ * @example
+ * ```typescript
+ * const embedder = new OpenAIEmbeddings(); // Uses OPENAI_API_KEY
+ * const embedder = new OpenAIEmbeddings({ model: 'text-embedding-3-large' });
+ * const vectors = await embedder.embedDocuments(['Hello', 'World']);
+ * ```
+ */
+class OpenAIEmbeddings {
+    constructor(config = {}) {
+        this._apiKey = config.apiKey || process.env.OPENAI_API_KEY || '';
+        if (!this._apiKey) {
+            throw new Error('OpenAI API key required. Pass apiKey or set OPENAI_API_KEY environment variable.');
+        }
+        this._model = config.model || 'text-embedding-3-small';
+        this._batchSize = config.batchSize || 100;
+    }
+    get dimension() {
+        return exports.MODEL_DIMENSIONS[this._model] || 1536;
+    }
+    get modelName() {
+        return this._model;
+    }
+    async embedDocuments(texts) {
+        if (texts.length === 0) {
+            return [];
+        }
+        const allEmbeddings = [];
+        // Process in batches
+        for (let i = 0; i < texts.length; i += this._batchSize) {
+            const batch = texts.slice(i, i + this._batchSize);
+            const response = await fetch('https://api.openai.com/v1/embeddings', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this._apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    model: this._model,
+                    input: batch,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.text();
+                throw new Error(`OpenAI API error: ${response.status} ${error}`);
+            }
+            const data = await response.json();
+            // Sort by index to ensure correct order
+            const sorted = data.data.sort((a, b) => a.index - b.index);
+            allEmbeddings.push(...sorted.map(e => e.embedding));
+        }
+        return allEmbeddings;
+    }
+    async embedQuery(text) {
+        const response = await fetch('https://api.openai.com/v1/embeddings', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this._apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this._model,
+                input: text,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`OpenAI API error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        return data.data[0].embedding;
+    }
+}
+exports.OpenAIEmbeddings = OpenAIEmbeddings;
+/**
+ * Cohere embedding provider.
+ *
+ * @example
+ * ```typescript
+ * const embedder = new CohereEmbeddings(); // Uses COHERE_API_KEY
+ * const vectors = await embedder.embedDocuments(['Hello', 'World']);
+ * ```
+ */
+class CohereEmbeddings {
+    constructor(config = {}) {
+        this._apiKey = config.apiKey || process.env.COHERE_API_KEY || '';
+        if (!this._apiKey) {
+            throw new Error('Cohere API key required. Pass apiKey or set COHERE_API_KEY environment variable.');
+        }
+        this._model = config.model || 'embed-english-v3.0';
+        this._inputType = config.inputType || 'search_document';
+    }
+    get dimension() {
+        return exports.MODEL_DIMENSIONS[this._model] || 1024;
+    }
+    get modelName() {
+        return this._model;
+    }
+    async embedDocuments(texts) {
+        if (texts.length === 0) {
+            return [];
+        }
+        const response = await fetch('https://api.cohere.ai/v1/embed', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this._apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this._model,
+                texts: texts,
+                input_type: this._inputType,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Cohere API error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        return data.embeddings;
+    }
+    async embedQuery(text) {
+        const response = await fetch('https://api.cohere.ai/v1/embed', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this._apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this._model,
+                texts: [text],
+                input_type: 'search_query',
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Cohere API error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        return data.embeddings[0];
+    }
+}
+exports.CohereEmbeddings = CohereEmbeddings;
+/**
+ * Voyage AI embedding provider.
+ *
+ * @example
+ * ```typescript
+ * const embedder = new VoyageEmbeddings(); // Uses VOYAGE_API_KEY
+ * const vectors = await embedder.embedDocuments(['Hello', 'World']);
+ * ```
+ */
+class VoyageEmbeddings {
+    constructor(config = {}) {
+        this._apiKey = config.apiKey || process.env.VOYAGE_API_KEY || '';
+        if (!this._apiKey) {
+            throw new Error('Voyage API key required. Pass apiKey or set VOYAGE_API_KEY environment variable.');
+        }
+        this._model = config.model || 'voyage-3';
+    }
+    get dimension() {
+        return exports.MODEL_DIMENSIONS[this._model] || 1024;
+    }
+    get modelName() {
+        return this._model;
+    }
+    async embedDocuments(texts) {
+        if (texts.length === 0) {
+            return [];
+        }
+        const response = await fetch('https://api.voyageai.com/v1/embeddings', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this._apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this._model,
+                input: texts,
+                input_type: 'document',
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Voyage API error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        return data.data.map(d => d.embedding);
+    }
+    async embedQuery(text) {
+        const response = await fetch('https://api.voyageai.com/v1/embeddings', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this._apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this._model,
+                input: [text],
+                input_type: 'query',
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Voyage API error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        return data.data[0].embedding;
+    }
+}
+exports.VoyageEmbeddings = VoyageEmbeddings;
+/**
+ * Factory function to create an embedding provider.
+ *
+ * @param provider - One of: 'openai', 'cohere', 'voyage'
+ * @param config - Provider-specific configuration
+ * @returns EmbeddingProvider instance
+ *
+ * @example
+ * ```typescript
+ * const embedder = getEmbedder('openai');
+ * const embedder = getEmbedder('cohere', { model: 'embed-multilingual-v3.0' });
+ * ```
+ */
+function getEmbedder(provider, config) {
+    switch (provider.toLowerCase()) {
+        case 'openai':
+            return new OpenAIEmbeddings(config);
+        case 'cohere':
+            return new CohereEmbeddings(config);
+        case 'voyage':
+            return new VoyageEmbeddings(config);
+        default:
+            throw new Error(`Unknown provider: ${provider}. Supported: openai, cohere, voyage`);
+    }
+}

package/dist/entities.d.ts

@@ -0,0 +1,251 @@
+/**
+ * Entity extraction (NER) provider support for Memvid SDK (Node.js).
+ *
+ * Providers:
+ *   - LocalNER: DistilBERT-NER (ONNX, offline)
+ *   - OpenAIEntities: OpenAI GPT-4 (cloud, custom entity types)
+ *   - ClaudeEntities: Anthropic Claude (cloud, custom entity types)
+ *   - GeminiEntities: Google Gemini (cloud, custom entity types)
+ *
+ * @example
+ * ```typescript
+ * import { create } from 'memvid-sdk';
+ * import { getEntityExtractor, LocalNER, OpenAIEntities } from 'memvid-sdk/entities';
+ *
+ * // Local NER (default)
+ * const ner = getEntityExtractor('local');
+ *
+ * // Or with cloud provider for custom entity types
+ * const ner = getEntityExtractor('openai', {
+ *   entityTypes: ['COMPANY', 'PRODUCT', 'EXECUTIVE'],
+ * });
+ *
+ * // Extract entities
+ * const text = "Microsoft CEO Satya Nadella announced the new Surface Pro in Seattle.";
+ * const entities = await ner.extract(text);
+ * // [
+ * //   { name: "Microsoft", type: "ORG", confidence: 0.99 },
+ * //   { name: "Satya Nadella", type: "PERSON", confidence: 0.97 },
+ * //   { name: "Seattle", type: "LOCATION", confidence: 0.98 },
+ * // ]
+ *
+ * // Store with entities
+ * const mem = await create('knowledge.mv2', 'basic');
+ * await mem.put({ title: 'Tech News', text, entities });
+ * ```
+ */
+/**
+ * Extracted entity structure.
+ */
+export interface Entity {
+    /** Entity name as it appears in text. */
+    name: string;
+    /** Entity type (e.g., PERSON, ORG, LOCATION). */
+    type: string;
+    /** Confidence score between 0.0 and 1.0. */
+    confidence: number;
+}
+/**
+ * Relationship between entities.
+ */
+export interface Relationship {
+    /** Source entity name. */
+    source: string;
+    /** Target entity name. */
+    target: string;
+    /** Relationship type (e.g., WORKS_FOR, LOCATED_IN). */
+    type: string;
+    /** Confidence score between 0.0 and 1.0. */
+    confidence: number;
+}
+/**
+ * Result from entity extraction with optional relationships.
+ */
+export interface EntityExtractionResult {
+    /** Extracted entities. */
+    entities: Entity[];
+    /** Extracted relationships (optional). */
+    relationships?: Relationship[];
+}
+/**
+ * Abstract interface for entity extraction providers.
+ */
+export interface EntityExtractor {
+    /** Provider name (e.g., 'local:distilbert-ner'). */
+    readonly name: string;
+    /** Supported entity types. */
+    readonly entityTypes: string[];
+    /**
+     * Extract entities from text.
+     * @param text - Text to extract entities from
+     * @param minConfidence - Minimum confidence threshold (0.0-1.0)
+     * @returns Promise resolving to list of entities
+     */
+    extract(text: string, minConfidence?: number): Promise<Entity[]>;
+    /**
+     * Extract entities from multiple texts.
+     * @param texts - Texts to extract entities from
+     * @param minConfidence - Minimum confidence threshold
+     * @returns Promise resolving to list of entity arrays
+     */
+    extractBatch(texts: string[], minConfidence?: number): Promise<Entity[][]>;
+}
+/**
+ * Default entity types for cloud providers.
+ */
+export declare const DEFAULT_ENTITY_TYPES: string[];
+/**
+ * LocalNER configuration options.
+ */
+export interface LocalNERConfig {
+    /** Model to use. Default: 'distilbert-ner' */
+    model?: string;
+}
+/**
+ * Local NER provider using DistilBERT-NER (ONNX).
+ *
+ * Supported entity types (fixed):
+ *   - PERSON: People's names
+ *   - ORG: Organizations
+ *   - LOCATION: Places
+ *   - MISC: Miscellaneous
+ */
+export declare class LocalNER implements EntityExtractor {
+    private readonly _model;
+    private _nativeModel;
+    constructor(config?: LocalNERConfig);
+    get name(): string;
+    get entityTypes(): string[];
+    private _getModel;
+    extract(text: string, minConfidence?: number): Promise<Entity[]>;
+    extractBatch(texts: string[], minConfidence?: number): Promise<Entity[][]>;
+}
+/**
+ * OpenAIEntities configuration options.
+ */
+export interface OpenAIEntitiesConfig {
+    /** OpenAI API key. If not provided, uses OPENAI_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: 'gpt-4o-mini' */
+    model?: string;
+    /** Custom entity types. Default: standard NER types */
+    entityTypes?: string[];
+    /** Custom extraction prompt. */
+    prompt?: string;
+}
+/**
+ * OpenAI GPT-4 entity extraction provider.
+ *
+ * Supports custom entity types and relationship extraction.
+ */
+export declare class OpenAIEntities implements EntityExtractor {
+    private readonly _apiKey;
+    private readonly _model;
+    private readonly _entityTypes;
+    private readonly _prompt;
+    private static readonly DEFAULT_PROMPT;
+    constructor(config?: OpenAIEntitiesConfig);
+    get name(): string;
+    get entityTypes(): string[];
+    extract(text: string, minConfidence?: number): Promise<Entity[]>;
+    extractBatch(texts: string[], minConfidence?: number): Promise<Entity[][]>;
+    /**
+     * Extract entities AND relationships from text.
+     */
+    extractWithRelationships(text: string, minConfidence?: number): Promise<EntityExtractionResult>;
+}
+/**
+ * ClaudeEntities configuration options.
+ */
+export interface ClaudeEntitiesConfig {
+    /** Anthropic API key. If not provided, uses ANTHROPIC_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: 'claude-3-5-sonnet-20241022' */
+    model?: string;
+    /** Custom entity types. */
+    entityTypes?: string[];
+}
+/**
+ * Anthropic Claude entity extraction provider.
+ */
+export declare class ClaudeEntities implements EntityExtractor {
+    private readonly _apiKey;
+    private readonly _model;
+    private readonly _entityTypes;
+    constructor(config?: ClaudeEntitiesConfig);
+    get name(): string;
+    get entityTypes(): string[];
+    extract(text: string, minConfidence?: number): Promise<Entity[]>;
+    extractBatch(texts: string[], minConfidence?: number): Promise<Entity[][]>;
+}
+/**
+ * GeminiEntities configuration options.
+ */
+export interface GeminiEntitiesConfig {
+    /** Google AI API key. If not provided, uses GEMINI_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: 'gemini-2.0-flash' */
+    model?: string;
+    /** Custom entity types. */
+    entityTypes?: string[];
+}
+/**
+ * Google Gemini entity extraction provider.
+ */
+export declare class GeminiEntities implements EntityExtractor {
+    private readonly _apiKey;
+    private readonly _model;
+    private readonly _entityTypes;
+    constructor(config?: GeminiEntitiesConfig);
+    get name(): string;
+    get entityTypes(): string[];
+    extract(text: string, minConfidence?: number): Promise<Entity[]>;
+    extractBatch(texts: string[], minConfidence?: number): Promise<Entity[][]>;
+}
+/**
+ * Configuration options for getEntityExtractor factory.
+ */
+export interface EntityExtractorConfig {
+    /** Model name (provider-specific). */
+    model?: string;
+    /** API key for cloud providers. */
+    apiKey?: string;
+    /** Custom entity types (cloud providers only). */
+    entityTypes?: string[];
+    /** Custom extraction prompt (OpenAI only). */
+    prompt?: string;
+}
+/**
+ * Factory function to create an entity extraction provider.
+ *
+ * @param provider - Provider specification. Can be:
+ *   - Simple: 'local', 'openai', 'claude', 'gemini'
+ *   - With model: 'openai:gpt-4o-mini', 'claude:claude-3-5-sonnet-20241022'
+ * @param config - Provider-specific configuration
+ * @returns EntityExtractor instance
+ *
+ * @example
+ * ```typescript
+ * // Simple provider
+ * const ner = getEntityExtractor('local');
+ * const ner = getEntityExtractor('openai');
+ *
+ * // Provider with model specification
+ * const ner = getEntityExtractor('openai:gpt-4o-mini');
+ * const ner = getEntityExtractor('claude:claude-3-5-sonnet-20241022');
+ * const ner = getEntityExtractor('gemini:gemini-2.0-flash');
+ *
+ * // With config for custom entity types
+ * const ner = getEntityExtractor('openai', { entityTypes: ['COMPANY', 'PRODUCT'] });
+ * ```
+ */
+export declare function getEntityExtractor(provider?: string, config?: EntityExtractorConfig): EntityExtractor;
+declare const _default: {
+    LocalNER: typeof LocalNER;
+    OpenAIEntities: typeof OpenAIEntities;
+    ClaudeEntities: typeof ClaudeEntities;
+    GeminiEntities: typeof GeminiEntities;
+    getEntityExtractor: typeof getEntityExtractor;
+    DEFAULT_ENTITY_TYPES: string[];
+};
+export default _default;