@utaba/deep-memory 0.1.0

package/dist/portability-DdlNYXGX.d.cts

@@ -0,0 +1,897 @@
+/** Context provided by the consumer to identify who is performing operations */
+interface ProvenanceContext {
+    /** User or agent ID performing the operation */
+    actorId: string;
+    /** Whether the actor is a human user or an AI agent */
+    actorType: 'user' | 'agent';
+    /** Optional conversation ID — links memory to a conversation */
+    conversationId?: string;
+    /** Optional message ID — links memory to a specific message */
+    messageId?: string;
+}
+/** Full provenance record stored on every entity and relationship */
+interface Provenance {
+    createdBy: string;
+    createdByType: 'user' | 'agent';
+    createdAt: string;
+    createdInConversation?: string;
+    createdFromMessage?: string;
+    modifiedBy: string;
+    modifiedByType: 'user' | 'agent';
+    modifiedAt: string;
+    modifiedInConversation?: string;
+    modifiedFromMessage?: string;
+}
+
+/** Property type for vocabulary property schemas */
+type PropertyType = 'string' | 'number' | 'boolean' | 'date' | 'enum';
+/** Defines a property on an entity or relationship type */
+interface PropertySchema {
+    name: string;
+    type: PropertyType;
+    required: boolean;
+    description?: string;
+    /** Valid values when type === "enum" */
+    enumValues?: string[];
+    defaultValue?: unknown;
+}
+/** Definition of an entity type within a vocabulary */
+interface EntityTypeDefinition {
+    /** Type identifier, e.g., "clause", "part", "person" */
+    type: string;
+    /** Natural language description — critical for AI comprehension */
+    description: string;
+    /** Version of this type definition */
+    version: string;
+    /** Expected properties and their types */
+    properties: PropertySchema[];
+    createdAt: string;
+    createdBy: string;
+    modifiedAt: string;
+    modifiedBy: string;
+}
+/** Definition of a relationship type within a vocabulary */
+interface RelationshipTypeDefinition {
+    /** Type identifier, e.g., "requires_clause", "component_of" */
+    type: string;
+    /** Natural language description */
+    description: string;
+    /** Version of this type definition */
+    version: string;
+    /** Valid source entity types */
+    allowedSourceTypes: string[];
+    /** Valid target entity types */
+    allowedTargetTypes: string[];
+    /** Whether the relationship is symmetric */
+    bidirectional: boolean;
+    /** Optional edge properties */
+    properties?: PropertySchema[];
+    createdAt: string;
+    createdBy: string;
+    modifiedAt: string;
+    modifiedBy: string;
+}
+/** The vocabulary schema of a memory repository */
+interface MemoryVocabulary {
+    /** Semantic version of the vocabulary */
+    version: string;
+    /** ISO timestamp of last modification */
+    lastModified: string;
+    /** User or system that last modified the vocabulary */
+    modifiedBy: string;
+    entityTypes: EntityTypeDefinition[];
+    relationshipTypes: RelationshipTypeDefinition[];
+}
+/** Vocabulary governance mode — controls how the vocabulary can evolve */
+type GovernanceMode = 'locked' | 'managed' | 'open';
+/** Governance configuration for a repository */
+interface GovernanceConfig {
+    mode: GovernanceMode;
+    /** Managed mode: similarity score below which proposals auto-approve (default 0.3) */
+    autoApproveThreshold?: number;
+    /** Managed mode: if true, all proposals queue for human approval regardless of checks */
+    requireApproval?: boolean;
+    /** Open mode: whether deduplication is still enforced (default true) */
+    deduplicationEnabled?: boolean;
+    /** Default similarity threshold for semantic search (0.0-1.0, default 0.5). Model-dependent — lower for local models, higher for OpenAI. */
+    defaultSimilarityThreshold?: number;
+}
+/** Proposal to change the vocabulary — add, edit, or delete a type */
+interface VocabularyProposal {
+    proposalType: 'entity_type' | 'relationship_type' | 'edit_entity_type' | 'edit_relationship_type' | 'delete_entity_type' | 'delete_relationship_type';
+    /** Used when proposalType is 'entity_type' (add new) */
+    entityType?: {
+        type: string;
+        description: string;
+        properties?: PropertySchema[];
+    };
+    /** Used when proposalType is 'relationship_type' (add new) */
+    relationshipType?: {
+        type: string;
+        description: string;
+        allowedSourceTypes: string[];
+        allowedTargetTypes: string[];
+        bidirectional?: boolean;
+        properties?: PropertySchema[];
+    };
+    /** Used when proposalType is 'edit_entity_type' */
+    editEntityType?: {
+        type: string;
+        description?: string;
+        addProperties?: PropertySchema[];
+        removeProperties?: string[];
+        updateProperties?: PropertySchema[];
+    };
+    /** Used when proposalType is 'edit_relationship_type' */
+    editRelationshipType?: {
+        type: string;
+        description?: string;
+        allowedSourceTypes?: string[];
+        allowedTargetTypes?: string[];
+        bidirectional?: boolean;
+        addProperties?: PropertySchema[];
+        removeProperties?: string[];
+        updateProperties?: PropertySchema[];
+    };
+    /** Used when proposalType is 'delete_entity_type' */
+    deleteEntityType?: {
+        type: string;
+    };
+    /** Used when proposalType is 'delete_relationship_type' */
+    deleteRelationshipType?: {
+        type: string;
+    };
+    /** Why this change is needed */
+    justification: string;
+}
+/** Result of a vocabulary change proposal */
+interface VocabularyProposalResult {
+    status: 'approved' | 'pending_approval' | 'rejected';
+    proposalId?: string;
+    /** The type name that was proposed */
+    type: string;
+    /** New vocabulary version if approved */
+    vocabularyVersion?: string;
+    /** Reason for rejection */
+    reason?: string;
+    /** Similar existing types if rejected as duplicate */
+    duplicates?: Array<{
+        type: string;
+        description: string;
+        similarity: number;
+    }>;
+    /** Number of entities cascade-deleted (delete_entity_type only) */
+    cascadedEntities?: number;
+    /** Number of relationships cascade-deleted (delete operations) */
+    cascadedRelationships?: number;
+}
+/** Record of a vocabulary change for auditing */
+interface VocabularyChangeRecord {
+    changeId: string;
+    changeType: 'entity_type_added' | 'relationship_type_added' | 'entity_type_modified' | 'relationship_type_modified' | 'entity_type_removed' | 'relationship_type_removed';
+    typeName: string;
+    previousVersion?: string;
+    newVersion: string;
+    proposedBy: string;
+    proposedAt: string;
+    approvedBy?: string;
+    approvedAt?: string;
+    reason: string;
+}
+/** Vocabulary with resolved governance info and stats */
+interface ResolvedVocabulary {
+    vocabulary: MemoryVocabulary;
+    governanceMode: GovernanceMode;
+    governanceConfig: GovernanceConfig;
+}
+/** Input for creating entity type definitions (without system-managed fields) */
+interface EntityTypeInput {
+    type: string;
+    description: string;
+    properties?: PropertySchema[];
+}
+/** Input for creating relationship type definitions (without system-managed fields) */
+interface RelationshipTypeInput {
+    type: string;
+    description: string;
+    allowedSourceTypes: string[];
+    allowedTargetTypes: string[];
+    bidirectional?: boolean;
+    properties?: PropertySchema[];
+}
+/** Input vocabulary definition used when creating a repository */
+interface VocabularyInput {
+    entityTypes?: EntityTypeInput[];
+    relationshipTypes?: RelationshipTypeInput[];
+}
+
+/** Detail level for entity retrieval */
+type DetailLevel = 'brief' | 'summary' | 'full';
+/** Full entity representation (returned at "full" detail level) */
+interface Entity {
+    id: string;
+    slug: string;
+    entityType: string;
+    label: string;
+    summary?: string;
+    properties: Record<string, unknown>;
+    /** Raw content/data of the entity — only at "full" detail level */
+    data?: string;
+    /** Format of the data field, e.g., "text/plain", "text/markdown" */
+    dataFormat?: string;
+    provenance: Provenance;
+}
+/** Entity at "summary" detail level — properties but no raw data */
+interface EntitySummary {
+    id: string;
+    slug: string;
+    entityType: string;
+    label: string;
+    summary?: string;
+    properties: Record<string, unknown>;
+}
+/** Entity at "brief" detail level — minimal info for lists */
+interface EntityBrief {
+    id: string;
+    slug: string;
+    entityType: string;
+    label: string;
+    summary?: string;
+}
+/** Input for creating a new entity */
+interface CreateEntityInput {
+    /** Explicit GUID — auto-generated if omitted */
+    id?: string;
+    /** Must exist in the repository's vocabulary */
+    entityType: string;
+    label: string;
+    summary?: string;
+    /** Must conform to the vocabulary's property schema */
+    properties?: Record<string, unknown>;
+    /** Raw content/data */
+    data?: string;
+    /** Format of the data field */
+    dataFormat?: string;
+}
+/** Input for updating an existing entity */
+interface UpdateEntityInput {
+    label?: string;
+    summary?: string;
+    /** Merged with existing properties */
+    properties?: Record<string, unknown>;
+    data?: string;
+    dataFormat?: string;
+    /** Force regeneration of the embedding vector (e.g. after switching embedding models) */
+    reembed?: boolean;
+}
+/** Internal stored representation — includes provenance and embeddings */
+interface StoredEntity {
+    id: string;
+    slug: string;
+    entityType: string;
+    label: string;
+    summary?: string;
+    properties: Record<string, unknown>;
+    data?: string;
+    dataFormat?: string;
+    provenance: Provenance;
+    /** Vector embedding of the entity (label + summary + properties) */
+    embedding?: number[];
+}
+/** Internal update representation for the storage provider */
+interface StoredEntityUpdate {
+    label?: string;
+    slug?: string;
+    summary?: string;
+    properties?: Record<string, unknown>;
+    data?: string;
+    dataFormat?: string;
+    provenance: Provenance;
+    embedding?: number[];
+}
+/** Options for getEntity */
+interface GetEntityOptions {
+    detailLevel?: DetailLevel;
+}
+/** Options for getEntities (batch) */
+interface GetEntitiesOptions {
+    /** Only "brief" or "summary" for batch retrieval */
+    detailLevel?: 'brief' | 'summary';
+}
+
+/** Pagination options used across all paginated queries */
+interface PaginationOptions {
+    /** Maximum number of results (default 10, max 50) */
+    limit?: number;
+    /** Pagination offset */
+    offset?: number;
+}
+/** Query for finding entities by label, type, and property filters */
+interface FindEntitiesQuery extends PaginationOptions {
+    /** Search term to match against entity labels */
+    searchTerm?: string;
+    /** Filter by entity type(s) */
+    entityTypes?: string[];
+    /** Filter by property values */
+    properties?: Record<string, unknown>;
+    /** Detail level for returned entities (default: summary) */
+    detailLevel?: DetailLevel;
+    /** Filter by provenance metadata */
+    provenance?: ProvenanceFilter;
+}
+/** Options for neighbourhood exploration */
+interface ExploreOptions {
+    /** Exploration depth: 1, 2, or 3 (default 1) */
+    depth?: 1 | 2 | 3;
+    /** Filter by relationship type(s) */
+    relationshipTypes?: string[];
+    /** Filter result entity types */
+    entityTypes?: string[];
+    /** Direction filter */
+    direction?: RelationshipDirection;
+    /** Max results per relationship type (default 10) */
+    limitPerType?: number;
+    /** Pagination offset per relationship type */
+    offsetPerType?: number;
+    /** Detail level for returned entities (default: summary) */
+    detailLevel?: DetailLevel;
+    /** Filter relationships by property values (all filters are AND'd) */
+    relationshipPropertyFilters?: PropertyFilter[];
+}
+/** Options for path finding between two entities */
+interface PathOptions {
+    /** Maximum path depth (default 3, max 5) */
+    maxDepth?: number;
+    /** Filter allowed relationship types */
+    relationshipTypes?: string[];
+    /** Filter entities in paths by type(s) — only paths through matching entity types are returned */
+    entityTypes?: string[];
+    /** Maximum number of paths to return (default 5) */
+    limit?: number;
+    /** Pagination offset */
+    offset?: number;
+    /** Detail level for returned entities (default: brief) */
+    detailLevel?: DetailLevel;
+    /** Filter relationships in paths by property values (all filters are AND'd) */
+    relationshipPropertyFilters?: PropertyFilter[];
+}
+/** Options for semantic/vector similarity search */
+interface ConceptSearchOptions extends PaginationOptions {
+    /** Minimum similarity threshold (0.0–1.0, default 0.7) */
+    similarityThreshold?: number;
+    /** Filter by entity type(s) */
+    entityTypes?: string[];
+    /** Detail level for returned entities (default: summary) */
+    detailLevel?: DetailLevel;
+}
+/** Options for timeline queries */
+interface TimelineOptions extends PaginationOptions {
+    /** Date range filter */
+    timeRange?: {
+        from: string;
+        to: string;
+    };
+    /** Filter by event types */
+    eventTypes?: string[];
+    /** Filter by provenance metadata */
+    provenance?: ProvenanceFilter;
+}
+/** Filter by provenance metadata (conversation, actor, date range) */
+interface ProvenanceFilter {
+    /** Filter to entities created/modified in these conversations */
+    conversationIds?: string[];
+    /** Filter to entities created/modified by these actors */
+    actors?: string[];
+    /** Filter to entities created/modified within this date range */
+    dateRange?: {
+        from: string;
+        to: string;
+    };
+}
+/** Filter on a relationship property value */
+interface PropertyFilter {
+    /** Property name on the relationship */
+    key: string;
+    /** Filter operator */
+    operator: 'eq' | 'neq' | 'isNull' | 'isNotNull' | 'gt' | 'lt' | 'gte' | 'lte' | 'contains';
+    /** Value to compare (not needed for isNull/isNotNull) */
+    value?: unknown;
+}
+/** Storage-level find query */
+interface StorageFindQuery {
+    searchTerm?: string;
+    entityTypes?: string[];
+    properties?: Record<string, unknown>;
+    provenance?: ProvenanceFilter;
+    limit: number;
+    offset: number;
+}
+/** Storage-level explore options */
+interface StorageExploreOptions {
+    depth: number;
+    relationshipTypes?: string[];
+    entityTypes?: string[];
+    direction: RelationshipDirection;
+    limitPerType: number;
+    offsetPerType: number;
+    relationshipPropertyFilters?: PropertyFilter[];
+}
+/** Storage-level path finding options */
+interface StoragePathOptions {
+    maxDepth: number;
+    relationshipTypes?: string[];
+    entityTypes?: string[];
+    limit: number;
+    offset: number;
+    relationshipPropertyFilters?: PropertyFilter[];
+}
+/** Storage-level timeline options */
+interface StorageTimelineOptions {
+    timeRange?: {
+        from: string;
+        to: string;
+    };
+    eventTypes?: string[];
+    provenance?: ProvenanceFilter;
+    limit: number;
+    offset: number;
+}
+/** Options for full-text search (SearchProvider) */
+interface SearchOptions extends PaginationOptions {
+    /** Filter by entity type(s) */
+    entityTypes?: string[];
+}
+
+/** Direction filter for relationship queries */
+type RelationshipDirection = 'outbound' | 'inbound' | 'both';
+/** Public relationship representation */
+interface Relationship {
+    id: string;
+    relationshipType: string;
+    sourceEntityId: string;
+    targetEntityId: string;
+    properties: Record<string, unknown>;
+    bidirectional: boolean;
+    provenance: Provenance;
+}
+/** Input for creating a new relationship */
+interface CreateRelationshipInput {
+    /** Explicit GUID — auto-generated if omitted */
+    id?: string;
+    /** Must exist in the repository's vocabulary */
+    relationshipType: string;
+    /** Must match allowedSourceTypes (GUID or slug) */
+    sourceEntityId: string;
+    /** Must match allowedTargetTypes (GUID or slug) */
+    targetEntityId: string;
+    /** Must conform to the relationship type's property schema */
+    properties?: Record<string, unknown>;
+}
+/** Internal stored representation */
+interface StoredRelationship {
+    id: string;
+    relationshipType: string;
+    sourceEntityId: string;
+    targetEntityId: string;
+    properties: Record<string, unknown>;
+    bidirectional: boolean;
+    provenance: Provenance;
+}
+/** Relationship with human-readable source/target info */
+interface EnrichedRelationship {
+    id: string;
+    relationshipType: string;
+    sourceEntityId: string;
+    sourceSlug: string;
+    sourceLabel: string;
+    targetEntityId: string;
+    targetSlug: string;
+    targetLabel: string;
+    properties: Record<string, unknown>;
+    bidirectional: boolean;
+    provenance: Provenance;
+}
+/** Aggregated relationship counts by type and direction */
+interface RelationshipSummary {
+    outbound: Record<string, number>;
+    inbound: Record<string, number>;
+}
+/** Options for querying relationships of an entity */
+interface RelationshipQueryOptions {
+    /** Filter by relationship type(s) */
+    relationshipTypes?: string[];
+    /** Filter by direction relative to the entity */
+    direction?: RelationshipDirection;
+    /** Maximum number of results */
+    limit?: number;
+    /** Pagination offset */
+    offset?: number;
+    /** Filter by relationship property values (all filters are AND'd) */
+    propertyFilters?: PropertyFilter[];
+}
+
+/** Extensible metadata bag persisted as a single JSON column */
+interface RepositoryMetadata {
+    /** Embedding model identifier (e.g. "Qwen/Qwen3-Embedding-8B") */
+    embeddingModelId?: string;
+    /** Dimensionality of embedding vectors */
+    embeddingDimensions?: number;
+    /** Arbitrary additional properties */
+    [key: string]: unknown;
+}
+/** Configuration for creating a new repository */
+interface RepositoryConfig {
+    /** Optional: if omitted a GUID is generated automatically */
+    repositoryId?: string;
+    type?: string;
+    label: string;
+    description?: string;
+    /** Legal terms, licence, or compliance notes (stored but excluded from list queries) */
+    legal?: string;
+    /** Repository owner identifier (stored but excluded from list queries) */
+    owner?: string;
+    /** Initial vocabulary definition */
+    vocabulary?: VocabularyInput;
+    /** Governance configuration */
+    governance?: GovernanceConfig;
+    /** Extensible metadata — embedding model info, custom fields, etc. */
+    metadata?: RepositoryMetadata;
+}
+/** Summary of a repository for listing */
+interface RepositorySummary {
+    repositoryId: string;
+    type?: string;
+    label: string;
+    description?: string;
+    governanceMode: GovernanceMode;
+    stats?: RepositoryStats;
+}
+/** Repository statistics */
+interface RepositoryStats {
+    entityCount: number;
+    relationshipCount: number;
+    vocabularyVersion: string;
+    entityTypeBreakdown: Record<string, number>;
+    relationshipTypeBreakdown: Record<string, number>;
+}
+/** Internal stored representation of a repository */
+interface StoredRepository {
+    repositoryId: string;
+    type?: string;
+    label: string;
+    description?: string;
+    /** Legal terms, licence, or compliance notes */
+    legal?: string;
+    /** Repository owner identifier */
+    owner?: string;
+    governanceConfig: GovernanceConfig;
+    /** Extensible metadata bag (embedding model info, custom fields, etc.) */
+    metadata?: RepositoryMetadata;
+    createdAt: string;
+    createdBy: string;
+}
+/** Internal stored summary for listing */
+interface StoredRepositorySummary {
+    repositoryId: string;
+    type?: string;
+    label: string;
+    description?: string;
+    governanceConfig: GovernanceConfig;
+}
+/** Fields that can be updated on an existing repository */
+interface RepositoryUpdate {
+    label?: string;
+    description?: string;
+    type?: string;
+    legal?: string;
+    owner?: string;
+    governanceConfig?: GovernanceConfig;
+    /** Metadata updates — merged with existing metadata (shallow merge) */
+    metadata?: RepositoryMetadata;
+}
+/** Filter for listing repositories */
+interface RepositoryFilter {
+    /** Filter by repository type */
+    type?: string;
+    /** Include statistics */
+    includeStats?: boolean;
+    /** Maximum number of results (default 20) */
+    limit?: number;
+    /** Pagination offset */
+    offset?: number;
+}
+/** Configuration passed to the storage provider for repository creation */
+interface StorageRepositoryConfig {
+    repositoryId: string;
+    type?: string;
+    label: string;
+    description?: string;
+    /** Legal terms, licence, or compliance notes */
+    legal?: string;
+    /** Repository owner identifier */
+    owner?: string;
+    governanceConfig: GovernanceConfig;
+    /** Extensible metadata bag */
+    metadata?: RepositoryMetadata;
+    createdAt: string;
+    createdBy: string;
+}
+
+/** Paginated result wrapper */
+interface PaginatedResult<T> {
+    items: T[];
+    total: number;
+    hasMore: boolean;
+    limit: number;
+    offset: number;
+}
+/** Centre entity in a neighbourhood exploration */
+interface NeighbourhoodCentre {
+    id: string;
+    slug: string;
+    entityType: string;
+    label: string;
+}
+/** A group of entities connected by a specific relationship type */
+interface NeighbourhoodGroup {
+    total: number;
+    returned: number;
+    entities: Array<Entity | EntitySummary | EntityBrief>;
+}
+/** A layer of connected entities at a specific depth */
+interface NeighbourhoodLayer {
+    /** Keyed by relationship type */
+    [relationshipType: string]: NeighbourhoodGroup;
+}
+/** Result of neighbourhood exploration */
+interface Neighbourhood {
+    centre: NeighbourhoodCentre;
+    layers: NeighbourhoodLayer[];
+    statistics: {
+        totalEntities: number;
+        returnedEntities: number;
+        truncatedTypes: string[];
+    };
+}
+/** A single path between two entities */
+interface Path {
+    length: number;
+    entities: Array<Entity | EntitySummary | EntityBrief>;
+    relationships: Array<{
+        id: string;
+        type: string;
+        direction: string;
+        properties: Record<string, unknown>;
+    }>;
+}
+/** Result of path finding */
+interface PathResult {
+    totalPaths: number;
+    returned: number;
+    paths: Path[];
+}
+/** Entity with a relevance/similarity score */
+interface ScoredEntity {
+    id: string;
+    slug: string;
+    entityType: string;
+    label: string;
+    summary?: string;
+    score: number;
+}
+/** A related entity reference with human-readable info */
+interface TimelineEntityRef {
+    id: string;
+    slug: string;
+    label: string;
+}
+/** Relationship detail included in relationship timeline events */
+interface TimelineRelationshipDetail {
+    id: string;
+    relationshipType: string;
+    sourceEntity: TimelineEntityRef;
+    targetEntity: TimelineEntityRef;
+}
+/** A single timeline event */
+interface TimelineEvent {
+    timestamp: string;
+    eventType: string;
+    description: string;
+    relatedEntities: TimelineEntityRef[];
+    relationship?: TimelineRelationshipDetail;
+}
+/** Result of a timeline query */
+interface TimelineResult {
+    id: string;
+    slug: string;
+    totalEvents: number;
+    returned: number;
+    events: TimelineEvent[];
+}
+/** Result of a getGraph query — paginated entities with enriched relationships */
+interface GraphResult {
+    vocabulary: ResolvedVocabulary;
+    stats: RepositoryStats;
+    entities: Array<Entity | EntitySummary | EntityBrief>;
+    relationships: EnrichedRelationship[];
+    /** Total relationship count for this page (before truncation) */
+    totalRelationships: number;
+    /** Whether the relationships were truncated due to the max limit */
+    relationshipsTruncated: boolean;
+    hasMore: boolean;
+    cursor?: string;
+}
+/** Map of entity ID → Entity (for batch retrieval) */
+type EntityMap = Map<string, EntitySummary>;
+/** Storage-level neighbourhood (uses StoredEntity) */
+interface StorageNeighbourhoodGroup {
+    total: number;
+    entities: StoredEntity[];
+    relationships: StoredRelationship[];
+}
+interface StorageNeighbourhoodLayer {
+    [relationshipType: string]: StorageNeighbourhoodGroup;
+}
+interface StorageNeighbourhood {
+    centreId: string;
+    layers: StorageNeighbourhoodLayer[];
+}
+/** Storage-level path result */
+interface StoragePath {
+    entityIds: string[];
+    relationshipIds: string[];
+}
+interface StoragePathResult {
+    paths: StoragePath[];
+    totalPaths: number;
+}
+/** Storage-level timeline result */
+interface StorageTimelineEvent {
+    timestamp: string;
+    eventType: string;
+    entityId: string;
+    relationshipId?: string;
+}
+interface StorageTimelineResult {
+    events: StorageTimelineEvent[];
+    total: number;
+}
+/** Search hit from a SearchProvider */
+interface SearchHit {
+    id: string;
+    score: number;
+    highlights?: Record<string, string[]>;
+}
+/** Result of a bulk import operation */
+interface BulkImportResult {
+    entitiesImported: number;
+    relationshipsImported: number;
+    errors: Array<{
+        item: string;
+        error: string;
+    }>;
+}
+/** Result of a re-embedding operation */
+interface ReembedResult {
+    processed: number;
+    failed: number;
+    errors: Array<{
+        entityId: string;
+        error: string;
+    }>;
+    modelId: string;
+    dimensions: number;
+}
+
+/** Manifest describing an exported repository archive */
+interface ExportManifest {
+    /** Archive format version — for forward compatibility */
+    formatVersion: '1.0.0';
+    /** @utaba/deep-memory version that created this export */
+    libraryVersion: string;
+    /** ISO 8601 timestamp */
+    exportedAt: string;
+    exportedBy: ProvenanceContext;
+    repository: {
+        repositoryId: string;
+        type?: string;
+        label: string;
+        description?: string;
+        vocabularyVersion: string;
+        governanceMode: GovernanceMode;
+    };
+    statistics: {
+        entityCount: number;
+        relationshipCount: number;
+        entityTypeBreakdown: Record<string, number>;
+        relationshipTypeBreakdown: Record<string, number>;
+    };
+    /** Embedding metadata — critical for portability */
+    embedding?: {
+        modelId: string;
+        dimensions: number;
+        note: string;
+    };
+}
+/** A complete repository export archive */
+interface ExportArchive {
+    manifest: ExportManifest;
+    vocabulary: MemoryVocabulary;
+    entities: StoredEntity[];
+    relationships: StoredRelationship[];
+}
+/** A chunk of exported data (for streaming) */
+interface ExportChunk {
+    type: 'entities' | 'relationships';
+    data: StoredEntity[] | StoredRelationship[];
+    sequence: number;
+    isLast: boolean;
+}
+/** Items yielded by the streaming export */
+type ExportStreamItem = {
+    type: 'manifest';
+    data: ExportManifest;
+} | {
+    type: 'vocabulary';
+    data: MemoryVocabulary;
+} | {
+    type: 'entities';
+    data: StoredEntity[];
+    sequence: number;
+    isLast: boolean;
+} | {
+    type: 'relationships';
+    data: StoredRelationship[];
+    sequence: number;
+    isLast: boolean;
+};
+/** Options for importing a repository archive */
+interface ImportOptions {
+    /** How to handle the target repository */
+    target: {
+        mode: 'create';
+        repositoryId: string;
+        config: RepositoryConfig;
+    } | {
+        mode: 'merge';
+        repositoryId: string;
+    };
+    /** How to handle vocabulary differences (only for "merge" mode) */
+    vocabularyConflict?: 'reject' | 'extend' | 'prompt';
+    /** How to handle entity ID collisions (only for "merge" mode) */
+    entityConflict?: 'skip' | 'overwrite' | 'rename';
+    /** Whether to re-generate embeddings using the current EmbeddingProvider */
+    reEmbed?: boolean;
+}
+/** A chunk of data for bulk import */
+interface ImportChunk {
+    entities?: StoredEntity[];
+    relationships?: StoredRelationship[];
+}
+/** Header for streaming import — sent before data chunks */
+interface ImportStreamHeader {
+    manifest: ExportManifest;
+    vocabulary: MemoryVocabulary;
+}
+/** Warning generated during import */
+interface ImportWarning {
+    code: string;
+    message: string;
+    id?: string;
+    relationshipId?: string;
+}
+/** Result of an import operation */
+interface ImportResult {
+    success: boolean;
+    repositoryId: string;
+    statistics: {
+        entitiesImported: number;
+        entitiesSkipped: number;
+        relationshipsImported: number;
+        relationshipsSkipped: number;
+        vocabularyExtensions: number;
+    };
+    warnings: ImportWarning[];
+}
+
+export type { RepositorySummary as $, ReembedResult as A, BulkImportResult as B, CreateEntityInput as C, DetailLevel as D, ExportChunk as E, FindEntitiesQuery as F, GovernanceConfig as G, Relationship as H, ImportChunk as I, PropertyFilter as J, RelationshipSummary as K, GraphResult as L, MemoryVocabulary as M, ExploreOptions as N, Neighbourhood as O, PaginatedResult as P, PathOptions as Q, RepositoryFilter as R, StorageRepositoryConfig as S, PathResult as T, UpdateEntityInput as U, VocabularyChangeRecord as V, ConceptSearchOptions as W, ScoredEntity as X, TimelineOptions as Y, TimelineResult as Z, RepositoryConfig as _, StoredRepository as a, ExportArchive as a0, ImportOptions as a1, ImportResult as a2, ExportStreamItem as a3, ImportStreamHeader as a4, SearchOptions as a5, SearchHit as a6, EnrichedRelationship as a7, EntityMap as a8, EntityTypeInput as a9, ExportManifest as aa, GetEntitiesOptions as ab, GetEntityOptions as ac, GovernanceMode as ad, ImportWarning as ae, NeighbourhoodCentre as af, NeighbourhoodGroup as ag, NeighbourhoodLayer as ah, Path as ai, PropertySchema as aj, PropertyType as ak, ProvenanceFilter as al, RelationshipDirection as am, RelationshipTypeDefinition as an, RelationshipTypeInput as ao, RepositoryMetadata as ap, StorageNeighbourhoodGroup as aq, StorageNeighbourhoodLayer as ar, StoragePath as as, StorageTimelineEvent as at, TimelineEntityRef as au, TimelineEvent as av, TimelineRelationshipDetail as aw, VocabularyInput as ax, StoredRepositorySummary as b, RepositoryUpdate as c, RepositoryStats as d, PaginationOptions as e, StoredEntity as f, StoredEntityUpdate as g, StorageFindQuery as h, StoredRelationship as i, RelationshipQueryOptions as j, StorageExploreOptions as k, StorageNeighbourhood as l, StoragePathOptions as m, StoragePathResult as n, StorageTimelineOptions as o, StorageTimelineResult as p, ResolvedVocabulary as q, CreateRelationshipInput as r, EntityTypeDefinition as s, VocabularyProposal as t, VocabularyProposalResult as u, ProvenanceContext as v, Provenance as w, Entity as x, EntitySummary as y, EntityBrief as z };