@utaba/deep-memory 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,408 @@
+import { G as GovernanceConfig, M as MemoryVocabulary, q as ResolvedVocabulary, C as CreateEntityInput, U as UpdateEntityInput, r as CreateRelationshipInput, s as EntityTypeDefinition, t as VocabularyProposal, u as VocabularyProposalResult, v as ProvenanceContext, w as Provenance, x as Entity, D as DetailLevel, y as EntitySummary, z as EntityBrief, F as FindEntitiesQuery, P as PaginatedResult, A as ReembedResult, H as Relationship, J as PropertyFilter, K as RelationshipSummary, L as GraphResult, N as ExploreOptions, O as Neighbourhood, Q as PathOptions, T as PathResult, W as ConceptSearchOptions, X as ScoredEntity, Y as TimelineOptions, Z as TimelineResult, d as RepositoryStats, _ as RepositoryConfig, R as RepositoryFilter, $ as RepositorySummary, c as RepositoryUpdate, a as StoredRepository, a0 as ExportArchive, a1 as ImportOptions, a2 as ImportResult, a3 as ExportStreamItem, a4 as ImportStreamHeader, I as ImportChunk, S as StorageRepositoryConfig, b as StoredRepositorySummary, e as PaginationOptions, V as VocabularyChangeRecord, f as StoredEntity, g as StoredEntityUpdate, h as StorageFindQuery, i as StoredRelationship, j as RelationshipQueryOptions, k as StorageExploreOptions, l as StorageNeighbourhood, m as StoragePathOptions, n as StoragePathResult, o as StorageTimelineOptions, p as StorageTimelineResult, E as ExportChunk, B as BulkImportResult, a5 as SearchOptions, a6 as SearchHit } from './portability-DdlNYXGX.js';
+export { a7 as EnrichedRelationship, a8 as EntityMap, a9 as EntityTypeInput, aa as ExportManifest, ab as GetEntitiesOptions, ac as GetEntityOptions, ad as GovernanceMode, ae as ImportWarning, af as NeighbourhoodCentre, ag as NeighbourhoodGroup, ah as NeighbourhoodLayer, ai as Path, aj as PropertySchema, ak as PropertyType, al as ProvenanceFilter, am as RelationshipDirection, an as RelationshipTypeDefinition, ao as RelationshipTypeInput, ap as RepositoryMetadata, aq as StorageNeighbourhoodGroup, ar as StorageNeighbourhoodLayer, as as StoragePath, at as StorageTimelineEvent, au as TimelineEntityRef, av as TimelineEvent, aw as TimelineRelationshipDetail, ax as VocabularyInput } from './portability-DdlNYXGX.js';
+import { DeepMemoryEventType, EventHandler, Unsubscribe, DeepMemoryEvent, HookResult, EventPayload } from './types/index.js';
+import { S as StorageProvider } from './StorageProvider-CJjz8uBY.js';
+import { EmbeddingProvider, SearchProvider, LockProvider, SearchableEntity } from './providers/index.js';
+export { LockHandle, LockOptions } from './providers/index.js';
+
+/** Error codes for all Deep Memory errors */
+type DeepMemoryErrorCode = 'INVALID_INPUT' | 'ENTITY_NOT_FOUND' | 'ENTITY_ALREADY_EXISTS' | 'RELATIONSHIP_NOT_FOUND' | 'RELATIONSHIP_ALREADY_EXISTS' | 'REPOSITORY_NOT_FOUND' | 'REPOSITORY_ALREADY_EXISTS' | 'VOCABULARY_VALIDATION_FAILED' | 'RELATIONSHIP_CONSTRAINT_FAILED' | 'GOVERNANCE_DENIED' | 'OPERATION_CANCELLED' | 'EMBEDDING_PROVIDER_REQUIRED' | 'IMPORT_ERROR' | 'EXPORT_ERROR' | 'PROVIDER_ERROR';
+/** Base error class for all Deep Memory errors */
+declare class DeepMemoryError extends Error {
+    readonly code: DeepMemoryErrorCode;
+    readonly suggestion?: string;
+    constructor(code: DeepMemoryErrorCode, message: string, suggestion?: string);
+}
+/** Input validation failed (e.g. invalid ID format) */
+declare class InvalidInputError extends DeepMemoryError {
+    readonly field: string;
+    constructor(field: string, message: string, suggestion?: string);
+}
+/** Entity was not found in the repository */
+declare class EntityNotFoundError extends DeepMemoryError {
+    readonly id: string;
+    readonly slug?: string;
+    constructor(idOrSlug: string, slug?: string);
+}
+/** Attempted to create an entity with an ID that already exists */
+declare class DuplicateEntityError extends DeepMemoryError {
+    readonly id: string;
+    constructor(id: string);
+}
+/** Relationship was not found */
+declare class RelationshipNotFoundError extends DeepMemoryError {
+    readonly relationshipId: string;
+    constructor(relationshipId: string);
+}
+/** Attempted to create a relationship with an ID that already exists */
+declare class DuplicateRelationshipError extends DeepMemoryError {
+    readonly relationshipId: string;
+    constructor(relationshipId: string);
+}
+/** Repository was not found */
+declare class RepositoryNotFoundError extends DeepMemoryError {
+    readonly repositoryId: string;
+    constructor(repositoryId: string);
+}
+/** Attempted to create a repository with an ID that already exists */
+declare class DuplicateRepositoryError extends DeepMemoryError {
+    readonly repositoryId: string;
+    constructor(repositoryId: string);
+}
+/** Entity or relationship failed vocabulary validation */
+declare class VocabularyValidationError extends DeepMemoryError {
+    readonly errors: Array<{
+        field: string;
+        message: string;
+        suggestion?: string;
+    }>;
+    constructor(errors: Array<{
+        field: string;
+        message: string;
+        suggestion?: string;
+    }>);
+}
+/** Relationship source/target entity types violate vocabulary constraints */
+declare class RelationshipConstraintError extends DeepMemoryError {
+    readonly relationshipType: string;
+    readonly sourceType?: string;
+    readonly targetType?: string;
+    constructor(relationshipType: string, message: string, sourceType?: string, targetType?: string);
+}
+/** Governance rules denied the operation */
+declare class GovernanceDeniedError extends DeepMemoryError {
+    readonly governanceMode: string;
+    constructor(governanceMode: string, reason: string);
+}
+/** A pre-mutation hook cancelled the operation */
+declare class OperationCancelledError extends DeepMemoryError {
+    readonly operation: string;
+    readonly reason: string;
+    constructor(operation: string, reason: string);
+}
+/** Semantic search was attempted without an embedding provider */
+declare class EmbeddingProviderRequiredError extends DeepMemoryError {
+    constructor();
+}
+/** Error during import operations */
+declare class ImportError extends DeepMemoryError {
+    constructor(message: string, suggestion?: string);
+}
+/** Error during export operations */
+declare class ExportError extends DeepMemoryError {
+    constructor(message: string, suggestion?: string);
+}
+/** Generic provider-level error */
+declare class ProviderError extends DeepMemoryError {
+    constructor(message: string, suggestion?: string);
+}
+
+/** A single validation error with optional suggestion */
+interface ValidationError {
+    field: string;
+    message: string;
+    suggestion?: string;
+}
+/** Result of a validation check */
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+
+interface VocabularyEngineConfig {
+    repositoryId: string;
+    storageProvider: StorageProvider;
+    governanceConfig: GovernanceConfig;
+    embeddingProvider?: EmbeddingProvider;
+    /** Similarity threshold for deduplication (default 0.85) */
+    deduplicationThreshold?: number;
+}
+declare class VocabularyEngine {
+    private readonly repositoryId;
+    private readonly storage;
+    private readonly governanceConfig;
+    private readonly deduplicator;
+    /** Cached vocabulary — invalidated on mutation */
+    private cachedVocabulary;
+    constructor(config: VocabularyEngineConfig);
+    /** Get the governance configuration for this repository */
+    getGovernanceConfig(): GovernanceConfig;
+    /** Get the current vocabulary from storage (cached) */
+    getVocabulary(): Promise<MemoryVocabulary>;
+    /** Get the resolved vocabulary with governance info */
+    getResolvedVocabulary(): Promise<ResolvedVocabulary>;
+    /** Invalidate the cached vocabulary (call after external mutations) */
+    invalidateCache(): void;
+    /** Validate an entity creation input against the vocabulary */
+    validateEntity(input: CreateEntityInput): Promise<ValidationResult>;
+    /** Validate an entity update input against the vocabulary */
+    validateEntityUpdate(input: UpdateEntityInput, entityType: string): Promise<ValidationResult>;
+    /** Validate a relationship creation input against the vocabulary */
+    validateRelationship(input: CreateRelationshipInput, sourceEntityType: string, targetEntityType: string): Promise<ValidationResult>;
+    /** Get an entity type definition from the vocabulary */
+    getEntityTypeDef(entityType: string): Promise<EntityTypeDefinition | null>;
+    /**
+     * Propose a vocabulary change (add, edit, or delete).
+     * Runs deduplication for add proposals, then governance rules.
+     * For delete proposals, cascades data deletion if approved.
+     */
+    proposeChange(proposal: VocabularyProposal, proposedBy: string): Promise<VocabularyProposalResult>;
+    /** @deprecated Use proposeChange instead */
+    proposeExtension(proposal: VocabularyProposal, proposedBy: string): Promise<VocabularyProposalResult>;
+    /** Cascade-delete all data for a deleted vocabulary type */
+    private cascadeDeleteData;
+    private getExistingTypesForProposal;
+    private getProposedTypeName;
+    private getProposedDescription;
+}
+
+/**
+ * Stamps provenance metadata on entities and relationships.
+ * The storage provider never needs to worry about provenance —
+ * it just stores what it receives from the tracker.
+ */
+declare class ProvenanceTracker {
+    private context;
+    constructor(context: ProvenanceContext);
+    /** Update the active provenance context (e.g., different conversation) */
+    updateContext(newContext: Partial<ProvenanceContext>): void;
+    /** Get the current provenance context */
+    getContext(): ProvenanceContext;
+    /** Stamp a newly created entity or relationship with full provenance */
+    stampCreate(): Provenance;
+    /** Stamp an updated entity or relationship — preserves creation fields, updates modified fields */
+    stampUpdate(existing: Provenance): Provenance;
+}
+
+/** Pre-mutation event types (those ending in "ing") */
+type PreMutationEvent = Extract<DeepMemoryEventType, 'entity:creating' | 'entity:updating' | 'entity:deleting' | 'relationship:creating' | 'relationship:removing'>;
+/** Hook handler that can cancel or modify operations */
+type HookHandler<T extends PreMutationEvent> = (event: DeepMemoryEvent<T>) => HookResult | Promise<HookResult>;
+declare class EventBus {
+    private handlers;
+    private hookHandlers;
+    private provenance;
+    private repositoryId?;
+    constructor(provenance: ProvenanceContext, repositoryId?: string);
+    /** Update provenance context (e.g., when conversation changes) */
+    updateProvenance(provenance: ProvenanceContext): void;
+    /** Subscribe to an event. Returns an unsubscribe function. */
+    on<E extends DeepMemoryEventType>(event: E, handler: EventHandler<E>): Unsubscribe;
+    /** Register a pre-mutation hook that can cancel operations */
+    onHook<E extends PreMutationEvent>(event: E, handler: HookHandler<E>): Unsubscribe;
+    /** Emit an event to all registered handlers */
+    emit<E extends DeepMemoryEventType>(event: E, payload: EventPayload<E>): Promise<void>;
+    /**
+     * Emit a pre-mutation hook event.
+     * Returns `{ cancelled: false }` if all hooks pass,
+     * or `{ cancelled: true, reason }` if any hook cancels.
+     */
+    emitHook<E extends PreMutationEvent>(event: E, payload: EventPayload<E>): Promise<{
+        cancelled: boolean;
+        reason?: string;
+    }>;
+    /** Remove all listeners and hooks */
+    removeAllListeners(): void;
+}
+
+interface MemoryRepositoryConfig {
+    repositoryId: string;
+    storage: StorageProvider;
+    search?: SearchProvider;
+    embedding?: EmbeddingProvider;
+    vocabularyEngine: VocabularyEngine;
+    provenanceTracker: ProvenanceTracker;
+    eventBus: EventBus;
+}
+declare class MemoryRepository {
+    readonly repositoryId: string;
+    private readonly storage;
+    private readonly search?;
+    private readonly vocabularyEngine;
+    private readonly provenanceTracker;
+    private readonly eventBus;
+    private readonly entityManager;
+    private readonly relationshipManager;
+    private readonly graphTraversal;
+    private readonly searchOrchestrator;
+    constructor(config: MemoryRepositoryConfig);
+    getVocabulary(): Promise<ResolvedVocabulary>;
+    proposeVocabularyChange(proposal: VocabularyProposal): Promise<VocabularyProposalResult>;
+    /** @deprecated Use proposeVocabularyChange instead */
+    proposeVocabularyExtension(proposal: VocabularyProposal): Promise<VocabularyProposalResult>;
+    createEntity(input: CreateEntityInput): Promise<Entity>;
+    updateEntity(entityId: string, updates: UpdateEntityInput): Promise<Entity>;
+    getEntity(entityId: string, detailLevel?: DetailLevel): Promise<Entity | EntitySummary | EntityBrief | null>;
+    getBySlug(slug: string, detailLevel?: DetailLevel): Promise<Entity | EntitySummary | EntityBrief | null>;
+    getEntities(entityIds: string[], detailLevel?: 'brief' | 'summary'): Promise<Map<string, EntitySummary | EntityBrief>>;
+    findEntities(query: FindEntitiesQuery): Promise<PaginatedResult<Entity | EntitySummary | EntityBrief>>;
+    deleteEntity(entityId: string): Promise<void>;
+    /** Re-embed specific entities using the current EmbeddingProvider */
+    reembedEntities(entityIds: string[]): Promise<ReembedResult>;
+    /**
+     * Re-embed all entities in the repository using the current EmbeddingProvider.
+     * Processes in batches with optional rate limiting. Emits reembed:* events for progress tracking.
+     * Updates repository metadata with the new model ID and dimensions on completion.
+     */
+    reembedAll(options?: {
+        batchSize?: number;
+        /** Max retries per batch on embedding failure (default 3) */
+        maxRetries?: number;
+        /** Abort after this many cumulative failures (default: no limit) */
+        errorThresholdToAbort?: number;
+        /** Milliseconds to wait between batches for rate limiting (default 0) */
+        delayBetweenBatchesMs?: number;
+    }): Promise<ReembedResult>;
+    createRelationship(input: CreateRelationshipInput): Promise<Relationship>;
+    removeRelationship(relationshipId: string): Promise<void>;
+    getRelationships(entityId: string, options?: {
+        relationshipTypes?: string[];
+        direction?: 'outbound' | 'inbound' | 'both';
+        limit?: number;
+        offset?: number;
+        propertyFilters?: PropertyFilter[];
+    }): Promise<PaginatedResult<Relationship>>;
+    getRelationshipSummary(entityId: string): Promise<RelationshipSummary>;
+    getRelationshipsForEntities(entityIds: string[]): Promise<Relationship[]>;
+    /** Get the full graph — entities with enriched relationships, vocabulary, and stats. Paginated. */
+    getGraph(options?: {
+        limit?: number;
+        offset?: number;
+        detailLevel?: DetailLevel;
+    }): Promise<GraphResult>;
+    exploreNeighbourhood(entityId: string, options?: ExploreOptions): Promise<Neighbourhood>;
+    findPaths(sourceId: string, targetId: string, options?: PathOptions): Promise<PathResult>;
+    searchByConcept(query: string, options?: ConceptSearchOptions): Promise<PaginatedResult<ScoredEntity>>;
+    getTimeline(entityId: string, options?: TimelineOptions): Promise<TimelineResult>;
+    getStats(): Promise<RepositoryStats>;
+    on<E extends DeepMemoryEventType>(event: E, handler: EventHandler<E>): Unsubscribe;
+    onHook<E extends Extract<DeepMemoryEventType, 'entity:creating' | 'entity:updating' | 'entity:deleting' | 'relationship:creating' | 'relationship:removing'>>(event: E, handler: HookHandler<E>): Unsubscribe;
+}
+
+/** Generate a v4 UUID without depending on node:crypto */
+declare function generateId(): string;
+/** Validate that a string is a valid UUID */
+declare function isValidUuid(value: string): boolean;
+/** Configuration for creating a DeepMemory instance */
+interface DeepMemoryConfig {
+    /** Required: the storage provider for persistence */
+    storage: StorageProvider;
+    /** Optional: search provider for full-text search */
+    search?: SearchProvider;
+    /** Optional: embedding provider for semantic search */
+    embedding?: EmbeddingProvider;
+    /** Optional: lock provider for distributed locking */
+    lock?: LockProvider;
+    /** Required: provenance context identifying the actor */
+    provenance: ProvenanceContext;
+}
+declare class DeepMemory {
+    private readonly storage;
+    private readonly search?;
+    private readonly embedding?;
+    /** Reserved for future distributed locking support */
+    readonly lock?: LockProvider;
+    private readonly provenance;
+    private readonly globalEventBus;
+    private initialised;
+    constructor(config: DeepMemoryConfig);
+    /** Initialise the storage provider (call once before use) */
+    private ensureInitialised;
+    /** Create or migrate the storage schema. Call once at deployment / startup, not per-request. */
+    ensureSchema(): Promise<void>;
+    private validateRepositoryId;
+    /** Create a new memory repository */
+    createRepository(config: RepositoryConfig): Promise<MemoryRepository>;
+    /** Open an existing repository */
+    openRepository(repositoryId: string): Promise<MemoryRepository>;
+    /** List all repositories */
+    listRepositories(filter?: RepositoryFilter): Promise<PaginatedResult<RepositorySummary>>;
+    /** Update repository metadata and settings */
+    updateRepository(repositoryId: string, updates: RepositoryUpdate): Promise<StoredRepository>;
+    /** Delete a repository */
+    deleteRepository(repositoryId: string): Promise<void>;
+    /** Export a repository to a portable archive */
+    exportRepository(repositoryId: string): Promise<ExportArchive>;
+    /** Import a repository from a portable archive */
+    importRepository(archive: ExportArchive, options: ImportOptions): Promise<ImportResult>;
+    /**
+     * Stream a repository export as an async generator.
+     * Yields: manifest → vocabulary → entity chunks → relationship chunks.
+     * Use for large repositories to avoid loading everything into memory.
+     */
+    exportRepositoryStream(repositoryId: string): AsyncGenerator<ExportStreamItem>;
+    /**
+     * Import a repository from a stream of chunks.
+     * Use for large repositories to avoid loading everything into memory.
+     */
+    importRepositoryStream(header: ImportStreamHeader, chunks: AsyncIterable<ImportChunk>, options: ImportOptions): Promise<ImportResult>;
+    /** Subscribe to global events */
+    on<E extends DeepMemoryEventType>(event: E, handler: EventHandler<E>): Unsubscribe;
+    /** Update the provenance context (e.g., new conversation) */
+    updateProvenance(context: Partial<ProvenanceContext>): void;
+    /** Dispose of all resources */
+    dispose(): Promise<void>;
+}
+
+/**
+ * Evaluate whether a set of properties matches all given filters.
+ * All filters are AND'd — every filter must match for the result to be true.
+ */
+declare function matchesPropertyFilters(properties: Record<string, unknown>, filters: PropertyFilter[]): boolean;
+
+declare class InMemoryStorageProvider implements StorageProvider {
+    private stores;
+    private getStore;
+    initialise(): Promise<void>;
+    dispose(): Promise<void>;
+    createRepository(config: StorageRepositoryConfig): Promise<StoredRepository>;
+    getRepository(repositoryId: string): Promise<StoredRepository | null>;
+    listRepositories(filter?: RepositoryFilter): Promise<PaginatedResult<StoredRepositorySummary>>;
+    updateRepository(repositoryId: string, updates: RepositoryUpdate): Promise<StoredRepository>;
+    deleteRepository(repositoryId: string): Promise<void>;
+    getRepositoryStats(repositoryId: string): Promise<RepositoryStats>;
+    getVocabulary(repositoryId: string): Promise<MemoryVocabulary>;
+    saveVocabulary(repositoryId: string, vocabulary: MemoryVocabulary): Promise<void>;
+    getVocabularyChangeLog(repositoryId: string, options?: PaginationOptions): Promise<PaginatedResult<VocabularyChangeRecord>>;
+    createEntity(repositoryId: string, entity: StoredEntity): Promise<StoredEntity>;
+    getEntity(repositoryId: string, entityId: string): Promise<StoredEntity | null>;
+    getEntityBySlug(repositoryId: string, slug: string): Promise<StoredEntity | null>;
+    getEntities(repositoryId: string, entityIds: string[]): Promise<Map<string, StoredEntity>>;
+    updateEntity(repositoryId: string, entityId: string, updates: StoredEntityUpdate): Promise<StoredEntity>;
+    deleteEntity(repositoryId: string, entityId: string): Promise<void>;
+    deleteEntitiesByType(repositoryId: string, entityType: string): Promise<{
+        deletedEntities: number;
+        deletedRelationships: number;
+    }>;
+    findEntities(repositoryId: string, query: StorageFindQuery): Promise<PaginatedResult<StoredEntity>>;
+    createRelationship(repositoryId: string, relationship: StoredRelationship): Promise<StoredRelationship>;
+    getRelationship(repositoryId: string, relationshipId: string): Promise<StoredRelationship | null>;
+    getEntityRelationships(repositoryId: string, entityId: string, options?: RelationshipQueryOptions): Promise<PaginatedResult<StoredRelationship>>;
+    deleteRelationship(repositoryId: string, relationshipId: string): Promise<void>;
+    deleteRelationshipsByType(repositoryId: string, relationshipType: string): Promise<{
+        deletedRelationships: number;
+    }>;
+    exploreNeighbourhood(repositoryId: string, entityId: string, options: StorageExploreOptions): Promise<StorageNeighbourhood>;
+    findPaths(repositoryId: string, sourceId: string, targetId: string, options: StoragePathOptions): Promise<StoragePathResult>;
+    getTimeline(repositoryId: string, entityId: string, options: StorageTimelineOptions): Promise<StorageTimelineResult>;
+    exportAll(repositoryId: string): AsyncIterable<ExportChunk>;
+    importBulk(repositoryId: string, data: ImportChunk[]): Promise<BulkImportResult>;
+}
+
+declare class InMemorySearchProvider implements SearchProvider {
+    private indices;
+    private getIndex;
+    indexEntity(repositoryId: string, entity: SearchableEntity): Promise<void>;
+    removeEntity(repositoryId: string, entityId: string): Promise<void>;
+    search(repositoryId: string, query: string, options?: SearchOptions): Promise<PaginatedResult<SearchHit>>;
+    reindexRepository(repositoryId: string, entities: AsyncIterable<SearchableEntity>): Promise<void>;
+}
+
+declare class NoOpEmbeddingProvider implements EmbeddingProvider {
+    embed(_text: string): Promise<number[]>;
+    embedBatch(_texts: string[]): Promise<number[][]>;
+    dimensions(): number;
+    modelId(): string;
+}
+
+export { BulkImportResult, ConceptSearchOptions, CreateEntityInput, CreateRelationshipInput, DeepMemory, type DeepMemoryConfig, DeepMemoryError, type DeepMemoryErrorCode, DeepMemoryEvent, DeepMemoryEventType, DetailLevel, DuplicateEntityError, DuplicateRelationshipError, DuplicateRepositoryError, EmbeddingProvider, EmbeddingProviderRequiredError, Entity, EntityBrief, EntityNotFoundError, EntitySummary, EntityTypeDefinition, EventHandler, EventPayload, ExploreOptions, ExportArchive, ExportChunk, ExportError, ExportStreamItem, FindEntitiesQuery, GovernanceConfig, GovernanceDeniedError, GraphResult, HookResult, ImportChunk, ImportError, ImportOptions, ImportResult, ImportStreamHeader, InMemorySearchProvider, InMemoryStorageProvider, InvalidInputError, LockProvider, MemoryRepository, MemoryVocabulary, Neighbourhood, NoOpEmbeddingProvider, OperationCancelledError, PaginatedResult, PaginationOptions, PathOptions, PathResult, PropertyFilter, Provenance, ProvenanceContext, ProviderError, ReembedResult, Relationship, RelationshipConstraintError, RelationshipNotFoundError, RelationshipQueryOptions, RelationshipSummary, RepositoryConfig, RepositoryFilter, RepositoryNotFoundError, RepositoryStats, RepositorySummary, RepositoryUpdate, ResolvedVocabulary, ScoredEntity, SearchHit, SearchOptions, SearchProvider, SearchableEntity, StorageExploreOptions, StorageFindQuery, StorageNeighbourhood, StoragePathOptions, StoragePathResult, StorageProvider, StorageRepositoryConfig, StorageTimelineOptions, StorageTimelineResult, StoredEntity, StoredEntityUpdate, StoredRelationship, StoredRepository, StoredRepositorySummary, TimelineOptions, TimelineResult, Unsubscribe, UpdateEntityInput, VocabularyChangeRecord, VocabularyProposal, VocabularyProposalResult, VocabularyValidationError, generateId, isValidUuid, matchesPropertyFilters };