aimeat 1.2.0

package/dist/src/storage/providers/mongodb/index.d.ts

@@ -0,0 +1,608 @@
+/**
+ * MongoDB Storage Implementation using Prisma Client.
+ *
+ * To use:
+ *   1. pnpm add @prisma/client prisma
+ *   2. npx prisma generate
+ *   3. Set DATABASE_URL environment variable
+ *   4. Start with: aimeat --db mongodb://localhost:27017/aimeat
+ */
+import type { Storage, OwnerRecord, AgentRecord, MemoryRecord, ActionRecord, WorkRecord, WalletTransaction, BoardRecord, BoardPostRecord, OtkRecord, DisputeRecord, DisputeAuditEntry, MicroMemoryRecord, StorageFileRecord, PeeringRequestRecord, ChunkedUploadRecord, GHIIRecord, ChatInstanceRecord, PersonalNodeRecord, MailboxItemRecord, SchemaRecord, ConsentRecord, ConsentAuditEntry, CsmRecord, MsmRecord, EmailVerificationRecord, PushSubscriptionRecord, TrustedIssuerRecord, SiteChangeLogEntry, ExtensionRecord, EscrowHoldRecord, CortexExtensionRecord, PersonalPushSubscriptionRecord, NotificationPreferences, AppRecord, AppListOptions, AppPurchaseRecord, NotificationTemplateRecord, MemoryLinkRecord, OperatorReviewRecord, ScheduledJobRecord, ExtensionInstanceRecord, ReplicationQueueEntry, DeviceAuthorizationRecord, OAuthClientRecord, OAuthRefreshTokenRecord, OAuthApprovalRecord, SystemPromptRecord, SystemPromptVersionRecord, ExecutionLogEntry, PackageRecord, PackageFilter, TemplateListingRecord, TemplateReview, TemplateDiscussion, TemplateFilter, PackageInstanceRecord, InstanceFilter } from '../../interface.js';
+export declare class MongoStorage implements Storage {
+    private prisma;
+    private chunkedUploads;
+    readonly ready: Promise<void>;
+    constructor(databaseUrl: string);
+    private init;
+    private ensureReady;
+    createOwner(owner: OwnerRecord): Promise<OwnerRecord>;
+    getOwner(name: string): Promise<OwnerRecord | null>;
+    listOwners(): Promise<OwnerRecord[]>;
+    updateOwner(name: string, updates: Partial<OwnerRecord>): Promise<OwnerRecord | null>;
+    deleteOwner(name: string): Promise<boolean>;
+    createAgent(agent: AgentRecord): Promise<AgentRecord>;
+    getAgent(gaii: string): Promise<AgentRecord | null>;
+    getAgentsByOwner(owner: string): Promise<AgentRecord[]>;
+    updateAgent(gaii: string, updates: Partial<AgentRecord>): Promise<AgentRecord | null>;
+    deleteAgent(gaii: string): Promise<boolean>;
+    /**
+     * Cascade-delete all data associated with a single agent GAII.
+     * Called by both deleteOwner and deleteAgent.
+     */
+    private cascadeDeleteAgentData;
+    listAgents(): Promise<AgentRecord[]>;
+    /**
+     * Resolve any identity (GAII, GHII, bare owner) to the owner's GHII identifier.
+     * All balance operations go through GHII — agents don't have their own balance.
+     */
+    private resolveGhii;
+    debitBalance(gaii: string, amount: number): Promise<boolean>;
+    creditBalance(gaii: string, amount: number): Promise<boolean>;
+    creditBalanceCapped(gaii: string, amount: number, cap: number): Promise<number>;
+    transferBalance(fromGaii: string, toGaii: string, amount: number): Promise<boolean>;
+    setMemory(record: MemoryRecord): Promise<MemoryRecord>;
+    setMemoryIfVersion(record: MemoryRecord, expectedVersion: number): Promise<MemoryRecord | null>;
+    getMemory(ownerGaii: string, key: string): Promise<MemoryRecord | null>;
+    listMemory(ownerGaii: string, opts?: {
+        prefix?: string;
+        visibility?: string;
+        tags?: string[];
+        maxFlags?: number;
+    }): Promise<MemoryRecord[]>;
+    listAllMemory(opts?: {
+        prefix?: string;
+        ownerPrefix?: string;
+        visibility?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        items: MemoryRecord[];
+        total: number;
+    }>;
+    deleteMemory(ownerGaii: string, key: string): Promise<boolean>;
+    deleteAllMemory(ownerGaii: string): Promise<number>;
+    incrementMemoryFlagCount(ownerGaii: string, key: string): Promise<void>;
+    searchMemory(ownerGaii: string, query: string, opts?: {
+        visibility?: string;
+        maxFlags?: number;
+    }): Promise<MemoryRecord[]>;
+    createAction(action: ActionRecord): Promise<ActionRecord>;
+    getAction(id: string, providerGaii: string): Promise<ActionRecord | null>;
+    listActions(opts?: {
+        search?: string;
+        category?: string;
+    }): Promise<ActionRecord[]>;
+    deleteAction(id: string, providerGaii: string): Promise<boolean>;
+    deleteActionsByProvider(gaii: string): Promise<number>;
+    listActionsByProvider(gaii: string): Promise<ActionRecord[]>;
+    updateAction(id: string, providerGaii: string, updates: Partial<ActionRecord>): Promise<ActionRecord | null>;
+    createWork(work: WorkRecord): Promise<WorkRecord>;
+    getWork(trackingCode: string): Promise<WorkRecord | null>;
+    updateWork(trackingCode: string, updates: Partial<WorkRecord>): Promise<WorkRecord | null>;
+    listWorkByProvider(gaii: string): Promise<WorkRecord[]>;
+    listWorkByRequester(gaii: string): Promise<WorkRecord[]>;
+    listAllWork(limit?: number): Promise<WorkRecord[]>;
+    addTransaction(tx: WalletTransaction): Promise<WalletTransaction>;
+    getTransactions(gaii: string, limit?: number): Promise<WalletTransaction[]>;
+    listAllTransactions(limit?: number): Promise<WalletTransaction[]>;
+    deleteTransactions(gaii: string): Promise<number>;
+    createBoard(board: BoardRecord): Promise<BoardRecord>;
+    getBoard(id: string): Promise<BoardRecord | null>;
+    listBoards(opts?: {
+        visibility?: string;
+        ownerGaii?: string;
+    }): Promise<BoardRecord[]>;
+    updateBoardVisibility(id: string, visibility: string): Promise<import('../../interface.js').BoardRecord | null>;
+    updateBoardMembers(id: string, allowedGaiis: string[]): Promise<import('../../interface.js').BoardRecord | null>;
+    deleteBoard(id: string): Promise<boolean>;
+    createPost(post: BoardPostRecord): Promise<BoardPostRecord>;
+    getPost(boardId: string, postId: string): Promise<BoardPostRecord | null>;
+    listPosts(boardId: string, opts?: {
+        category?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<BoardPostRecord[]>;
+    deletePost(boardId: string, postId: string): Promise<boolean>;
+    addReaction(boardId: string, postId: string, emoji: string, gaii: string): Promise<boolean>;
+    createBoardSubscription(sub: import('../../interface.js').BoardSubscriptionRecord): Promise<import('../../interface.js').BoardSubscriptionRecord>;
+    getBoardSubscription(boardId: string, gaii: string): Promise<import('../../interface.js').BoardSubscriptionRecord | null>;
+    listBoardSubscriptions(boardId: string): Promise<import('../../interface.js').BoardSubscriptionRecord[]>;
+    listSubscriptionsByAgent(gaii: string): Promise<import('../../interface.js').BoardSubscriptionRecord[]>;
+    deleteBoardSubscription(boardId: string, gaii: string): Promise<boolean>;
+    private toBoardSubscriptionRecord;
+    createOtk(otk: OtkRecord): Promise<OtkRecord>;
+    private toOtkRecord;
+    getOtk(key: string): Promise<OtkRecord | null>;
+    consumeOtk(key: string, graceMs?: number): Promise<OtkRecord | null>;
+    listOtksBySession(sessionId: string): Promise<OtkRecord[]>;
+    expireSessionOtks(sessionId: string): Promise<number>;
+    createDispute(dispute: DisputeRecord): Promise<DisputeRecord>;
+    getDispute(id: string): Promise<DisputeRecord | null>;
+    getDisputeByTrackingCode(tc: string): Promise<DisputeRecord | null>;
+    updateDispute(id: string, updates: Partial<DisputeRecord>): Promise<DisputeRecord | null>;
+    addDisputeAuditEntry(disputeId: string, entry: DisputeAuditEntry): Promise<DisputeAuditEntry>;
+    getDisputeAuditLog(disputeId: string): Promise<DisputeAuditEntry[]>;
+    listDisputesByProvider(gaii: string): Promise<DisputeRecord[]>;
+    listAllDisputes(limit?: number): Promise<DisputeRecord[]>;
+    setMicroMemory(record: MicroMemoryRecord): Promise<MicroMemoryRecord>;
+    getMicroMemory(gaii: string, set: string): Promise<MicroMemoryRecord | null>;
+    listMicroMemorySets(gaii: string): Promise<MicroMemoryRecord[]>;
+    deleteMicroMemory(gaii: string, set: string): Promise<boolean>;
+    deleteMicroMemoryEntry(gaii: string, set: string, key: string): Promise<boolean>;
+    findMicroMemoryByAccessCode(set: string, accessCode: string): Promise<MicroMemoryRecord | null>;
+    createStorageFile(file: StorageFileRecord): Promise<StorageFileRecord>;
+    getStorageFile(ownerGaii: string, key: string): Promise<StorageFileRecord | null>;
+    listStorageFiles(ownerGaii: string): Promise<StorageFileRecord[]>;
+    deleteStorageFile(ownerGaii: string, key: string): Promise<boolean>;
+    updateFileTagsByKey(ownerGaii: string, key: string, tags: string[]): Promise<StorageFileRecord | null>;
+    updateFileVisibility(ownerGaii: string, key: string, visibility: StorageFileRecord['visibility']): Promise<StorageFileRecord | null>;
+    createPeeringRequest(req: PeeringRequestRecord): Promise<PeeringRequestRecord>;
+    getPeeringRequest(id: string): Promise<PeeringRequestRecord | null>;
+    listPeeringRequests(status?: string): Promise<PeeringRequestRecord[]>;
+    updatePeeringRequest(id: string, updates: Partial<PeeringRequestRecord>): Promise<PeeringRequestRecord | null>;
+    createChunkedUpload(record: ChunkedUploadRecord): Promise<ChunkedUploadRecord>;
+    getChunkedUpload(uploadId: string): Promise<ChunkedUploadRecord | null>;
+    addChunk(uploadId: string, chunkIndex: number, data: Buffer): Promise<boolean>;
+    deleteChunkedUpload(uploadId: string): Promise<boolean>;
+    setNodeKey(publicKey: string, privateKey: string): Promise<void>;
+    getNodeKey(): Promise<{
+        publicKey: string;
+        privateKey: string;
+    } | null>;
+    private toOwnerRecord;
+    private toAgentRecord;
+    private toMemoryRecord;
+    private toActionRecord;
+    private toWorkRecord;
+    private toBoardRecord;
+    private toPostRecord;
+    private toDisputeRecord;
+    private toPeeringRecord;
+    private toGHIIRecord;
+    createGHII(record: GHIIRecord): Promise<GHIIRecord>;
+    getGHII(ghii: string): Promise<GHIIRecord | null>;
+    getGHIIByOwner(ownerName: string): Promise<GHIIRecord | null>;
+    getGHIIByEmailHash(emailHash: string): Promise<GHIIRecord | null>;
+    updateGHII(ghii: string, updates: Partial<GHIIRecord>): Promise<GHIIRecord | null>;
+    listGHIIs(opts?: {
+        q?: string;
+        level?: number;
+    }): Promise<GHIIRecord[]>;
+    deleteGHII(ghii: string): Promise<boolean>;
+    createChatInstance(record: ChatInstanceRecord): Promise<ChatInstanceRecord>;
+    getChatInstance(id: string): Promise<ChatInstanceRecord | null>;
+    listChatInstances(opts?: {
+        ownerName?: string;
+        platform?: string;
+        ghii?: string;
+    }): Promise<ChatInstanceRecord[]>;
+    updateChatInstance(id: string, updates: Partial<ChatInstanceRecord>): Promise<ChatInstanceRecord | null>;
+    deleteChatInstance(id: string): Promise<boolean>;
+    private toChatInstanceRecord;
+    createPersonalNode(node: PersonalNodeRecord): Promise<PersonalNodeRecord>;
+    getPersonalNode(nodeId: string): Promise<PersonalNodeRecord | null>;
+    getPersonalNodeByOwner(ownerName: string): Promise<PersonalNodeRecord | null>;
+    listPersonalNodes(opts?: {
+        status?: string;
+    }): Promise<PersonalNodeRecord[]>;
+    updatePersonalNode(nodeId: string, updates: Partial<PersonalNodeRecord>): Promise<PersonalNodeRecord | null>;
+    deletePersonalNode(nodeId: string): Promise<boolean>;
+    private toPersonalNodeRecord;
+    createMailboxItem(item: MailboxItemRecord): Promise<MailboxItemRecord>;
+    getMailboxItem(id: string): Promise<MailboxItemRecord | null>;
+    listMailboxItems(personalNodeId: string, opts?: {
+        type?: string;
+        limit?: number;
+    }): Promise<MailboxItemRecord[]>;
+    deleteMailboxItem(id: string): Promise<boolean>;
+    deleteMailboxItemsByNode(personalNodeId: string): Promise<number>;
+    getMailboxStats(personalNodeId: string): Promise<{
+        count: number;
+        totalBytes: number;
+    }>;
+    cleanExpiredMailboxItems(): Promise<number>;
+    private toMailboxItemRecord;
+    getMaintenanceMode(): Promise<import('../../interface.js').MaintenanceState>;
+    setMaintenanceMode(state: import('../../interface.js').MaintenanceState): Promise<import('../../interface.js').MaintenanceState>;
+    setSchema(record: SchemaRecord): Promise<SchemaRecord>;
+    getSchema(keyPattern: string, applyTo?: 'exact' | 'prefix'): Promise<SchemaRecord | null>;
+    deleteSchema(keyPattern: string): Promise<boolean>;
+    listSchemas(prefix?: string): Promise<SchemaRecord[]>;
+    findApplicableSchema(memoryKey: string): Promise<SchemaRecord | null>;
+    private toSchemaRecord;
+    createConsent(record: ConsentRecord): Promise<ConsentRecord>;
+    getConsent(id: string): Promise<ConsentRecord | null>;
+    listConsents(ownerGaii: string, opts?: {
+        status?: 'active' | 'revoked' | 'expired';
+        recipient?: string;
+    }): Promise<ConsentRecord[]>;
+    updateConsent(id: string, updates: Partial<ConsentRecord>): Promise<ConsentRecord | null>;
+    deleteConsent(id: string): Promise<boolean>;
+    findMatchingConsents(ownerGaii: string, memoryKey: string, accessorGaii: string): Promise<ConsentRecord[]>;
+    addConsentAuditEntry(entry: ConsentAuditEntry): Promise<ConsentAuditEntry>;
+    listConsentAudit(ownerGaii: string, opts?: {
+        days?: number;
+        consentId?: string;
+        accessorGaii?: string;
+    }): Promise<ConsentAuditEntry[]>;
+    private toConsentRecord;
+    createCsm(record: CsmRecord): Promise<CsmRecord>;
+    getCsm(name: string): Promise<CsmRecord | null>;
+    listCsms(opts?: {
+        serviceType?: string;
+    }): Promise<CsmRecord[]>;
+    updateCsm(name: string, updates: Partial<CsmRecord>): Promise<CsmRecord | null>;
+    deleteCsm(name: string): Promise<boolean>;
+    private toCsmRecord;
+    createMsm(record: MsmRecord): Promise<MsmRecord>;
+    getMsm(name: string): Promise<MsmRecord | null>;
+    listMsms(opts?: {
+        category?: string;
+    }): Promise<MsmRecord[]>;
+    updateMsm(name: string, updates: Partial<MsmRecord>): Promise<MsmRecord | null>;
+    deleteMsm(name: string): Promise<boolean>;
+    private toMsmRecord;
+    createEmailVerification(record: EmailVerificationRecord): Promise<EmailVerificationRecord>;
+    getEmailVerification(id: string): Promise<EmailVerificationRecord | null>;
+    getActiveEmailVerification(ownerName: string, purpose: string): Promise<EmailVerificationRecord | null>;
+    updateEmailVerification(id: string, updates: Partial<EmailVerificationRecord>): Promise<EmailVerificationRecord | null>;
+    deleteExpiredEmailVerifications(): Promise<number>;
+    private toEmailVerificationRecord;
+    createFlag(record: import('../../interface.js').FlagRecord): Promise<import('../../interface.js').FlagRecord>;
+    getFlag(id: string): Promise<import('../../interface.js').FlagRecord | null>;
+    getFlagsByTarget(targetType: string, targetId: string): Promise<import('../../interface.js').FlagRecord[]>;
+    getFlagByUser(targetType: string, targetId: string, flaggedBy: string): Promise<import('../../interface.js').FlagRecord | null>;
+    getFlagSummary(targetType: string, targetId: string): Promise<import('../../interface.js').FlagSummary | null>;
+    updateFlag(id: string, updates: Partial<import('../../interface.js').FlagRecord>): Promise<import('../../interface.js').FlagRecord | null>;
+    listFlags(opts?: {
+        status?: string;
+        targetType?: string;
+        page?: number;
+        perPage?: number;
+    }): Promise<import('../../interface.js').FlagRecord[]>;
+    private toFlagRecord;
+    createMatch(record: import('../../interface.js').MatchRecord): Promise<import('../../interface.js').MatchRecord>;
+    getMatch(id: string): Promise<import('../../interface.js').MatchRecord | null>;
+    getMatchByPair(profileA: string, profileB: string): Promise<import('../../interface.js').MatchRecord | null>;
+    listMatchesByProfile(profile: string, opts?: {
+        status?: string;
+        page?: number;
+        perPage?: number;
+    }): Promise<import('../../interface.js').MatchRecord[]>;
+    updateMatch(id: string, updates: Partial<import('../../interface.js').MatchRecord>): Promise<import('../../interface.js').MatchRecord | null>;
+    deleteExpiredMatches(): Promise<number>;
+    listAllMatches(limit?: number): Promise<import('../../interface.js').MatchRecord[]>;
+    private toMatchRecord;
+    createOrganism(record: import('../../interface.js').OrganismRecord): Promise<import('../../interface.js').OrganismRecord>;
+    getOrganism(id: string): Promise<import('../../interface.js').OrganismRecord | null>;
+    listOrganisms(opts?: {
+        type?: string;
+        city?: string;
+        interest?: string;
+        visibility?: string;
+        member?: string;
+        page?: number;
+        perPage?: number;
+    }): Promise<import('../../interface.js').OrganismRecord[]>;
+    updateOrganism(id: string, updates: Partial<import('../../interface.js').OrganismRecord>): Promise<import('../../interface.js').OrganismRecord | null>;
+    deleteOrganism(id: string): Promise<boolean>;
+    private toOrganismRecord;
+    createMembership(record: import('../../interface.js').OrganismMembershipRecord): Promise<import('../../interface.js').OrganismMembershipRecord>;
+    getMembership(organismId: string, ghii: string): Promise<import('../../interface.js').OrganismMembershipRecord | null>;
+    listMembers(organismId: string, opts?: {
+        role?: string;
+        status?: string;
+    }): Promise<import('../../interface.js').OrganismMembershipRecord[]>;
+    listMembershipsByGhii(ghii: string): Promise<import('../../interface.js').OrganismMembershipRecord[]>;
+    updateMembership(id: string, updates: Partial<import('../../interface.js').OrganismMembershipRecord>): Promise<import('../../interface.js').OrganismMembershipRecord | null>;
+    deleteMembership(id: string): Promise<boolean>;
+    private toMembershipRecord;
+    createJoinRequest(record: import('../../interface.js').JoinRequestRecord): Promise<import('../../interface.js').JoinRequestRecord>;
+    getJoinRequest(id: string): Promise<import('../../interface.js').JoinRequestRecord | null>;
+    listJoinRequests(organismId: string, opts?: {
+        status?: string;
+    }): Promise<import('../../interface.js').JoinRequestRecord[]>;
+    updateJoinRequest(id: string, updates: Partial<import('../../interface.js').JoinRequestRecord>): Promise<import('../../interface.js').JoinRequestRecord | null>;
+    private toJoinRequestRecord;
+    createAppeal(record: import('../../interface.js').AppealRecord): Promise<import('../../interface.js').AppealRecord>;
+    getAppeal(id: string): Promise<import('../../interface.js').AppealRecord | null>;
+    getAppealByFlagId(flagId: string): Promise<import('../../interface.js').AppealRecord | null>;
+    listAppeals(opts?: {
+        status?: string;
+        page?: number;
+        perPage?: number;
+    }): Promise<import('../../interface.js').AppealRecord[]>;
+    updateAppeal(id: string, updates: Partial<import('../../interface.js').AppealRecord>): Promise<import('../../interface.js').AppealRecord | null>;
+    private toAppealRecord;
+    createListing(record: import('../../interface.js').ListingRecord): Promise<import('../../interface.js').ListingRecord>;
+    getListing(id: string): Promise<import('../../interface.js').ListingRecord | null>;
+    listListings(opts?: {
+        category?: string;
+        city?: string;
+        minPrice?: number;
+        maxPrice?: number;
+        status?: string;
+        sellerOwner?: string;
+        page?: number;
+        perPage?: number;
+    }): Promise<import('../../interface.js').ListingRecord[]>;
+    updateListing(id: string, updates: Partial<import('../../interface.js').ListingRecord>): Promise<import('../../interface.js').ListingRecord | null>;
+    deleteListing(id: string): Promise<boolean>;
+    private toListingRecord;
+    createPurchase(record: import('../../interface.js').PurchaseRecord): Promise<import('../../interface.js').PurchaseRecord>;
+    getPurchase(id: string): Promise<import('../../interface.js').PurchaseRecord | null>;
+    listPurchasesByBuyer(buyerOwner: string): Promise<import('../../interface.js').PurchaseRecord[]>;
+    listPurchasesBySeller(sellerOwner: string): Promise<import('../../interface.js').PurchaseRecord[]>;
+    updatePurchase(id: string, updates: Partial<import('../../interface.js').PurchaseRecord>): Promise<import('../../interface.js').PurchaseRecord | null>;
+    private toPurchaseRecord;
+    createPushSubscription(record: PushSubscriptionRecord): Promise<PushSubscriptionRecord>;
+    getPushSubscription(ownerName: string): Promise<PushSubscriptionRecord | null>;
+    deletePushSubscription(ownerName: string): Promise<boolean>;
+    listPushSubscriptions(): Promise<PushSubscriptionRecord[]>;
+    createTrustedIssuer(record: TrustedIssuerRecord): Promise<TrustedIssuerRecord>;
+    getTrustedIssuer(id: string): Promise<TrustedIssuerRecord | null>;
+    getTrustedIssuerByUrl(url: string): Promise<TrustedIssuerRecord | null>;
+    listTrustedIssuers(opts?: {
+        type?: string;
+    }): Promise<TrustedIssuerRecord[]>;
+    deleteTrustedIssuer(id: string): Promise<boolean>;
+    private toTrustedIssuerRecord;
+    createGenesisPeer(record: import('../../interface.js').GenesisPeerRecord): Promise<import('../../interface.js').GenesisPeerRecord>;
+    getGenesisPeer(id: string): Promise<import('../../interface.js').GenesisPeerRecord | null>;
+    getGenesisPeerByNodeId(nodeId: string): Promise<import('../../interface.js').GenesisPeerRecord | null>;
+    listGenesisPeers(opts?: {
+        status?: string;
+    }): Promise<import('../../interface.js').GenesisPeerRecord[]>;
+    updateGenesisPeer(id: string, updates: Partial<import('../../interface.js').GenesisPeerRecord>): Promise<import('../../interface.js').GenesisPeerRecord | null>;
+    deleteGenesisPeer(id: string): Promise<boolean>;
+    private toGenesisPeerRecord;
+    setOrganismReputation(record: import('../../interface.js').OrganismReputationRecord): Promise<import('../../interface.js').OrganismReputationRecord>;
+    getOrganismReputation(organismId: string): Promise<import('../../interface.js').OrganismReputationRecord | null>;
+    createRealtimeRoom(record: import('../../interface.js').RealtimeRoomRecord): Promise<import('../../interface.js').RealtimeRoomRecord>;
+    getRealtimeRoom(id: string): Promise<import('../../interface.js').RealtimeRoomRecord | null>;
+    listRealtimeRooms(filter?: {
+        appType?: string;
+        isPublic?: boolean;
+    }): Promise<import('../../interface.js').RealtimeRoomRecord[]>;
+    updateRealtimeRoom(id: string, updates: Partial<import('../../interface.js').RealtimeRoomRecord>): Promise<import('../../interface.js').RealtimeRoomRecord | null>;
+    deleteRealtimeRoom(id: string): Promise<boolean>;
+    addSiteChangeLog(entry: SiteChangeLogEntry): Promise<SiteChangeLogEntry>;
+    listSiteChangeLog(limit: number, cursor?: string): Promise<SiteChangeLogEntry[]>;
+    private toExtensionRecord;
+    createExtension(record: ExtensionRecord): Promise<ExtensionRecord>;
+    getExtension(name: string): Promise<ExtensionRecord | null>;
+    listExtensions(opts?: {
+        status?: string;
+    }): Promise<ExtensionRecord[]>;
+    updateExtension(name: string, updates: Partial<ExtensionRecord>): Promise<ExtensionRecord | null>;
+    deleteExtension(name: string): Promise<boolean>;
+    private toEscrowHoldRecord;
+    createEscrowHold(record: EscrowHoldRecord): Promise<EscrowHoldRecord>;
+    getEscrowHold(holdId: string): Promise<EscrowHoldRecord | null>;
+    listEscrowHolds(fromGaii: string, opts?: {
+        status?: string;
+    }): Promise<EscrowHoldRecord[]>;
+    releaseEscrowHold(holdId: string, toGaii: string): Promise<EscrowHoldRecord | null>;
+    refundEscrowHold(holdId: string): Promise<EscrowHoldRecord | null>;
+    createCortexExtension(record: CortexExtensionRecord): Promise<CortexExtensionRecord>;
+    getCortexExtension(name: string): Promise<CortexExtensionRecord | null>;
+    listCortexExtensions(opts?: {
+        status?: string;
+        namespace?: string;
+        visibility?: string;
+        installedBy?: string;
+    }): Promise<CortexExtensionRecord[]>;
+    updateCortexExtension(name: string, updates: Partial<CortexExtensionRecord>): Promise<CortexExtensionRecord | null>;
+    deleteCortexExtension(name: string): Promise<boolean>;
+    private toCortexExtensionRecord;
+    setCortexLibFile(extName: string, libName: string, content: string): Promise<void>;
+    getCortexLibFile(extName: string, libName: string): Promise<string | null>;
+    deleteCortexLibFile(extName: string, libName: string): Promise<boolean>;
+    createPersonalPushSubscription(record: PersonalPushSubscriptionRecord): Promise<PersonalPushSubscriptionRecord>;
+    getPersonalPushSubscription(id: string): Promise<PersonalPushSubscriptionRecord | null>;
+    listPersonalPushSubscriptions(personalNodeId: string): Promise<PersonalPushSubscriptionRecord[]>;
+    updatePersonalPushSubscription(id: string, updates: Partial<PersonalPushSubscriptionRecord>): Promise<boolean>;
+    deletePersonalPushSubscription(id: string): Promise<boolean>;
+    deletePersonalPushSubscriptionsByNode(personalNodeId: string): Promise<number>;
+    countPersonalPushSubscriptions(personalNodeId: string): Promise<number>;
+    private toPersonalPushSubRecord;
+    getNotificationPreferences(personalNodeId: string): Promise<NotificationPreferences | null>;
+    upsertNotificationPreferences(prefs: NotificationPreferences): Promise<NotificationPreferences>;
+    deleteNotificationPreferences(personalNodeId: string): Promise<boolean>;
+    private ntKey;
+    getNotificationTemplate(id: string, locale: string): Promise<NotificationTemplateRecord | null>;
+    upsertNotificationTemplate(record: NotificationTemplateRecord): Promise<NotificationTemplateRecord>;
+    listNotificationTemplates(): Promise<NotificationTemplateRecord[]>;
+    deleteAllNotificationTemplates(): Promise<void>;
+    createSession(session: {
+        sessionId: string;
+        gaii: string;
+        owner: string;
+        issuedAt: string;
+        expiresAt: string;
+    }): Promise<void>;
+    listActiveSessions(owner: string): Promise<import('../../../storage/repositories/session.repository.js').SessionRecord[]>;
+    revokeSession(sessionId: string): Promise<boolean>;
+    revokeAllSessions(owner: string): Promise<number>;
+    isSessionRevoked(sessionId: string): Promise<boolean>;
+    revokeToken(tokenHash: string, expiresAt: number): Promise<void>;
+    isTokenRevoked(tokenHash: string): Promise<boolean>;
+    cleanExpiredRevocations(): Promise<number>;
+    private toAppRecord;
+    createApp(record: AppRecord): Promise<AppRecord>;
+    getApp(ownerGaii: string, filename: string, version?: number): Promise<AppRecord | null>;
+    getAppByOwnerName(ownerName: string, filename: string, version?: number): Promise<AppRecord | null>;
+    listApps(opts?: AppListOptions): Promise<{
+        apps: AppRecord[];
+        total: number;
+    }>;
+    listAppVersions(ownerGaii: string, filename: string): Promise<AppRecord[]>;
+    getLatestVersionNumber(ownerGaii: string, filename: string): Promise<number>;
+    deleteApp(ownerGaii: string, filename: string, version?: number): Promise<boolean>;
+    updateAppAccessCode(ownerGaii: string, filename: string, accessCode?: string): Promise<boolean>;
+    getAppDownloads(ownerGaii: string, filename: string): Promise<number>;
+    incrementAppDownloads(ownerGaii: string, filename: string): Promise<void>;
+    private toAppPurchaseRecord;
+    createAppPurchase(record: AppPurchaseRecord): Promise<AppPurchaseRecord>;
+    getAppPurchase(transactionId: string): Promise<AppPurchaseRecord | null>;
+    listAppPurchasesByBuyer(buyerGaii: string): Promise<AppPurchaseRecord[]>;
+    listAppPurchasesBySeller(sellerGaii: string): Promise<AppPurchaseRecord[]>;
+    hasValidLicense(buyerGaii: string, sellerGaii: string, filename: string, licenseType?: 'single' | 'lifetime'): Promise<boolean>;
+    supportsConfigPersistence(): boolean;
+    getConfigValue(key: string): Promise<string | null>;
+    setConfigValue(key: string, value: string): Promise<void>;
+    deleteConfigValue(key: string): Promise<void>;
+    getAllConfigValues(): Promise<Record<string, string>>;
+    private toMemoryLinkRecord;
+    createLink(record: MemoryLinkRecord): Promise<MemoryLinkRecord>;
+    getLink(source: string, target: string): Promise<MemoryLinkRecord | null>;
+    listLinks(key: string, opts?: {
+        direction?: 'outgoing' | 'incoming' | 'both';
+        relation?: string;
+    }): Promise<MemoryLinkRecord[]>;
+    deleteLink(source: string, target: string): Promise<boolean>;
+    findBrokenLinks(ownerGaii: string): Promise<MemoryLinkRecord[]>;
+    private toOperatorReviewRecord;
+    createReview(record: OperatorReviewRecord): Promise<OperatorReviewRecord>;
+    listReviews(packageId: string): Promise<OperatorReviewRecord[]>;
+    listAllReviews(opts?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<OperatorReviewRecord[]>;
+    private toScheduledJobRecord;
+    createScheduledJob(record: ScheduledJobRecord): Promise<ScheduledJobRecord>;
+    getScheduledJob(id: string): Promise<ScheduledJobRecord | null>;
+    listScheduledJobs(filter?: {
+        type?: string;
+        extensionName?: string;
+        enabled?: boolean;
+    }): Promise<ScheduledJobRecord[]>;
+    updateScheduledJob(id: string, updates: Partial<ScheduledJobRecord>): Promise<ScheduledJobRecord | null>;
+    deleteScheduledJob(id: string): Promise<boolean>;
+    createExecutionLog(entry: ExecutionLogEntry): Promise<ExecutionLogEntry>;
+    listExecutionLogs(filter?: {
+        jobId?: string;
+        extensionName?: string;
+        trigger?: string;
+        result?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ExecutionLogEntry[]>;
+    countExecutionLogs(filter?: {
+        jobId?: string;
+        extensionName?: string;
+        trigger?: string;
+        result?: string;
+    }): Promise<number>;
+    pruneExecutionLogs(beforeDate: string): Promise<number>;
+    private toExecutionLogEntry;
+    private toExtensionInstanceRecord;
+    createExtensionInstance(record: ExtensionInstanceRecord): Promise<ExtensionInstanceRecord>;
+    getExtensionInstance(extensionName: string, instanceId: string): Promise<ExtensionInstanceRecord | null>;
+    listExtensionInstances(extensionName: string): Promise<ExtensionInstanceRecord[]>;
+    updateExtensionInstance(extensionName: string, instanceId: string, updates: Partial<ExtensionInstanceRecord>): Promise<ExtensionInstanceRecord | null>;
+    deleteExtensionInstance(extensionName: string, instanceId: string): Promise<boolean>;
+    private replicationQueue;
+    enqueueReplication(entry: Omit<ReplicationQueueEntry, 'id' | 'attempts' | 'lastAttemptAt' | 'status'>): Promise<string>;
+    dequeueReplication(peerId: string, limit: number): Promise<ReplicationQueueEntry[]>;
+    markReplicationSent(ids: string[]): Promise<void>;
+    markReplicationFailed(ids: string[]): Promise<void>;
+    pruneReplicationQueue(maxAge: Date): Promise<number>;
+    replicationQueueSize(): Promise<number>;
+    createDeviceAuth(req: DeviceAuthorizationRecord): Promise<void>;
+    getDeviceAuthByDeviceCode(deviceCode: string): Promise<DeviceAuthorizationRecord | null>;
+    getDeviceAuthByUserCode(userCode: string): Promise<DeviceAuthorizationRecord | null>;
+    updateDeviceAuth(deviceCode: string, updates: Partial<DeviceAuthorizationRecord>): Promise<void>;
+    countPendingDeviceAuthByOwner(ownerName: string): Promise<number>;
+    listPendingDeviceAuthByOwner(ownerName: string): Promise<DeviceAuthorizationRecord[]>;
+    cleanupExpiredDeviceAuth(): Promise<number>;
+    private toDeviceAuthRecord;
+    createOAuthClient(client: OAuthClientRecord): Promise<void>;
+    getOAuthClient(clientId: string): Promise<OAuthClientRecord | null>;
+    deleteOAuthClient(clientId: string): Promise<boolean>;
+    listOAuthClients(): Promise<OAuthClientRecord[]>;
+    createOAuthRefreshToken(token: OAuthRefreshTokenRecord): Promise<void>;
+    getOAuthRefreshToken(tokenHash: string): Promise<OAuthRefreshTokenRecord | null>;
+    deleteOAuthRefreshToken(tokenHash: string): Promise<boolean>;
+    deleteOAuthRefreshTokensByClient(clientId: string): Promise<number>;
+    deleteOAuthRefreshTokensByGaii(gaii: string): Promise<number>;
+    createOAuthApproval(approval: OAuthApprovalRecord): Promise<void>;
+    getOAuthApproval(clientId: string, gaii: string): Promise<OAuthApprovalRecord | null>;
+    deleteOAuthApproval(clientId: string, gaii: string): Promise<boolean>;
+    deleteOAuthApprovalsByClient(clientId: string): Promise<number>;
+    deleteOAuthApprovalsByGaii(gaii: string): Promise<number>;
+    listOAuthApprovalsByOwner(owner: string): Promise<OAuthApprovalRecord[]>;
+    listSystemPrompts(opts?: {
+        group?: string;
+    }): Promise<SystemPromptRecord[]>;
+    getSystemPrompt(id: string): Promise<SystemPromptRecord | null>;
+    upsertSystemPrompt(record: SystemPromptRecord): Promise<SystemPromptRecord>;
+    getSystemPromptVersions(promptId: string): Promise<SystemPromptVersionRecord[]>;
+    getSystemPromptVersion(promptId: string, version: number): Promise<SystemPromptVersionRecord | null>;
+    createSystemPromptVersion(record: SystemPromptVersionRecord): Promise<SystemPromptVersionRecord>;
+    pruneSystemPromptVersions(promptId: string, keepCount: number): Promise<number>;
+    deleteAllSystemPrompts(): Promise<void>;
+    private toSystemPromptRecord;
+    private toSystemPromptVersionRecord;
+    createPackage(record: PackageRecord): Promise<PackageRecord>;
+    getPackage(id: string): Promise<PackageRecord | null>;
+    getPackageByGroupAndVersion(groupId: string, version: string): Promise<PackageRecord | null>;
+    getLatestPublished(groupId: string): Promise<PackageRecord | null>;
+    listPackages(filter: PackageFilter): Promise<{
+        packages: PackageRecord[];
+        total: number;
+    }>;
+    listVersions(groupId: string, limit?: number, offset?: number): Promise<{
+        versions: PackageRecord[];
+        total: number;
+    }>;
+    updatePackage(id: string, updates: Partial<PackageRecord>): Promise<PackageRecord | null>;
+    archivePackage(id: string): Promise<boolean>;
+    private toPackageRecord;
+    createTemplateListing(record: TemplateListingRecord): Promise<TemplateListingRecord>;
+    getTemplateListing(id: string): Promise<TemplateListingRecord | null>;
+    getListingByPackage(packageGroupId: string): Promise<TemplateListingRecord | null>;
+    listTemplateListings(filter: TemplateFilter): Promise<{
+        listings: TemplateListingRecord[];
+        total: number;
+    }>;
+    updateTemplateListing(id: string, updates: Partial<TemplateListingRecord>): Promise<TemplateListingRecord | null>;
+    deleteTemplateListing(id: string): Promise<boolean>;
+    incrementInstallCount(listingId: string): Promise<void>;
+    listPendingTemplates(limit?: number, offset?: number): Promise<TemplateListingRecord[]>;
+    addReview(review: TemplateReview): Promise<TemplateReview>;
+    getReviewsByListing(listingId: string, limit?: number, offset?: number): Promise<{
+        reviews: TemplateReview[];
+        total: number;
+    }>;
+    getReviewByAuthor(listingId: string, authorGhii: string): Promise<TemplateReview | null>;
+    updateReview(id: string, updates: Partial<TemplateReview>): Promise<TemplateReview | null>;
+    deleteReview(id: string): Promise<boolean>;
+    recalculateRating(listingId: string): Promise<{
+        rating: number;
+        reviewCount: number;
+    }>;
+    private toTemplateReview;
+    addDiscussion(discussion: TemplateDiscussion): Promise<TemplateDiscussion>;
+    getDiscussionsByListing(listingId: string, limit?: number, offset?: number): Promise<{
+        discussions: TemplateDiscussion[];
+        total: number;
+    }>;
+    deleteDiscussion(id: string): Promise<boolean>;
+    private toTemplateListingRecord;
+    private toTemplateDiscussion;
+    createInstance(record: PackageInstanceRecord): Promise<PackageInstanceRecord>;
+    getInstance(id: string): Promise<PackageInstanceRecord | null>;
+    listInstances(filter: InstanceFilter): Promise<{
+        instances: PackageInstanceRecord[];
+        total: number;
+    }>;
+    updateInstance(id: string, updates: Partial<PackageInstanceRecord>): Promise<PackageInstanceRecord | null>;
+    deleteInstance(id: string): Promise<boolean>;
+    listInstancesByPackage(packageGroupId: string): Promise<{
+        instances: PackageInstanceRecord[];
+        total: number;
+    }>;
+    private toPackageInstanceRecord;
+}
+//# sourceMappingURL=index.d.ts.map