@undefineds.co/xpod 0.4.17 → 0.4.19

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/pod-dialect.d.ts

@@ -0,0 +1,324 @@
+import { entityKind } from 'drizzle-orm';
+import { SQL } from 'drizzle-orm';
+import { PodTable } from './schema';
+import { QueryCondition } from './query-conditions';
+import { ASTToSPARQLConverter, type SPARQLQuery } from './ast-to-sparql';
+import { ComunicaSPARQLExecutor } from './sparql-executor';
+import { TypeIndexManager, TypeIndexEntry, TypeIndexConfig, DiscoveredTable } from './typeindex-manager';
+import { DataDiscovery } from './discovery';
+import type { ExecutionStrategy } from './execution';
+import type { TableResourceDescriptor } from './execution/pod-executor-types';
+import { UriResolverImpl } from './uri';
+import type { SelectQueryPlan } from './select-plan';
+import type { InsertQueryPlan, UpdateQueryPlan, DeleteQueryPlan } from './pod-session';
+import { ShapeManager } from './shape';
+import type { ResourceResolver } from './resource-resolver';
+import type { SPARQLQueryEngineFactory } from './sparql-engine';
+export interface SolidAuthSession {
+    info: {
+        isLoggedIn: boolean;
+        webId?: string;
+        sessionId?: string;
+        clientId?: string;
+        client_id?: string;
+        podUrl?: string;
+    };
+    fetch: typeof fetch;
+    login?: (options?: Record<string, unknown>) => Promise<void>;
+    logout?: () => Promise<void>;
+}
+import type { ChannelType } from './notifications';
+export interface PodDialectConfig {
+    session: SolidAuthSession;
+    typeIndex?: TypeIndexConfig;
+    createQueryEngine?: SPARQLQueryEngineFactory;
+    /** Explicit Pod base URL for IdP/SP split deployments. */
+    podUrl?: string;
+    disableInteropDiscovery?: boolean;
+    /**
+     * Controls implicit LDP container/resource probes before ORM operations.
+     *
+     * - best-effort: register schema metadata, but defer LDP preparation to write time. This is the default.
+     * - strict: fail when preparation fails.
+     * - off: do not preflight resource preparation; let direct LDP reads/writes surface real failures.
+     */
+    resourcePreparation?: 'strict' | 'best-effort' | 'off';
+    /**
+     * 通知通道偏好顺序，默认 ['streaming-http', 'websocket']
+     * 会根据服务器支持的通道自动选择第一个匹配的
+     */
+    preferredChannels?: ChannelType[];
+    /**
+     * Storage 缓存过期时间（毫秒），默认 5 分钟
+     * 用于 IdP-SP 分离场景，控制从 profile 重新读取 pim:storage 的频率
+     */
+    storageTTL?: number;
+    /**
+     * 启用 debug 模式，输出查询信息
+     */
+    debug?: boolean;
+}
+export interface PodOperation {
+    type: 'select' | 'insert' | 'update' | 'delete';
+    table: PodTable;
+    sql?: SQL;
+    data?: unknown;
+    where?: Record<string, unknown> | QueryCondition;
+    select?: Record<string, unknown>;
+    values?: unknown | unknown[];
+    plan?: SelectQueryPlan | InsertQueryPlan | UpdateQueryPlan | DeleteQueryPlan;
+    joins?: Array<{
+        type: 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin' | 'crossJoin';
+        table: PodTable;
+        condition: unknown;
+    }>;
+    limit?: number;
+    offset?: number;
+    orderBy?: Array<{
+        column: string;
+        direction: 'asc' | 'desc';
+    }>;
+    distinct?: boolean;
+}
+export declare class PodDialect {
+    static readonly [entityKind] = "PodDialect";
+    private runtime;
+    private services;
+    private podUrl;
+    private webId;
+    private sparqlConverter;
+    private sparqlExecutor;
+    private ldpExecutor;
+    private strategyFactory;
+    private executor;
+    private typeIndexManager;
+    private discovery;
+    private shapeManager;
+    private resolverFactory;
+    private uriResolver;
+    config: PodDialectConfig;
+    private registeredTables;
+    private preparedContainers;
+    private preparedResources;
+    private shortIdSubjectIndex;
+    private debugLogger;
+    private currentTableRegistry;
+    private currentTableNameRegistry;
+    constructor(config: PodDialectConfig);
+    /**
+     * Get the ResourceResolver for a table
+     */
+    getResolver(table: PodTable): ResourceResolver;
+    private buildShortIdSubjectIndexKey;
+    registerResourceSubject(table: PodTable, subject: string): void;
+    unregisterResourceSubject(table: PodTable, subject: string): void;
+    lookupIndexedResourceSubject(table: PodTable, id: string): string | null;
+    /**
+     * Get the ExecutionStrategy for a table
+     */
+    getStrategy(table: PodTable): ExecutionStrategy;
+    /**
+     * 获取 ShapeManager 实例
+     */
+    getShapeManager(): ShapeManager;
+    /**
+     * 获取 UriResolver 实例
+     */
+    getUriResolver(): UriResolverImpl;
+    /**
+     * 获取 DataDiscovery 实例
+     */
+    getDiscovery(): DataDiscovery;
+    /**
+     * 设置 schema（表注册表）
+     * 用于 URI 引用字段的自动补全
+     *
+     * 构建两个注册表：
+     * - tableRegistry: rdfClass -> tables[]（同一 class 可能对应多个表）
+     * - tableNameRegistry: tableName -> table（用于明确指定表名时查找）
+     */
+    setSchema(schema: Record<string, unknown>): void;
+    private refreshBaseUrlFromRuntime;
+    private findSubjectsForCondition;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    private extractUserPathFromWebId;
+    resolveTableResource(table: PodTable): TableResourceDescriptor;
+    /**
+     * Resolve LDP container/resource URLs for a table.
+     *
+     * Always returns the physical LDP storage location, regardless of whether
+     * the table has a sparqlEndpoint configured. SPARQL strategy will resolve
+     * the endpoint URL separately via table.getSparqlEndpoint().
+     */
+    private resolveTableUrls;
+    private resolveLdpResource;
+    private resourceExists;
+    private normalizeResourceUrl;
+    private normalizeContainerKey;
+    private normalizeResourceKey;
+    private isStorageRootContainer;
+    private markContainerPrepared;
+    private markResourcePrepared;
+    private isAbsoluteUrl;
+    private resolveAbsoluteUrl;
+    private ensureResourceExists;
+    executeOnResource(resourceUrl: string, sparqlQuery: SPARQLQuery, descriptor?: TableResourceDescriptor): Promise<unknown[]>;
+    /**
+     * Get the appropriate fetch function for a SPARQL endpoint
+     * - Same-origin endpoints (e.g., CSS SPARQL sidecar): use authenticated session.fetch
+     * - Cross-origin endpoints: use unauthenticated fetch (standard SPARQL endpoint behavior)
+     */
+    private getFetchForEndpoint;
+    private executeOnSparqlEndpoint;
+    /**
+     * 确保表有 resourcePath，如果没有则从 TypeIndex 自动发现
+     * 如果设置了 typeIndex，优先使用发现的位置（覆盖配置的 base）
+     */
+    private ensureTableResourcePath;
+    /**
+     * 尝试自动发现 SPARQL endpoint
+     * 按约定：${base}/-/sparql
+     * 使用 OPTIONS 做能力探测，因为 xpod sidecar 不接受 HEAD。
+     */
+    private tryDiscoverSparqlEndpoint;
+    query(operation: PodOperation): Promise<unknown[]>;
+    /**
+     * Collect all resource URLs involved in a query plan.
+     * Used for resolving data sources for SPARQL queries.
+     */
+    private collectSelectSources;
+    private buildIdInConditionFromSubjects;
+    private isInsertPlan;
+    private isUpdatePlan;
+    private isDeletePlan;
+    private isSelectPlan;
+    private buildSubjectLookupPlan;
+    private isQueryConditionNode;
+    private extractSubjectFromRow;
+    private conditionTargetsIdentifier;
+    private rewriteIdentifierConditionWithSubjects;
+    private ensureIdentifierCondition;
+    private rewriteWhereConditionWithSubjects;
+    executeSql(sql: SQL, table: PodTable): Promise<unknown[]>;
+    addNamespace(prefix: string, uri: string): void;
+    getConfig(): {
+        podUrl: string;
+        webId: string;
+        connected: boolean;
+    };
+    /**
+     * 获取认证的 fetch 函数
+     * 用于需要认证访问的操作（如 Notifications）
+     */
+    getAuthenticatedFetch(): typeof fetch;
+    getSPARQLConverter(): ASTToSPARQLConverter;
+    getSPARQLExecutor(): ComunicaSPARQLExecutor;
+    getPodUrl(): string;
+    /**
+     * 获取用户的 WebID
+     */
+    getWebId(): string;
+    /**
+     * 发现特定 RDF 类型的数据位置
+     * 通过 TypeIndex 和 Interop 发现
+     *
+     * @param rdfClass RDF 类型 URI
+     * @returns 数据位置列表
+     */
+    discoverDataLocations(rdfClass: string, options?: import('./discovery').DiscoverOptions): Promise<import('./discovery').DataLocation[]>;
+    /**
+     * 获取所有数据注册信息
+     */
+    discoverAll(): Promise<import('./discovery').DataRegistrationInfo[]>;
+    /**
+     * 按应用 ID 发现数据位置
+     */
+    discoverByApp(appId: string): Promise<import('./discovery').DataLocation[]>;
+    addSource(source: string): void;
+    removeSource(source: string): void;
+    getSources(): string[];
+    addSourcesFromTypeIndex(): Promise<void>;
+    queryContainer(containerPath: string, sql: SQL, table: PodTable): Promise<unknown[]>;
+    getPodMetadata(): Promise<unknown>;
+    private stripSPARQLProlog;
+    private looksLikeRawSQL;
+    private inferSPARQLQueryType;
+    executeSPARQL(query: string): Promise<unknown[]>;
+    transaction<T>(transaction: (tx: PodDialect) => Promise<T>): Promise<T>;
+    getResourcePreparationMode(): NonNullable<PodDialectConfig['resourcePreparation']>;
+    shouldSkipResourcePreparation(): boolean;
+    shouldUseWriteTimeResourcePreparation(): boolean;
+    shouldContinueAfterResourcePreparationError(): boolean;
+    /**
+     * Prepare and optionally register a resource mapping.
+     */
+    registerTable(table: PodTable): Promise<void>;
+    /**
+     * 查找用户的 TypeIndex
+     */
+    findTypeIndex(): Promise<string | null>;
+    /**
+     * 创建 TypeIndex
+     */
+    createTypeIndex(): Promise<string>;
+    /**
+     * 发现已注册的类型
+     */
+    discoverTypes(typeIndexUrl?: string): Promise<TypeIndexEntry[]>;
+    /**
+     * 自动发现和注册类型（用于数据消费方）
+     */
+    autoDiscoverAndRegister(webId?: string): Promise<TypeIndexEntry[]>;
+    /**
+     * 从 Profile 中自动发现类型（不依赖 TypeIndex）
+     */
+    discoverTypesFromProfile(): Promise<TypeIndexEntry[]>;
+    /**
+     * 发现特定的类型定义（按需发现）
+     * @param rdfClassUri 要发现的 RDF 类型 URI
+     */
+    discoverSpecificType(rdfClassUri: string): Promise<TypeIndexEntry | null>;
+    /**
+     * 发现多个特定类型
+     * @param rdfClassUris 要发现的 RDF 类型 URI 数组
+     */
+    discoverSpecificTypes(rdfClassUris: string[]): Promise<TypeIndexEntry[]>;
+    /**
+     * 发现并创建可用的表定义
+     * @param rdfClassUri 要发现的 RDF 类型 URI
+     * @returns 可用的表定义，如果未找到则返回 null
+     */
+    discoverTable(rdfClassUri: string): Promise<DiscoveredTable | null>;
+    /**
+     * 发现并创建多个可用的表定义
+     * @param rdfClassUris 要发现的 RDF 类型 URI 数组
+     * @returns 可用的表定义数组
+     */
+    discoverTables(rdfClassUris: string[]): Promise<DiscoveredTable[]>;
+    /**
+     * 检查类型是否已注册
+     */
+    isTypeRegistered(type: string, typeIndexUrl?: string): Promise<boolean>;
+    /**
+     * 获取 TypeIndex 管理器
+     */
+    getTypeIndexManager(): TypeIndexManager;
+    private ensureContainerExists;
+    private createContainerWithRetry;
+    private sleep;
+    private readErrorResponseBody;
+    private formatResourcePreparationError;
+    /**
+     * 获取父容器 URL
+     * 例如: https://pod.com/alice/data/users/ -> https://pod.com/alice/data/
+     */
+    private getParentContainer;
+    /**
+     * List all resources in a container
+     * Uses LDP containment triples to discover resources
+     */
+    private listContainerResources;
+}
+//# sourceMappingURL=pod-dialect.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/pod-discovery.d.ts

@@ -0,0 +1,20 @@
+export interface PodContainer {
+    url: string;
+    name?: string;
+    description?: string;
+}
+export interface AuthenticationResult {
+    webId?: string;
+    isLoggedIn: boolean;
+    sessionId?: string;
+}
+export declare class PodDiscovery {
+    private fetchFn;
+    constructor(fetchFn?: typeof fetch);
+    discoverContainers(webId: string): Promise<PodContainer[]>;
+    authenticateWithProvider(oidcIssuer: string): Promise<AuthenticationResult>;
+    createContainer(parentUrl: string, name: string): Promise<string>;
+}
+export declare function discoverPodContainers(webId: string, fetchFn?: typeof fetch): Promise<PodContainer[]>;
+export declare function authenticateWithSolid(oidcIssuer: string): Promise<AuthenticationResult>;
+//# sourceMappingURL=pod-discovery.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/pod-session.d.ts

@@ -0,0 +1,52 @@
+import { entityKind } from 'drizzle-orm';
+import { SQL } from 'drizzle-orm';
+import { PodDialect, type PodOperation } from './pod-dialect';
+import { PodTable } from './schema';
+import { SelectQueryBuilder } from './query-builders/select-query-builder';
+import { InsertQueryBuilder } from './query-builders/insert-query-builder';
+import { UpdateQueryBuilder } from './query-builders/update-query-builder';
+import { DeleteQueryBuilder } from './query-builders/delete-query-builder';
+import type { InsertQueryPlan, UpdateQueryPlan, DeleteQueryPlan, SelectFieldMap } from './query-builders/types';
+export type { SelectFieldMap, InsertQueryPlan, UpdateQueryPlan, DeleteQueryPlan };
+export type { PodOperation } from './pod-dialect';
+export { SelectQueryBuilder, InsertQueryBuilder, UpdateQueryBuilder, DeleteQueryBuilder };
+type GenericPodTable = PodTable<any>;
+export declare class PodAsyncSession {
+    private dialect;
+    private _schema?;
+    private options;
+    static readonly [entityKind] = "PodAsyncSession";
+    constructor(dialect: PodDialect, _schema?: unknown | undefined, options?: {
+        logger?: boolean;
+    });
+    /**
+     * 获取会话关联的 schema
+     */
+    getSchema(): unknown;
+    /**
+     * 检查连接状态
+     */
+    isConnected(): boolean;
+    /**
+     * 获取方言实例
+     */
+    getDialect(): PodDialect;
+    /**
+     * 获取会话选项
+     */
+    getOptions(): {
+        logger?: boolean;
+    };
+    private ensureInitialized;
+    execute(operation: PodOperation): Promise<unknown[]>;
+    private updateSubjectIndex;
+    private resolveOperationSubjects;
+    private getKnownRowIri;
+    executeSql(sql: SQL, table: GenericPodTable): Promise<unknown[]>;
+    select<TTable extends GenericPodTable>(fields?: SelectFieldMap): SelectQueryBuilder<TTable>;
+    insert<TTable extends GenericPodTable>(table: TTable): InsertQueryBuilder<TTable>;
+    update<TTable extends GenericPodTable>(table: TTable): UpdateQueryBuilder<TTable>;
+    delete<TTable extends GenericPodTable>(table: TTable): DeleteQueryBuilder<TTable>;
+    transaction<T>(transaction: (tx: PodAsyncSession) => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=pod-session.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/profile-manager.d.ts

@@ -0,0 +1,90 @@
+/**
+ * ProfileManager - Utility class for managing user's Profile document.
+ *
+ * Use this in table hooks to add/remove links from the user's Profile.
+ *
+ * @example
+ * 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']);
+ *     }
+ *   },
+ * }
+ */
+import type { SolidSession } from './schema';
+/**
+ * Manages links in the user's Profile document.
+ * Use this to implement publish/unpublish patterns or manage social connections.
+ *
+ * @example
+ * // In a table hook
+ * const pm = new ProfileManager(ctx.session);
+ *
+ * // Publish a resource (link via foaf:made)
+ * await pm.addToProfile('http://xmlns.com/foaf/0.1/made', agentUri);
+ *
+ * // Add a friend (link via foaf:knows)
+ * await pm.addToProfile('http://xmlns.com/foaf/0.1/knows', friendWebId);
+ *
+ * // Add an interest
+ * await pm.addToProfile('http://xmlns.com/foaf/0.1/interest', topicUri);
+ */
+export declare class ProfileManager {
+    private fetchFn;
+    private webId;
+    /**
+     * Create a ProfileManager instance.
+     *
+     * @param session - The Solid authentication session (compatible with Inrupt Session)
+     *
+     * @example
+     * // In a table hook
+     * afterInsert: async (ctx, record) => {
+     *   const pm = new ProfileManager(ctx.session);
+     *   await pm.addToProfile('foaf:made', record['@id']);
+     * }
+     */
+    constructor(session: SolidSession);
+    /**
+     * Add a link from the user's Profile to a target URI.
+     *
+     * @param predicate - The RDF predicate to use (e.g., 'http://xmlns.com/foaf/0.1/made')
+     * @param targetUri - The URI to link to (e.g., the resource's @id)
+     *
+     * @example
+     * await pm.addToProfile('http://xmlns.com/foaf/0.1/made', record['@id']);
+     */
+    addToProfile(predicate: string, targetUri: string): Promise<void>;
+    /**
+     * Remove a link from the user's Profile to a target URI.
+     *
+     * @param predicate - The RDF predicate (e.g., 'http://xmlns.com/foaf/0.1/made')
+     * @param targetUri - The URI to unlink (e.g., the resource's @id)
+     *
+     * @example
+     * await pm.removeFromProfile('http://xmlns.com/foaf/0.1/made', record['@id']);
+     */
+    removeFromProfile(predicate: string, targetUri: string): Promise<void>;
+    /**
+     * Check if a resource is currently linked from the Profile.
+     *
+     * @param predicate - The RDF predicate to check
+     * @param targetUri - The URI to check for
+     * @returns true if the link exists, false otherwise
+     */
+    isLinked(predicate: string, targetUri: string): Promise<boolean>;
+    /**
+     * Get all URIs linked from the Profile with the given predicate.
+     *
+     * @param predicate - The RDF predicate to query
+     * @returns Array of linked URIs
+     */
+    getLinkedResources(predicate: string): Promise<string[]>;
+    /**
+     * Get the user's WebID.
+     */
+    getWebId(): string;
+}
+//# sourceMappingURL=profile-manager.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/query-builders/default-id-template.d.ts

@@ -0,0 +1,10 @@
+import type { PodTable } from '../schema';
+export interface DefaultIdTemplateOptions {
+    key: string;
+    row?: Record<string, unknown>;
+    now?: Date;
+    resource?: PodTable<any>;
+    links?: Record<string, PodTable<any>>;
+}
+export declare function renderDefaultIdTemplate(template: string, options: DefaultIdTemplateOptions): string;
+//# sourceMappingURL=default-id-template.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/query-builders/delete-query-builder.d.ts

@@ -0,0 +1,31 @@
+import { entityKind, SQL } from 'drizzle-orm';
+import { PodTable } from '../schema';
+import { PodAsyncSession } from '../pod-session';
+import { type PublicQueryCondition, type PublicWhereObject } from '../query-conditions';
+import { DeleteQueryPlan, type SelectFieldMap } from './types';
+export declare class DeleteQueryBuilder<TTable extends PodTable<any> = PodTable<any>> {
+    session: PodAsyncSession;
+    table: TTable;
+    static readonly [entityKind] = "DeleteQueryBuilder";
+    whereConditions?: Record<string, any>;
+    sql?: SQL;
+    private conditionTree?;
+    private returningFields?;
+    constructor(session: PodAsyncSession, table: TTable);
+    where(conditions: PublicWhereObject | SQL | PublicQueryCondition): this;
+    returning(fields?: SelectFieldMap): this;
+    whereByIri(iri: string): this;
+    private isQueryCondition;
+    private convertQueryConditionToSimple;
+    private normalizeWhereConditionsForDelete;
+    toIR: () => DeleteQueryPlan<TTable>;
+    private buildSPARQLQuery;
+    toSPARQL(): import("../ast-to-sparql").SPARQLQuery;
+    toSparql(): import("../ast-to-sparql").SPARQLQuery;
+    execute(): Promise<any[]>;
+    private fetchMatchedRows;
+    private runAfterDeleteHooks;
+    private buildHookContext;
+    then<TResult1 = Awaited<ReturnType<DeleteQueryBuilder<TTable>['execute']>>, TResult2 = never>(onfulfilled?: ((value: Awaited<ReturnType<DeleteQueryBuilder<TTable>['execute']>>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+}
+//# sourceMappingURL=delete-query-builder.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/query-builders/helpers.d.ts

@@ -0,0 +1,11 @@
+import { QueryCondition } from '../query-conditions';
+import type { SPARQLQuery } from '../ast-to-sparql';
+import type { SelectFieldMap } from './types';
+export declare function inferSPARQLQueryType(query: string): SPARQLQuery['type'] | undefined;
+export declare function createLiteralCondition(alias: string | undefined, column: string, value: any): QueryCondition;
+export declare function buildConditionTreeFromObject(conditions: Record<string, any> | undefined, alias?: string): QueryCondition | undefined;
+export declare function resolveRowSubject(row?: Record<string, any> | null): string | undefined;
+export declare function orderRowsBySubjects(rows: Record<string, any>[], subjects: string[]): Record<string, any>[];
+export declare function projectReturningRow(row: Record<string, any>, fields?: SelectFieldMap | true): Record<string, any>;
+export declare function projectReturningRows(rows: Record<string, any>[], fields?: SelectFieldMap | true): Record<string, any>[];
+//# sourceMappingURL=helpers.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/query-builders/index.d.ts

@@ -0,0 +1,7 @@
+export { SelectQueryBuilder } from './select-query-builder';
+export { InsertQueryBuilder } from './insert-query-builder';
+export { UpdateQueryBuilder } from './update-query-builder';
+export { DeleteQueryBuilder } from './delete-query-builder';
+export { renderDefaultIdTemplate, type DefaultIdTemplateOptions } from './default-id-template';
+export type { SelectFieldMap, InsertQueryPlan, UpdateQueryPlan, DeleteQueryPlan } from './types';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/query-builders/insert-query-builder.d.ts

@@ -0,0 +1,37 @@
+import { entityKind, SQL } from 'drizzle-orm';
+import { PodTable, InferInsertData } from '../schema';
+import { PodAsyncSession } from '../pod-session';
+import { InsertQueryPlan, type SelectFieldMap } from './types';
+export declare class InsertQueryBuilder<TTable extends PodTable<any> = PodTable<any>> {
+    session: PodAsyncSession;
+    table: TTable;
+    static readonly [entityKind] = "InsertQueryBuilder";
+    insertValues?: InferInsertData<TTable> | InferInsertData<TTable>[];
+    sql?: SQL;
+    private returningFields?;
+    constructor(session: PodAsyncSession, table: TTable);
+    values(values: InferInsertData<TTable> | InferInsertData<TTable>[] | SQL): this;
+    returning(fields?: SelectFieldMap): this;
+    toIR: () => InsertQueryPlan<TTable>;
+    private buildSPARQLQuery;
+    toSPARQL(): import("../ast-to-sparql").SPARQLQuery;
+    toSparql(): import("../ast-to-sparql").SPARQLQuery;
+    execute(): Promise<any[]>;
+    then<TResult1 = Awaited<ReturnType<InsertQueryBuilder<TTable>['execute']>>, TResult2 = never>(onfulfilled?: ((value: Awaited<ReturnType<InsertQueryBuilder<TTable>['execute']>>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    private fetchReturningRowsBySubjects;
+    private getSubjectUris;
+    /**
+     * Run afterInsert hooks for all inserted records.
+     */
+    private runAfterInsertHooks;
+    /**
+     * Build the HookContext from session info.
+     */
+    private buildHookContext;
+    private getRowsWithDefaults;
+    private applyDefaultValues;
+    private applyDefaultValue;
+    private resolveDefaultValue;
+    private isPrimaryKeyColumn;
+}
+//# sourceMappingURL=insert-query-builder.d.ts.map