@undefineds.co/drizzle-solid 0.2.6

package/dist/esm/core/pod-table.d.ts

@@ -0,0 +1,710 @@
+import { entityKind } from 'drizzle-orm';
+export interface NamespaceConfig {
+    prefix: string;
+    uri: string;
+}
+export interface PodColumnOptions {
+    primaryKey?: boolean;
+    required?: boolean;
+    defaultValue?: unknown;
+    predicate?: string;
+    referenceTarget?: string;
+    referenceTableName?: string;
+    referenceTable?: PodTable;
+    notNull?: boolean;
+    baseType?: ColumnBuilderDataType;
+    isArray?: boolean;
+    inverse?: boolean;
+}
+export interface PodColumnInterface {
+    name: string;
+    dataType: 'string' | 'integer' | 'datetime' | 'boolean';
+    options: PodColumnOptions;
+    predicate?: string;
+}
+export type ColumnBuilderDataType = 'string' | 'integer' | 'datetime' | 'boolean' | 'json' | 'object' | 'array' | 'uri';
+type RdfTermInput = string | {
+    value: string;
+} | {
+    term?: {
+        value: string;
+    };
+};
+export declare class ColumnBuilder<TType extends ColumnBuilderDataType, TElement extends ColumnBuilderDataType | null = null, TNotNull extends boolean = false, THasDefault extends boolean = false> {
+    readonly name: string;
+    readonly dataType: TType;
+    options: PodColumnOptions;
+    private _predicateUri?;
+    readonly elementType: TElement;
+    constructor(name: string, dataType: TType, options?: PodColumnOptions, predicate?: string, elementType?: TElement);
+    formatValue(value: any): string | string[];
+    private formatSingleValue;
+    parseValue(rdfValue: string, datatypeIri?: string): any;
+    private parseSingleValue;
+    primaryKey(): ColumnBuilder<TType, TElement, true, THasDefault>;
+    notNull(): ColumnBuilder<TType, TElement, true, THasDefault>;
+    predicate(uri: RdfTermInput): ColumnBuilder<TType, TElement, TNotNull, THasDefault>;
+    default(value: unknown): ColumnBuilder<TType, TElement, TNotNull, true>;
+    defaultNow(): ColumnBuilder<TType, TElement, TNotNull, true>;
+    inverse(value?: boolean): ColumnBuilder<TType, TElement, TNotNull, THasDefault>;
+    /**
+     * 设置引用目标
+     *
+     * 支持三种输入格式：
+     * 1. class URI 字符串 (https://...) - 从 tableRegistry 按 class 查找
+     * 2. 表名字符串 (非 URL 格式) - 从 tableNameRegistry 按表名查找
+     * 3. PodTable 对象 - 直接使用，优先级最高
+     *
+     * @example
+     * // 使用 class URI（自动推导表）
+     * author: uri('author').reference('https://schema.org/Person')
+     *
+     * // 使用表名（解决同 class 多表歧义）
+     * author: uri('author').reference('users_public')
+     *
+     * // 使用表对象（类型安全，但注意循环依赖）
+     * author: uri('author').reference(usersTable)
+     */
+    reference(target: string | PodTable): ColumnBuilder<TType, TElement, TNotNull, THasDefault>;
+    array(): ColumnBuilder<'array', TType, TNotNull, THasDefault>;
+    getPredicateUri(): string | undefined;
+}
+type ColumnValueType<T extends ColumnBuilderDataType> = T extends 'string' ? string : T extends 'integer' ? number : T extends 'boolean' ? boolean : T extends 'datetime' ? Date : T extends 'json' ? unknown : T extends 'object' ? Record<string, unknown> : T extends 'uri' ? string : T extends 'array' ? unknown[] : unknown;
+type ExtractNotNull<T extends PodColumnBase> = T extends PodColumnBase<any, infer TNotNull, any, any> ? TNotNull : false;
+type ExtractHasDefault<T extends PodColumnBase> = T extends PodColumnBase<any, any, infer THasDefault, any> ? THasDefault : false;
+type ColumnIsRequiredForInsert<T extends PodColumnBase> = ExtractNotNull<T> extends true ? ExtractHasDefault<T> extends true ? false : true : false;
+type ColumnAllowsNull<T extends PodColumnBase> = ExtractNotNull<T> extends true ? false : true;
+export type InferColumnType<T extends PodColumnBase> = T extends PodArrayColumn<infer ElementType, any, any> ? ColumnValueType<ElementType>[] : ColumnValueType<T['dataType']>;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type InferTableData<TTable extends PodTable<Record<string, PodColumnBase<any, any, any, any>>>> = Simplify<{
+    [K in keyof TTable['columns']]: InferColumnType<TTable['columns'][K]>;
+}>;
+type InsertRequiredColumns<TTable extends PodTable<Record<string, PodColumnBase<any, any, any, any>>>> = {
+    [K in keyof TTable['columns'] as ColumnIsRequiredForInsert<TTable['columns'][K]> extends true ? K : never]: InferColumnType<TTable['columns'][K]>;
+};
+type InsertOptionalColumns<TTable extends PodTable<Record<string, PodColumnBase<any, any, any, any>>>> = {
+    [K in keyof TTable['columns'] as ColumnIsRequiredForInsert<TTable['columns'][K]> extends true ? never : K]?: InferColumnType<TTable['columns'][K]>;
+};
+export type InferInsertData<TTable extends PodTable<Record<string, PodColumnBase<any, any, any, any>>>> = Simplify<InsertRequiredColumns<TTable> & InsertOptionalColumns<TTable>>;
+type UpdateColumnValue<T extends PodColumnBase<any, any, any, any>> = ColumnAllowsNull<T> extends true ? InferColumnType<T> | null : InferColumnType<T>;
+export type InferUpdateData<TTable extends PodTable<Record<string, PodColumnBase<any, any, any, any>>>> = Simplify<{
+    [K in keyof TTable['columns']]?: UpdateColumnValue<TTable['columns'][K]>;
+}>;
+/**
+ * 合并父类和子类的列定义
+ * 子类列覆盖同名父类列
+ */
+export type MergedColumns<TParent extends Record<string, PodColumnBase<any, any, any, any>>, TChild extends Record<string, PodColumnBase<any, any, any, any>>> = Simplify<{
+    [K in keyof TParent | keyof TChild]: K extends keyof TChild ? TChild[K] : K extends keyof TParent ? TParent[K] : never;
+}>;
+/**
+ * Solid authentication session interface.
+ * Compatible with @inrupt/solid-client-authn-browser Session.
+ */
+export interface SolidSession {
+    info: {
+        isLoggedIn: boolean;
+        webId?: string;
+        sessionId?: string;
+    };
+    fetch: typeof globalThis.fetch;
+}
+/**
+ * Context passed to table hooks.
+ * Provides access to the Solid session and database for operations.
+ */
+export interface HookContext {
+    /**
+     * The Solid authentication session.
+     * Compatible with @inrupt/solid-client-authn-browser Session.
+     * Use session.fetch for authenticated requests and session.info.webId for the user's WebID.
+     */
+    session: SolidSession;
+    /** The table being operated on */
+    table: PodTable<any>;
+    /**
+     * The database instance.
+     * Use this to perform operations on other tables within hooks.
+     *
+     * @example
+     * ```typescript
+     * afterUpdate: async (ctx, record, changes) => {
+     *   if ('starred' in changes && record.starred) {
+     *     await ctx.db.insert(favoriteTable).values({ ... });
+     *   }
+     * }
+     * ```
+     */
+    db: any;
+}
+/**
+ * Hooks for table lifecycle events.
+ * Use hooks to implement custom logic like:
+ * - Updating Profile when resources are published
+ * - Sending notifications
+ * - Audit logging
+ * - Cascading updates
+ *
+ * @example
+ * const agents = podTable('agents', {
+ *   id: id(),
+ *   name: string('name'),
+ *   public: boolean('public'),
+ * }, {
+ *   type: 'https://vocab.ai/Agent',
+ *   hooks: {
+ *     afterInsert: async (ctx, record) => {
+ *       if (record.public) {
+ *         const pm = new ProfileManager(ctx.session);
+ *         await pm.addToProfile('http://xmlns.com/foaf/0.1/made', record['@id']);
+ *       }
+ *     },
+ *     afterUpdate: async (ctx, record, changes) => {
+ *       if ('public' in changes) {
+ *         const pm = new ProfileManager(ctx.session);
+ *         if (record.public) {
+ *           await pm.addToProfile('http://xmlns.com/foaf/0.1/made', record['@id']);
+ *         } else {
+ *           await pm.removeFromProfile('http://xmlns.com/foaf/0.1/made', record['@id']);
+ *         }
+ *       }
+ *     },
+ *   },
+ * });
+ */
+export interface TableHooks {
+    /** Called after a record is inserted */
+    afterInsert?: (ctx: HookContext, record: Record<string, unknown>) => Promise<void>;
+    /** Called after a record is updated. `changes` contains only the fields that were modified. */
+    afterUpdate?: (ctx: HookContext, record: Record<string, unknown>, changes: Record<string, unknown>) => Promise<void>;
+    /** Called after a record is deleted */
+    afterDelete?: (ctx: HookContext, record: Record<string, unknown>) => Promise<void>;
+}
+export interface PodTableOptions {
+    base?: string;
+    /**
+     * Optional SPARQL 1.1 endpoint URL for SELECT query optimization.
+     *
+     * Can be specified as:
+     * - Relative path from Pod root: `/data/users/-/sparql`
+     * - Full absolute URI: `https://pod.example.com/alice/data/users/-/sparql`
+     *
+     * **Important**: This only affects SELECT queries. INSERT/UPDATE/DELETE
+     * operations always use LDP protocol (PUT/PATCH) for:
+     * - Solid Notifications compatibility (SPARQL UPDATE doesn't trigger notifications)
+     * - ACL permission enforcement through CSS Handler chain
+     *
+     * @example
+     * // Relative path (resolved against Pod URL at runtime)
+     * podTable('users', columns, {
+     *   base: '/data/users/',
+     *   sparqlEndpoint: '/data/users/-/sparql'
+     * })
+     *
+     * @example
+     * // Full absolute URI
+     * podTable('users', columns, {
+     *   base: '/data/users/',
+     *   sparqlEndpoint: 'https://pod.example.com/alice/data/users/-/sparql'
+     * })
+     */
+    sparqlEndpoint?: string;
+    type: RdfTermInput;
+    namespace?: NamespaceConfig;
+    typeIndex?: 'private' | 'public';
+    /**
+     * SAI RegistrySet container path or URL used for SAI registration.
+     * When provided, `db.init()` will register this table with SAI as well.
+     */
+    saiRegistryPath?: string;
+    subClassOf?: RdfTermInput | RdfTermInput[];
+    subjectTemplate?: string;
+    /**
+     * Execution strategy mode (reserved for future use).
+     *
+     * Currently not used - strategy is determined by `sparqlEndpoint`:
+     * - SELECT: uses SPARQL if `sparqlEndpoint` is configured, otherwise LDP
+     * - INSERT/UPDATE/DELETE: always uses LDP for Solid Notifications compatibility
+     *
+     * Note: This is different from physical storage mode (fragment vs document),
+     * which is inferred from `subjectTemplate` by `uriResolver.getResourceMode()`.
+     *
+     * @future May be used for batch update optimization via SPARQL UPDATE
+     */
+    resourceMode?: 'ldp' | 'sparql';
+    autoRegister?: boolean;
+    /**
+     * Lifecycle hooks for table operations.
+     * Use hooks to implement custom logic that runs after insert/update/delete.
+     *
+     * @example
+     * const agents = podTable('agents', {
+     *   id: id(),
+     *   name: string('name'),
+     *   public: boolean('public'),
+     * }, {
+     *   type: 'https://vocab.ai/Agent',
+     *   hooks: {
+     *     afterInsert: async (ctx, record) => {
+     *       if (record.public) {
+     *         const pm = new PublishManager(ctx);
+     *         await pm.addToProfile('http://xmlns.com/foaf/0.1/made', record['@id']);
+     *       }
+     *     },
+     *   },
+     * });
+     */
+    hooks?: TableHooks;
+}
+export interface PodColumnMapping {
+    column: string;
+    predicate: string;
+    kind: 'datatype' | 'object';
+    datatype?: string;
+    referenceTarget?: string;
+    isArray?: boolean;
+    inverse?: boolean;
+}
+export interface PodTableMapping {
+    name: string;
+    type: string;
+    subjectTemplate: string;
+    namespace?: NamespaceConfig;
+    subClassOf?: string[];
+    columns: Record<string, PodColumnMapping>;
+    relations?: Record<string, RelationDefinition>;
+}
+export type RelationKind = 'one' | 'many';
+/**
+ * 联邦查询发现函数类型
+ * 接收父记录，返回用于发现的 WebID 或 Pod URL
+ */
+export type DiscoverFunction<TParent = any> = (parent: TParent) => string | string[] | undefined;
+export interface RelationDefinition {
+    type: RelationKind;
+    /** 目标表或 schema（联邦查询时使用 SolidSchema） */
+    table: PodTable<any> | SolidSchema<any>;
+    fields?: PodColumnBase[];
+    references?: PodColumnBase[];
+    relationName?: string;
+    /** 联邦查询：发现函数，用于从父记录获取 WebID 进行数据发现 */
+    discover?: DiscoverFunction;
+    /** 是否为联邦关系（目标是 SolidSchema） */
+    isFederated?: boolean;
+}
+export declare abstract class PodColumnBase<TType extends ColumnBuilderDataType = ColumnBuilderDataType, TNotNull extends boolean = false, THasDefault extends boolean = false, TElement extends ColumnBuilderDataType | null = null> {
+    name: string;
+    readonly dataType: TType;
+    options: PodColumnOptions;
+    tableName?: string | undefined;
+    static readonly [entityKind] = "PodColumn";
+    readonly _traits: [TNotNull, THasDefault, TElement];
+    constructor(name: string, dataType: TType, options?: PodColumnOptions, tableName?: string | undefined);
+    table?: PodTable<any>;
+    relationName?: string;
+    getPredicate(tableNamespace?: NamespaceConfig): string;
+    isReference(): boolean;
+    getReferenceTarget(): string | undefined;
+    getReferenceTableName(): string | undefined;
+    getReferenceTable(): PodTable | undefined;
+    primaryKey(): this;
+    notNull(): this;
+    default(value: unknown): this;
+    predicate(uri: RdfTermInput): this;
+    /**
+     * 设置引用目标
+     *
+     * 支持三种输入格式：
+     * 1. class URI 字符串 (https://...) - 从 tableRegistry 按 class 查找
+     * 2. 表名字符串 (非 URL 格式) - 从 tableNameRegistry 按表名查找
+     * 3. PodTable 对象 - 直接使用，优先级最高
+     */
+    reference(target: string | PodTable): this;
+    inverse(value?: boolean): this;
+    isInverse(): boolean;
+    formatValue(value: any): string | string[];
+    protected formatSingleValue(value: any): string;
+}
+export type PodColumn = PodColumnBase<ColumnBuilderDataType>;
+/**
+ * PodTable with columns accessible as direct properties.
+ * This type combines PodTable with its column definitions,
+ * allowing `table.columnName` syntax in addition to `table.columns.columnName`.
+ */
+export type PodTableWithColumns<TColumns extends Record<string, PodColumnBase<any, any, any, any>>> = PodTable<TColumns> & TColumns;
+export declare class PodStringColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'string', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodIntegerColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'integer', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodBooleanColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'boolean', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodDateTimeColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'datetime', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodJsonColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'json', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodObjectColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'object', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodUriColumn<TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'uri', TNotNull, THasDefault> {
+    constructor(name: string, options?: PodColumnOptions);
+}
+export declare class PodArrayColumn<TElement extends ColumnBuilderDataType = ColumnBuilderDataType, TNotNull extends boolean = false, THasDefault extends boolean = false> extends PodColumnBase<'array', TNotNull, THasDefault, TElement> {
+    readonly elementType: TElement;
+    constructor(name: string, elementType: TElement, options?: PodColumnOptions);
+}
+/**
+ * Schema 配置选项（不含 base 和 hooks）
+ *
+ * Schema 是纯数据结构定义，不包含 hooks。
+ * Hooks 应该在 db.createTable() 时提供。
+ */
+export type SolidSchemaOptions = Omit<PodTableOptions, 'base' | 'hooks'>;
+/**
+ * Options for db.createTable()
+ *
+ * @example
+ * ```typescript
+ * const userTable = db.createTable(userSchema, {
+ *   base: '/data/users/',
+ *   hooks: {
+ *     afterInsert: async (ctx, record) => {
+ *       // ctx.db is available here
+ *       await ctx.db.insert(auditTable).values({ ... });
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export interface CreateTableOptions {
+    /** Resource base path (relative or absolute IRI) */
+    base: string;
+    /** Lifecycle hooks for table operations */
+    hooks?: TableHooks;
+}
+/**
+ * SolidSchema - 独立的 schema 定义类
+ *
+ * 只包含表的结构信息（列、类型、谓词映射），不包含 base。
+ * 可以通过 .at(base) 方法绑定到具体位置，生成 PodTable。
+ *
+ * @example
+ * // 定义 schema（不绑定位置）
+ * const profileSchema = solidSchema('profile', {
+ *   name: string('name').predicate(FOAF.name),
+ *   avatar: uri('avatar').predicate(FOAF.img),
+ * }, {
+ *   type: FOAF.Person,
+ * });
+ *
+ * // 绑定到具体位置
+ * const myProfile = profileSchema.at('/profile/card.ttl');
+ * const aliceProfile = profileSchema.at('https://alice.pod/profile/card.ttl');
+ */
+export declare class SolidSchema<TColumns extends Record<string, PodColumnBase<any, any, any, any>> = Record<string, PodColumnBase<any, any, any, any>>> {
+    readonly name: string;
+    readonly columns: TColumns;
+    readonly options: SolidSchemaOptions;
+    readonly $kind: "SolidSchema";
+    /** 命名空间配置 */
+    readonly namespace?: NamespaceConfig;
+    /** subject 模板 */
+    readonly subjectTemplate?: string;
+    /** 父类 */
+    readonly subClassOf?: string[];
+    constructor(name: string, columns: TColumns, options: SolidSchemaOptions);
+    /**
+     * 绑定到具体位置，生成 PodTable
+     *
+     * @param base 资源路径（相对路径或绝对 IRI）
+     * @example
+     * const myProfile = profileSchema.at('/profile/card.ttl');
+     * const aliceProfile = profileSchema.at('https://alice.pod/profile/card.ttl');
+     */
+    at(base: string): PodTableWithColumns<TColumns>;
+    /**
+     * 创建继承当前 schema 的子 schema
+     *
+     * 子类会继承父类的所有列，并可以：
+     * - 添加新的属性
+     * - 给继承的属性添加约束（如 notNull、default）
+     * - 但不能修改继承属性的 predicate
+     *
+     * @param name - 子 schema 名称
+     * @param columns - 子类新增或覆盖的列
+     * @param options - 子 schema 选项（必须提供 type）
+     * @returns 包含所有继承列和新列的子 schema
+     *
+     * @example
+     * const secretSchema = solidSchema('secret', {
+     *   id: id(),
+     *   name: string('name').predicate(VOCAB.name),
+     *   createdAt: datetime('createdAt').predicate(VOCAB.createdAt),
+     * }, {
+     *   type: 'https://vocab.example/Secret',
+     * });
+     *
+     * // 创建子 schema
+     * const apiKeySchema = secretSchema.extend('apiKey', {
+     *   // 新增属性
+     *   apiKey: string('apiKey').notNull().predicate(VOCAB.apiKey),
+     *   // 增强父类属性（添加约束，但不能改 predicate）
+     *   name: string('name').notNull(),
+     * }, {
+     *   type: 'https://vocab.example/APIKey',
+     * });
+     *
+     * // apiKeySchema 包含: id, name(notNull), createdAt, apiKey
+     * // apiKeySchema.subClassOf 自动包含 'https://vocab.example/Secret'
+     */
+    extend<TChildName extends string, TChildColumns extends Record<string, ColumnInput>>(name: TChildName, columns: TChildColumns, options: Omit<SolidSchemaOptions, 'subClassOf'>): SolidSchema<MergedColumns<TColumns, ResolvedColumns<TChildColumns>>>;
+    /**
+     * 获取 RDF 类型
+     */
+    get type(): string;
+}
+/**
+ * 创建 SolidSchema（不绑定位置的 schema 定义）
+ *
+ * @example
+ * const profileSchema = solidSchema('profile', {
+ *   name: string('name').predicate(FOAF.name),
+ * }, {
+ *   type: FOAF.Person,
+ * });
+ *
+ * // 使用时绑定位置
+ * const myProfile = profileSchema.at('/profile/card.ttl');
+ */
+export declare function solidSchema<TName extends string, TColumns extends Record<string, ColumnInput>>(name: TName, columns: TColumns, options: SolidSchemaOptions): SolidSchema<ResolvedColumns<TColumns>>;
+/**
+ * 检查目标是否为 SolidSchema
+ */
+export declare function isSolidSchema(target: unknown): target is SolidSchema<any>;
+export declare class PodTable<TColumns extends Record<string, PodColumnBase<any, any, any, any>> = Record<string, PodColumnBase<any, any, any, any>>> {
+    static readonly [entityKind] = "PodTable";
+    config: {
+        name: string;
+        base: string;
+        type: string;
+        namespace?: NamespaceConfig;
+        typeIndex?: 'private' | 'public';
+        saiRegistryPath?: string;
+        subClassOf?: string[];
+        subjectTemplate: string;
+        containerPath?: string;
+        resourcePath?: string;
+        autoRegister?: boolean;
+        hooks?: TableHooks;
+    };
+    mapping: PodTableMapping;
+    relations?: Record<string, RelationDefinition>;
+    private resourcePath;
+    private containerPath;
+    private initialized;
+    private subjectTemplate;
+    private hasCustomSubjectTemplate;
+    private resourceMode?;
+    private sparqlEndpoint?;
+    private registerTypeIndexEnabled;
+    private parentClasses;
+    columns: TColumns;
+    readonly $inferSelect: InferTableData<PodTable<TColumns>>;
+    readonly $inferInsert: InferInsertData<PodTable<TColumns>>;
+    readonly $inferUpdate: InferUpdateData<PodTable<TColumns>>;
+    readonly _: {
+        readonly brand: 'Table';
+        readonly config: PodTableOptions;
+        readonly name: string;
+        readonly schema: string | undefined;
+        readonly columns: TColumns;
+        readonly inferSelect: InferTableData<PodTable<TColumns>>;
+        readonly inferInsert: InferInsertData<PodTable<TColumns>>;
+        readonly inferUpdate: InferUpdateData<PodTable<TColumns>>;
+    };
+    constructor(name: string, columns: TColumns, options: PodTableOptions);
+    getContainerPath(): string;
+    getType(): string;
+    /**
+     * @deprecated 使用 getType()
+     */
+    getRdfClass(): string;
+    getNamespace(): NamespaceConfig | undefined;
+    getSubjectTemplate(): string;
+    /**
+     * 检查是否有用户提供的 subjectTemplate
+     */
+    hasCustomTemplate(): boolean;
+    getSubClassOf(): string[];
+    getMapping(): PodTableMapping;
+    /**
+     * 获取表的 schema 定义（用于联邦查询）
+     *
+     * 返回只包含结构信息的 SolidSchema，不包含 base
+     * 用于 relations() 中的联邦查询，数据位置通过 discover 动态发现
+     *
+     * @example
+     * const friendsRelations = relations(friends, ({ many }) => ({
+     *   posts: many(posts.$schema, {
+     *     discover: (friend) => friend.webId,
+     *   }),
+     * }));
+     */
+    get $schema(): SolidSchema<TColumns>;
+    /**
+     * Generate a relative URI for a record by ID
+     *
+     * This returns a Pod-relative URI that drizzle-solid will automatically
+     * resolve to an absolute URI using the Pod URL at runtime.
+     *
+     * @param id - The record ID (typically a nanoid or user-defined identifier)
+     * @returns Relative URI like '/.data/agents/xK9mN2.ttl' or '/.data/tags.ttl#abc123'
+     *
+     * @example
+     * // Generate URI for a record by its ID
+     * const agentUri = agentTable.resolveUri('xK9mN2pL');
+     * // => '/.data/agents/xK9mN2pL.ttl'
+     *
+     * // Prefer using @id from query results when available
+     * const msg = { maker: existingAgent['@id'], content: 'Hello!' }
+     */
+    resolveUri(id: string): string;
+    private resolveBase;
+    private normalizeBaseInput;
+    private normalizeResourcePath;
+    private deriveContainerPath;
+    private ensureTrailingSlash;
+    getResourcePath(): string;
+    getResourceMode(): 'ldp' | 'sparql' | undefined;
+    getSparqlEndpoint(): string | undefined;
+    shouldRegisterTypeIndex(): boolean;
+    init(initializer: PodTableInitializer): Promise<void>;
+    isInitialized(): boolean;
+    markInitialized(initialized?: boolean): void;
+    /**
+     * 动态更新 base（TypeIndex 自动发现等场景）
+     */
+    setBase(base: string): void;
+    /**
+     * 动态更新 subjectTemplate（SAI DataRegistration 自动发现等场景）
+     */
+    setSubjectTemplate(template: string): void;
+    /**
+     * 动态设置 SPARQL endpoint（自动发现等场景）
+     */
+    setSparqlEndpoint(endpoint: string): void;
+    getColumns(): TColumns;
+    getColumn<TKey extends keyof TColumns>(name: TKey): TColumns[TKey];
+    getColumn(name: string): PodColumnBase | undefined;
+    hasColumn(name: string): boolean;
+    private resolveSubjectTemplate;
+    private buildDefaultSubjectTemplate;
+    private buildTableMapping;
+    private buildColumnMapping;
+    private inferColumnDatatype;
+    private normalizeParents;
+}
+export interface PodTableInitializer {
+    registerTable(table: PodTable<any>): Promise<void>;
+}
+export declare function boolean(name: string, options?: PodColumnOptions): ColumnBuilder<'boolean'>;
+export declare function timestamp(name: string, options?: PodColumnOptions): ColumnBuilder<'datetime'>;
+export declare function json(name: string, options?: PodColumnOptions): ColumnBuilder<'json'>;
+export declare function object(name: string, options?: PodColumnOptions): ColumnBuilder<'object'>;
+export declare function uri(name: string, options?: PodColumnOptions): ColumnBuilder<'uri'>;
+export declare function iri(name: string, options?: PodColumnOptions): ColumnBuilder<'uri'>;
+export declare function podString(name: string, options?: PodColumnOptions): PodStringColumn;
+export declare function podInteger(name: string, options?: PodColumnOptions): PodIntegerColumn;
+export declare function podBoolean(name: string, options?: PodColumnOptions): PodBooleanColumn;
+export declare function podDateTime(name: string, options?: PodColumnOptions): PodDateTimeColumn;
+export declare function podJson(name: string, options?: PodColumnOptions): PodJsonColumn;
+export declare function podObject(name: string, options?: PodColumnOptions): PodObjectColumn;
+export declare function id(name?: string, options?: PodColumnOptions): PodStringColumn;
+export declare function string(name: string, options?: PodColumnOptions): ColumnBuilder<'string'>;
+export declare function int(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function integer(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function date(name: string, options?: PodColumnOptions): ColumnBuilder<'datetime'>;
+export declare function datetime(name: string, options?: PodColumnOptions): ColumnBuilder<'datetime'>;
+export declare function text(name: string, options?: PodColumnOptions): ColumnBuilder<'string'>;
+export declare function varchar(name: string, options?: PodColumnOptions): ColumnBuilder<'string'>;
+export declare function char(name: string, options?: PodColumnOptions): ColumnBuilder<'string'>;
+export declare function bigint(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function smallint(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function tinyint(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function mediumint(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function serial(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function real(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function decimal(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function numeric(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function float(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function double(name: string, options?: PodColumnOptions): ColumnBuilder<'integer'>;
+export declare function jsonb(name: string, options?: PodColumnOptions): ColumnBuilder<'json'>;
+type ColumnInput = PodColumnBase | ColumnBuilder<ColumnBuilderDataType, ColumnBuilderDataType | null, boolean, boolean>;
+type ResolveColumn<T> = T extends ColumnBuilder<'string', any, infer TNotNull, infer THasDefault> ? PodStringColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'integer', any, infer TNotNull, infer THasDefault> ? PodIntegerColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'boolean', any, infer TNotNull, infer THasDefault> ? PodBooleanColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'datetime', any, infer TNotNull, infer THasDefault> ? PodDateTimeColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'json', any, infer TNotNull, infer THasDefault> ? PodJsonColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'object', any, infer TNotNull, infer THasDefault> ? PodObjectColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'uri', any, infer TNotNull, infer THasDefault> ? PodUriColumn<TNotNull, THasDefault> : T extends ColumnBuilder<'array', infer TElement, infer TNotNull, infer THasDefault> ? PodArrayColumn<TElement extends ColumnBuilderDataType ? TElement : ColumnBuilderDataType, TNotNull, THasDefault> : T extends PodColumnBase ? T : PodColumnBase;
+type ResolvedColumns<T extends Record<string, ColumnInput>> = {
+    [K in keyof T]: ResolveColumn<T[K]>;
+};
+type RelationBuilder = {
+    one: <T extends PodTable<any> | SolidSchema<any>>(table: T, options?: RelationOptions<T>) => RelationDefinition;
+    many: <T extends PodTable<any> | SolidSchema<any>>(table: T, options?: RelationOptions<T>) => RelationDefinition;
+};
+export interface RelationOptions<T = PodTable<any> | SolidSchema<any>> {
+    fields?: PodColumnBase[];
+    references?: PodColumnBase[];
+    relationName?: string;
+    /**
+     * 联邦查询：发现函数
+     * 用于从父记录获取 WebID，然后通过 .well-known/solid 发现目标数据位置
+     *
+     * @example
+     * posts: many(posts.$schema, {
+     *   discover: (friend) => friend.webId,
+     * })
+     */
+    discover?: DiscoverFunction;
+}
+export declare function podTable<TName extends string, TColumns extends Record<string, ColumnInput>>(name: TName, columns: TColumns, options: PodTableOptions): PodTableWithColumns<ResolvedColumns<TColumns>>;
+export declare function relations<TTable extends PodTable<any>>(table: TTable, builder: (helpers: RelationBuilder) => Record<string, RelationDefinition>): Record<string, RelationDefinition>;
+export declare const RDF_PREDICATES: {
+    readonly SCHEMA_NAME: "https://schema.org/name";
+    readonly SCHEMA_EMAIL: "https://schema.org/email";
+    readonly SCHEMA_IDENTIFIER: "https://schema.org/identifier";
+    readonly SCHEMA_DATE_CREATED: "https://schema.org/dateCreated";
+    readonly SCHEMA_DATE_MODIFIED: "https://schema.org/dateModified";
+    readonly SCHEMA_DESCRIPTION: "https://schema.org/description";
+    readonly SCHEMA_URL: "https://schema.org/url";
+    readonly SCHEMA_TITLE: "https://schema.org/title";
+    readonly SCHEMA_TEXT: "https://schema.org/text";
+    readonly SCHEMA_AUTHOR: "https://schema.org/author";
+    readonly SCHEMA_DATE_PUBLISHED: "https://schema.org/datePublished";
+    readonly FOAF_NAME: "http://xmlns.com/foaf/0.1/name";
+    readonly FOAF_MBOX: "http://xmlns.com/foaf/0.1/mbox";
+    readonly FOAF_HOMEPAGE: "http://xmlns.com/foaf/0.1/homepage";
+    readonly DC_TITLE: "http://purl.org/dc/terms/title";
+    readonly DC_DESCRIPTION: "http://purl.org/dc/terms/description";
+    readonly DC_CREATED: "http://purl.org/dc/terms/created";
+    readonly DC_MODIFIED: "http://purl.org/dc/terms/modified";
+};
+export declare const RDF_CLASSES: {
+    readonly SCHEMA_PERSON: "https://schema.org/Person";
+    readonly SCHEMA_BLOG_POSTING: "https://schema.org/BlogPosting";
+    readonly SCHEMA_ARTICLE: "https://schema.org/Article";
+    readonly SCHEMA_ORGANIZATION: "https://schema.org/Organization";
+    readonly SCHEMA_EVENT: "https://schema.org/Event";
+    readonly SCHEMA_PLACE: "https://schema.org/Place";
+    readonly FOAF_PERSON: "http://xmlns.com/foaf/0.1/Person";
+    readonly FOAF_ORGANIZATION: "http://xmlns.com/foaf/0.1/Organization";
+    readonly APP_USER: "https://myapp.com/vocab#User";
+    readonly APP_POST: "https://myapp.com/vocab#Post";
+    readonly APP_COMMENT: "https://myapp.com/vocab#Comment";
+    readonly APP_TAG: "https://myapp.com/vocab#Tag";
+};
+export type PodColumnType = PodStringColumn | PodIntegerColumn | PodBooleanColumn | PodDateTimeColumn;
+export {};
+//# sourceMappingURL=pod-table.d.ts.map