@undefineds.co/models 0.2.0 → 0.2.1

package/dist/namespaces.js

@@ -1 +1,253 @@
-export { ACL, AS, DCTerms, FOAF, LINQ, LINX_CHAT, LINX_MSG, LDP, MEETING, ODRL, OWL, RDF, RDFS, SCHEMA, SIOC, UDFS, UDFS_NAMESPACE, VCARD, WF, } from './core.js';
+import { FOAF, VCARD, LDP, DCTERMS, RDF as RDF_VOCAB, ACL as ACL_VOCAB } from '@inrupt/vocab-common-rdf';
+const ABSOLUTE_IRI = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
+const createNamespace = (prefix, baseUri, terms) => {
+    const builder = ((term) => ABSOLUTE_IRI.test(term) ? term : `${baseUri}${term}`);
+    builder.prefix = prefix;
+    builder.uri = baseUri;
+    builder.NAMESPACE = baseUri;
+    builder.term = (name) => builder(name);
+    Object.entries(terms).forEach(([key, local]) => {
+        Object.defineProperty(builder, key, {
+            value: builder(local),
+            enumerable: true,
+        });
+    });
+    return builder;
+};
+export { FOAF, VCARD, LDP };
+export const DCTerms = DCTERMS;
+export const RDF = RDF_VOCAB;
+export const ACL = ACL_VOCAB;
+// ODRL isn't provided as a NamespaceConfig-compatible builder in vocab-common-rdf.
+// We define a small namespace builder to keep drizzle-solid happy.
+export const ODRL = createNamespace('odrl', 'http://www.w3.org/ns/odrl/2/', {
+    Policy: 'Policy',
+    target: 'target',
+    action: 'action',
+});
+export const RDFS = createNamespace('rdfs', 'http://www.w3.org/2000/01/rdf-schema#', {
+    Class: 'Class',
+    label: 'label',
+    comment: 'comment',
+    subClassOf: 'subClassOf',
+    domain: 'domain',
+    range: 'range',
+});
+export const OWL = createNamespace('owl', 'http://www.w3.org/2002/07/owl#', {
+    Ontology: 'Ontology',
+    Class: 'Class',
+    ObjectProperty: 'ObjectProperty',
+    DatatypeProperty: 'DatatypeProperty',
+});
+export const SCHEMA = createNamespace('schema', 'http://schema.org/', {
+    CreativeWork: 'CreativeWork',
+    MediaObject: 'MediaObject',
+    PropertyValue: 'PropertyValue',
+    author: 'author',
+    dateCreated: 'dateCreated',
+    dateDeleted: 'dateDeleted',
+    description: 'description',
+    encodingFormat: 'encodingFormat',
+    fileSize: 'fileSize',
+    image: 'image',
+    name: 'name',
+    participant: 'participant',
+    text: 'text',
+    url: 'url',
+});
+export const SIOC = createNamespace('sioc', 'http://rdfs.org/sioc/ns#', {
+    Post: 'Post',
+    Thread: 'Thread',
+    Forum: 'Forum',
+    content: 'content',
+    richContent: 'richContent',
+    hasReply: 'has_reply',
+    replyOf: 'reply_of',
+    hasCreator: 'has_creator',
+    createdAt: 'created_at',
+    hasContainer: 'has_container',
+    has_parent: 'has_parent',
+    numReplies: 'num_replies',
+    has_member: 'has_member',
+});
+export const MEETING = createNamespace('mee', 'http://www.w3.org/ns/pim/meeting#', {
+    LongChat: 'LongChat',
+    Message: 'Message',
+});
+export const WF = createNamespace('wf', 'http://www.w3.org/2005/01/wf/flow-1.0#', {
+    message: 'message',
+    participation: 'participation',
+    participant: 'participant',
+});
+// Activity Streams 2.0 - W3C standard for social web
+export const AS = createNamespace('as', 'https://www.w3.org/ns/activitystreams#', {
+    Announce: 'Announce',
+    Public: 'Public',
+    audience: 'audience',
+    actor: 'actor',
+    object: 'object',
+});
+// Company-level namespace (community-first guidance): all custom terms live under udfs:.
+// NOTE: This base URI is part of the contract.
+export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
+    // Types
+    ApprovalRequest: 'ApprovalRequest',
+    AuditEntry: 'AuditEntry',
+    AutonomyGrant: 'AutonomyGrant',
+    favorite: 'favorite',
+    favoriteType: 'favoriteType',
+    favoriteTarget: 'favoriteTarget',
+    favoredAt: 'favoredAt',
+    conversation: 'conversation',
+    conversationType: 'conversationType',
+    conversationTitle: 'conversationTitle',
+    lastMessage: 'lastMessage',
+    lastActiveAt: 'lastActiveAt',
+    lastSyncedAt: 'lastSyncedAt',
+    sortKey: 'sortKey',
+    hasThread: 'hasThread',
+    inThread: 'inThread',
+    participants: 'participants',
+    messageContent: 'messageContent',
+    messageType: 'messageType',
+    messageStatus: 'messageStatus',
+    readBy: 'readBy',
+    Contact: 'Contact',
+    PersonContact: 'PersonContact',
+    AgentContact: 'AgentContact',
+    GroupContact: 'GroupContact',
+    hasContact: 'hasContact',
+    contactType: 'contactType',
+    entityUri: 'entityUri',
+    externalPlatform: 'externalPlatform',
+    externalId: 'externalId',
+    alias: 'alias',
+    aiAssistant: 'aiAssistant',
+    aiModel: 'aiModel',
+    aiModels: 'aiModels',
+    aiProvider: 'aiProvider',
+    credential: 'credential',
+    systemPrompt: 'systemPrompt',
+    temperature: 'temperature',
+    maxTokens: 'maxTokens',
+    systemMessage: 'systemMessage',
+    provider: 'provider',
+    model: 'model',
+    metadata: 'metadata',
+    tools: 'tools',
+    contextWindow: 'contextWindow',
+    contextRound: 'contextRound',
+    Agent: 'Agent',
+    agentCapability: 'agentCapability',
+    agentTool: 'agentTool',
+    agentConfig: 'agentConfig',
+    fileHash: 'fileHash',
+    syncStatus: 'syncStatus',
+    localPath: 'localPath',
+    isDefault: 'isDefault',
+    settingKey: 'settingKey',
+    settingValue: 'settingValue',
+    settingType: 'settingType',
+    apiKey: 'apiKey',
+    baseUrl: 'baseUrl',
+    inbox: 'inbox',
+    session: 'session',
+    status: 'status',
+    risk: 'risk',
+    assignedTo: 'assignedTo',
+    reason: 'reason',
+    resolvedAt: 'resolvedAt',
+    action: 'action',
+    actor: 'actor',
+    actorRole: 'actorRole',
+    context: 'context',
+    policy: 'policy',
+    approval: 'approval',
+    effect: 'effect',
+    riskCeiling: 'riskCeiling',
+    revokedAt: 'revokedAt',
+    archivedAt: 'archivedAt',
+    deletedAt: 'deletedAt',
+    pinnedAt: 'pinnedAt',
+    pinned: 'pinned',
+    muted: 'muted',
+    mutedAt: 'mutedAt',
+    unreadCount: 'unreadCount',
+    ttsModel: 'ttsModel',
+    videoModel: 'videoModel',
+    chatType: 'chatType',
+    workspace: 'workspace',
+    container: 'workspace',
+    policyRef: 'policyRef',
+    policyVersion: 'policyVersion',
+    parentThreadId: 'parentThreadId',
+    sessionStatus: 'sessionStatus',
+    sessionTool: 'sessionTool',
+    tokenUsage: 'tokenUsage',
+    groupOwner: 'groupOwner',
+    groupAdmin: 'groupAdmin',
+    senderName: 'senderName',
+    senderAvatarUrl: 'senderAvatarUrl',
+    mentions: 'mentions',
+    replyTo: 'replyTo',
+    routedBy: 'routedBy',
+    routeTargetAgentId: 'routeTargetAgentId',
+    coordinationId: 'coordinationId',
+    toolCallId: 'toolCallId',
+    toolName: 'toolName',
+    toolArguments: 'toolArguments',
+    toolStatus: 'toolStatus',
+    toolResult: 'toolResult',
+    toolError: 'toolError',
+    toolDuration: 'toolDuration',
+    toolRisk: 'toolRisk',
+    approvalStatus: 'approvalStatus',
+    decisionBy: 'decisionBy',
+    decisionRole: 'decisionRole',
+    onBehalfOf: 'onBehalfOf',
+    approvalReason: 'approvalReason',
+    inboxItemId: 'inboxItemId',
+    taskProgressId: 'taskProgressId',
+    taskSteps: 'taskSteps',
+    currentStep: 'currentStep',
+    totalSteps: 'totalSteps',
+    // Favorites V2
+    sourceModule: 'sourceModule',
+    sourceId: 'sourceId',
+    searchText: 'searchText',
+    snapshotMeta: 'snapshotMeta',
+});
+export const UDFS_NAMESPACE = UDFS.NAMESPACE;
+// Legacy alias: existing code may still import LINQ.
+// Keep as alias to avoid churn.
+export const LINQ = UDFS;
+// Wave A contracts: unified under company namespace (UDFS).
+// Keep legacy names as aliases to avoid downstream churn.
+export const LINX_CHAT = UDFS;
+export const LINX_MSG = UDFS;
+export const XPOD_CREDENTIAL = createNamespace('cred', 'https://vocab.xpod.dev/credential#', {
+    Credential: 'Credential',
+    provider: 'provider',
+    service: 'service',
+    status: 'status',
+    apiKey: 'apiKey',
+    baseUrl: 'baseUrl',
+    label: 'label',
+    lastUsedAt: 'lastUsedAt',
+    failCount: 'failCount',
+    rateLimitResetAt: 'rateLimitResetAt',
+});
+export const XPOD_AI = createNamespace('ai', 'https://vocab.xpod.dev/ai#', {
+    Provider: 'Provider',
+    Model: 'Model',
+    baseUrl: 'baseUrl',
+    proxyUrl: 'proxyUrl',
+    hasModel: 'hasModel',
+    displayName: 'displayName',
+    modelType: 'modelType',
+    isProvidedBy: 'isProvidedBy',
+    dimension: 'dimension',
+    status: 'status',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt',
+});

package/dist/profile.d.ts

@@ -1 +1,22 @@
-export { solidProfileTable, type SolidProfileRow, type SolidProfileInsert, type SolidProfileUpdate, } from './core.js';
+import type { SolidProfileRow } from "./profile.schema.js";
+import { type SolidProfileIdentity } from "./profile.repository.js";
+export { pickSolidProfileDisplayName, profileRepository, type SolidProfileIdentity, } from "./profile.repository.js";
+type NodeRequire = (id: string) => unknown;
+export interface SolidProfileSessionLike {
+    info?: {
+        webId?: string;
+    };
+    fetch?: typeof fetch;
+}
+export interface SolidProfileReader<TTable = unknown> {
+    findByIri(table: TTable, iri: string): Promise<unknown | null>;
+}
+export declare function createSolidProfileDatabase(session: unknown): Promise<SolidProfileReader>;
+export declare function applySolidProfileComunicaPatches(requireModule?: NodeRequire): Promise<boolean>;
+export declare function resolveSolidProfile(db: SolidProfileReader, webId: string): Promise<SolidProfileRow | null>;
+export declare function resolveSolidProfileWithTable<TTable>(db: SolidProfileReader<TTable>, webId: string, table: TTable): Promise<SolidProfileRow | null>;
+export declare function resolveSolidProfileDisplayName(db: SolidProfileReader, webId: string): Promise<string | null>;
+export declare function resolveSolidProfileIdentityWithReader(db: SolidProfileReader, webId: string): Promise<SolidProfileIdentity | null>;
+export declare function resolveSolidProfileIdentity(session: SolidProfileSessionLike, options?: {
+    webId?: string;
+}): Promise<SolidProfileIdentity | null>;

package/dist/profile.js

@@ -1 +1,88 @@
-export { solidProfileTable, } from './core.js';
+import { profileRepository } from "./profile.repository.js";
+export { pickSolidProfileDisplayName, profileRepository, } from "./profile.repository.js";
+export async function createSolidProfileDatabase(session) {
+    await applySolidProfileComunicaPatches();
+    const [{ drizzle }, { solidProfileTable }] = await Promise.all([
+        import("@undefineds.co/drizzle-solid"),
+        import("./profile.schema.js"),
+    ]);
+    return drizzle(session, {
+        logger: false,
+        disableInteropDiscovery: true,
+        schema: { solidProfileTable },
+    });
+}
+export async function applySolidProfileComunicaPatches(requireModule) {
+    const resolvedRequire = requireModule ?? await createNodeRequire();
+    if (!resolvedRequire) {
+        return false;
+    }
+    return [
+        "@comunica/actor-query-result-serialize-sparql-json",
+        "@comunica/actor-query-result-serialize-stats",
+        "@comunica/query-sparql-solid/node_modules/@comunica/actor-query-result-serialize-sparql-json",
+        "@comunica/query-sparql-solid/node_modules/@comunica/actor-query-result-serialize-stats",
+    ].map((moduleName) => patchActionObserverHttp(resolvedRequire, moduleName)).some(Boolean);
+}
+export async function resolveSolidProfile(db, webId) {
+    return await profileRepository.findByWebId(db, webId);
+}
+export async function resolveSolidProfileWithTable(db, webId, table) {
+    if (!webId.trim()) {
+        return null;
+    }
+    return await db.findByIri(table, webId);
+}
+export async function resolveSolidProfileDisplayName(db, webId) {
+    return await profileRepository.resolveDisplayName(db, webId);
+}
+export async function resolveSolidProfileIdentityWithReader(db, webId) {
+    return await profileRepository.resolveIdentity(db, webId);
+}
+export async function resolveSolidProfileIdentity(session, options = {}) {
+    const webId = options.webId ?? session.info?.webId;
+    if (!webId?.trim()) {
+        return null;
+    }
+    const db = await createSolidProfileDatabase(session);
+    return resolveSolidProfileIdentityWithReader(db, webId);
+}
+async function createNodeRequire() {
+    if (typeof process === 'undefined') {
+        return null;
+    }
+    try {
+        const moduleLib = await import("node:module");
+        if (typeof moduleLib.createRequire !== 'function') {
+            return null;
+        }
+        return moduleLib.createRequire(import.meta.url);
+    }
+    catch {
+        return null;
+    }
+}
+function patchActionObserverHttp(requireModule, moduleName) {
+    try {
+        const module = requireModule(moduleName);
+        const prototype = module.ActionObserverHttp?.prototype;
+        const originalOnRun = prototype?.onRun;
+        if (!prototype || typeof originalOnRun !== 'function') {
+            return false;
+        }
+        if (prototype.__linxObservedActorsPatchApplied) {
+            return true;
+        }
+        prototype.onRun = function patchedActionObserverOnRun(actor, action, output) {
+            if (!Array.isArray(this.observedActors)) {
+                this.observedActors = [];
+            }
+            return originalOnRun.call(this, actor, action, output);
+        };
+        prototype.__linxObservedActorsPatchApplied = true;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/profile.repository.d.ts

@@ -0,0 +1,105 @@
+import { type AnyPodTable } from './repository.js';
+import { type SolidProfileRow } from './profile.schema.js';
+export interface SolidProfileIdentity {
+    webId: string;
+    profile: SolidProfileRow | null;
+    displayName: string | null;
+    username: string;
+}
+export interface SolidProfileRepositoryReader {
+    findByIri?(table: AnyPodTable, iri: string): Promise<unknown | null>;
+}
+export declare const profileRepository: {
+    findByWebId(db: SolidProfileRepositoryReader, webId: string): Promise<SolidProfileRow | null>;
+    resolveDisplayName(db: SolidProfileRepositoryReader, webId: string): Promise<string | null>;
+    resolveIdentity(db: SolidProfileRepositoryReader, webId: string): Promise<SolidProfileIdentity | null>;
+    namespace: string;
+    resourcePath: string;
+    searchableFields?: ("name" | "favorite" | "inbox" | "id" | "nick" | "avatar" | "note" | "email" | "phone" | "region" | "gender")[] | undefined;
+    defaultSort?: {
+        field: "name" | "favorite" | "inbox" | "id" | "nick" | "avatar" | "note" | "email" | "phone" | "region" | "gender";
+        direction: "asc" | "desc";
+    } | undefined;
+    cache?: import("./repository.js").RepositoryCacheOptions;
+    invalidations: import("./repository.js").RepositoryInvalidations;
+    list: (db: import("./repository.js").SolidDatabase, filters?: Record<string, unknown> | undefined) => Promise<{
+        id: string;
+        name: string;
+        nick: string;
+        avatar: string;
+        note: string;
+        email: string;
+        phone: string;
+        region: string;
+        gender: string;
+        favorite: string;
+        inbox: string;
+    }[]>;
+    detail: (db: import("./repository.js").SolidDatabase, id: string) => Promise<{
+        id: string;
+        name: string;
+        nick: string;
+        avatar: string;
+        note: string;
+        email: string;
+        phone: string;
+        region: string;
+        gender: string;
+        favorite: string;
+        inbox: string;
+    } | null>;
+    create?: ((db: import("./repository.js").SolidDatabase, input: {
+        id?: string | undefined;
+        name?: string | undefined;
+        nick?: string | undefined;
+        avatar?: string | undefined;
+        note?: string | undefined;
+        email?: string | undefined;
+        phone?: string | undefined;
+        region?: string | undefined;
+        gender?: string | undefined;
+        favorite?: string | undefined;
+        inbox?: string | undefined;
+    }) => Promise<{
+        id: string;
+        name: string;
+        nick: string;
+        avatar: string;
+        note: string;
+        email: string;
+        phone: string;
+        region: string;
+        gender: string;
+        favorite: string;
+        inbox: string;
+    }>) | undefined;
+    update?: ((db: import("./repository.js").SolidDatabase, id: string, input: {
+        id?: string | null | undefined;
+        name?: string | null | undefined;
+        nick?: string | null | undefined;
+        avatar?: string | null | undefined;
+        note?: string | null | undefined;
+        email?: string | null | undefined;
+        phone?: string | null | undefined;
+        region?: string | null | undefined;
+        gender?: string | null | undefined;
+        favorite?: string | null | undefined;
+        inbox?: string | null | undefined;
+    }) => Promise<{
+        id: string;
+        name: string;
+        nick: string;
+        avatar: string;
+        note: string;
+        email: string;
+        phone: string;
+        region: string;
+        gender: string;
+        favorite: string;
+        inbox: string;
+    }>) | undefined;
+    remove?: (db: import("./repository.js").SolidDatabase, id: string) => Promise<{
+        id: string;
+    }>;
+};
+export declare function pickSolidProfileDisplayName(profile: Pick<SolidProfileRow, 'name' | 'nick'> | null | undefined): string | null;

package/dist/profile.repository.js

@@ -0,0 +1,47 @@
+import { extractProfileUsernameFromWebId } from './client/index.js';
+import { definePodRepository } from './repository.js';
+import { solidProfileTable, } from './profile.schema.js';
+const baseProfileRepository = definePodRepository({
+    namespace: 'profile',
+    table: solidProfileTable,
+    searchableFields: ['name', 'nick'],
+    disableMutations: {
+        create: true,
+        update: true,
+        remove: true,
+    },
+});
+export const profileRepository = {
+    ...baseProfileRepository,
+    async findByWebId(db, webId) {
+        if (!webId.trim()) {
+            return null;
+        }
+        return await db.findByIri?.(solidProfileTable, webId) ?? null;
+    },
+    async resolveDisplayName(db, webId) {
+        return pickSolidProfileDisplayName(await profileRepository.findByWebId(db, webId));
+    },
+    async resolveIdentity(db, webId) {
+        if (!webId.trim()) {
+            return null;
+        }
+        const profile = await profileRepository.findByWebId(db, webId);
+        return {
+            webId,
+            profile,
+            displayName: pickSolidProfileDisplayName(profile),
+            username: extractProfileUsernameFromWebId(webId),
+        };
+    },
+};
+export function pickSolidProfileDisplayName(profile) {
+    return normalizeDisplayName(profile?.name) ?? normalizeDisplayName(profile?.nick) ?? null;
+}
+function normalizeDisplayName(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}

package/dist/profile.schema.d.ts

@@ -0,0 +1,16 @@
+export declare const solidProfileTable: import("@undefineds.co/drizzle-solid/dist/core/schema/pod-table.js").PodTableWithColumns<import("@undefineds.co/drizzle-solid/dist/core/schema/types.js").ResolvedColumns<{
+    id: import("@undefineds.co/drizzle-solid/dist/core/schema/columns.js").PodStringColumn<false, false>;
+    name: import("@undefineds.co/drizzle-solid/dist/core/schema/columns.js").ColumnBuilder<"string", null, false, false>;
+    nick: import("@undefineds.co/drizzle-solid/dist/core/schema/columns.js").ColumnBuilder<"string", null, false, false>;
+    avatar: import("@undefineds.co/drizzle-solid/dist/core/schema/columns.js").ColumnBuilder<"string", null, false, false>;
+    note: import("@undefineds.co/drizzle-solid/dist/core/schema/columns.js").ColumnBuilder<"string", null, false, false>;
+    email: import("@undefineds.co/drizzle-solid/dist/core/schema/columns.js").ColumnBuilder<"string", null, false, false>;
+    phone: import("@undefineds.co/drizzle-solid/dist/core/schema/columns.js").ColumnBuilder<"string", null, false, false>;
+    region: import("@undefineds.co/drizzle-solid/dist/core/schema/columns.js").ColumnBuilder<"string", null, false, false>;
+    gender: import("@undefineds.co/drizzle-solid/dist/core/schema/columns.js").ColumnBuilder<"string", null, false, false>;
+    favorite: import("@undefineds.co/drizzle-solid/dist/core/schema/columns.js").ColumnBuilder<"string", null, false, false>;
+    inbox: import("@undefineds.co/drizzle-solid/dist/core/schema/columns.js").ColumnBuilder<"string", null, false, false>;
+}>>;
+export type SolidProfileRow = typeof solidProfileTable.$inferSelect;
+export type SolidProfileInsert = typeof solidProfileTable.$inferInsert;
+export type SolidProfileUpdate = typeof solidProfileTable.$inferUpdate;

package/dist/{core/profile.js → profile.schema.js}

@@ -1,7 +1,7 @@
-import { podTable, string, id } from "@undefineds.co/drizzle-solid";
-import { UDFS, VCARD, FOAF, LDP } from "./namespaces.js";
+import { id, podTable, string } from "@undefineds.co/drizzle-solid";
+import { FOAF, LDP, UDFS, VCARD } from "./namespaces.js";
 export const solidProfileTable = podTable("profile", {
-    id: id('id'),
+    id: id("id"),
     name: string("name").predicate(VCARD.fn),
     nick: string("nick").predicate(FOAF.nick),
     avatar: string("avatar").predicate(VCARD.hasPhoto),
@@ -11,7 +11,7 @@ export const solidProfileTable = podTable("profile", {
     region: string("region").predicate(VCARD.region),
     gender: string("gender").predicate(VCARD.hasGender),
     favorite: string("favorite").predicate(UDFS.favorite),
-    inbox: string("inbox").predicate(LDP.inbox)
+    inbox: string("inbox").predicate(LDP.inbox),
 }, {
     base: "idp:///profile/card",
     type: FOAF.Person,

package/dist/repository.d.ts

@@ -1,5 +1,52 @@
-import type { PodTable, InferTableData, InferInsertData, InferUpdateData, SolidDatabase as DrizzleSolidDatabase, QueryCondition } from '@undefineds.co/drizzle-solid';
-export type SolidDatabase<TSchema extends Record<string, unknown> = Record<string, never>> = DrizzleSolidDatabase<TSchema>;
+import type { PodTable, InferTableData, InferInsertData, InferUpdateData, QueryCondition } from '@undefineds.co/drizzle-solid';
+export interface AnyPodTable {
+    resolveUri?: (id: string) => string;
+    config?: {
+        name?: string;
+        base?: string;
+    };
+    getResourcePath?: () => string;
+}
+export interface PodExecutableQuery<TRow = unknown> {
+    where(condition: unknown): PodExecutableQuery<TRow>;
+    whereByIri?(iri: string | string[]): PodExecutableQuery<TRow>;
+    orderBy(...args: unknown[]): PodExecutableQuery<TRow>;
+    execute(): Promise<TRow[]>;
+}
+export interface PodInsertQuery {
+    values(values: unknown): {
+        execute(): Promise<unknown[]>;
+    };
+}
+export interface PodUpdateQuery {
+    set(values: unknown): PodMutationQuery;
+}
+export interface PodMutationQuery {
+    where(condition: unknown): PodMutationQuery;
+    whereByIri?(iri: string): PodMutationQuery;
+    execute(): Promise<unknown[]>;
+}
+export interface SolidDatabase<TSchema extends Record<string, unknown> = Record<string, unknown>> {
+    init?(tables: AnyPodTable[] | AnyPodTable, ...rest: unknown[]): Promise<void>;
+    select(fields?: unknown): {
+        from(table: AnyPodTable): PodExecutableQuery;
+    };
+    insert(table: AnyPodTable): PodInsertQuery;
+    update(table: AnyPodTable): PodUpdateQuery;
+    delete(table: AnyPodTable): PodMutationQuery;
+    findByIri?<T = unknown>(table: AnyPodTable, iri: string): Promise<T | null>;
+    updateByIri?<T = unknown>(table: AnyPodTable, iri: string, data: Record<string, unknown>): Promise<T | null>;
+    deleteByIri?(table: AnyPodTable, iri: string): Promise<unknown>;
+    subscribe?(table: AnyPodTable, options: unknown): Promise<{
+        unsubscribe?: () => void;
+    } | (() => void)>;
+}
+export declare function initSolidTables(db: SolidDatabase, tables: AnyPodTable[]): Promise<void>;
+export declare function resolvePodUri(webId: string, table: {
+    resolveUri?: (id: string) => string;
+}, id: string): string;
+export declare function findPodRowByStorageId<T>(db: SolidDatabase, webId: string, table: AnyPodTable, id: string): Promise<T | null>;
+export declare function whereByPodStorageId<TTable extends AnyPodTable>(webId: string, table: TTable, query: PodMutationQuery, id: string): PodMutationQuery;
 export interface RepositoryCacheOptions {
     staleTime?: number;
     gcTime?: number;
@@ -48,12 +95,5 @@ export interface PodRepositoryOptions<TTable extends PodTable<any>, Row extends
     disableMutations?: Partial<Record<'create' | 'update' | 'remove', boolean>>;
 }
 export declare function resolveRowId(row: Partial<Record<string, unknown>> | null): string | null;
-export declare function isIriLikeIdentifier(value: string): boolean;
-export declare function stripEntityIdentifiers<T extends Record<string, unknown>>(data: T | null | undefined): Partial<T>;
-type ExactTargetInput = string | Partial<Record<string, unknown>>;
-export declare function findExactRecord<TTable extends PodTable<any>>(db: SolidDatabase<any>, table: TTable, target: ExactTargetInput): Promise<InferTableData<TTable> | null>;
-export declare function updateExactRecord<TTable extends PodTable<any>>(db: SolidDatabase<any>, table: TTable, target: ExactTargetInput, data: Partial<Record<string, unknown>>): Promise<InferTableData<TTable> | null>;
-export declare function deleteExactRecord<TTable extends PodTable<any>>(db: SolidDatabase<any>, table: TTable, target: ExactTargetInput): Promise<boolean>;
 export declare function createRepositoryDescriptor<TTable extends PodTable<any>, Row extends Record<string, unknown> = InferTableData<TTable>, Insert = InferInsertData<TTable>, Update = InferUpdateData<TTable>, Filters extends Record<string, unknown> = Record<string, unknown>>(options: PodRepositoryOptions<TTable, Row, Filters>): PodRepositoryDescriptor<TTable, Row, Insert, Update, Filters>;
 export declare const definePodRepository: typeof createRepositoryDescriptor;
-export {};