@undefineds.co/xpod 0.4.14 → 0.4.16

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

@@ -1,19 +0,0 @@
-import { PodColumnBase } from './schema';
-export type AggregateFunction = 'count' | 'sum' | 'avg' | 'min' | 'max';
-export interface AggregateExpression {
-    kind: 'aggregate';
-    func: AggregateFunction;
-    column?: PodColumnBase | string;
-    distinct?: boolean;
-}
-interface AggregateOptions {
-    distinct?: boolean;
-}
-export declare function count(column?: PodColumnBase | string, options?: AggregateOptions): AggregateExpression;
-export declare function sum(column: PodColumnBase | string, options?: AggregateOptions): AggregateExpression;
-export declare function avg(column: PodColumnBase | string, options?: AggregateOptions): AggregateExpression;
-export declare function min(column: PodColumnBase | string, options?: AggregateOptions): AggregateExpression;
-export declare function max(column: PodColumnBase | string, options?: AggregateOptions): AggregateExpression;
-export declare function isAggregateExpression(value: unknown): value is AggregateExpression;
-export {};
-//# sourceMappingURL=aggregates.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/ast-to-sparql.d.ts

@@ -1,66 +0,0 @@
-import { SQL } from 'drizzle-orm';
-import { PodColumnBase, PodTable } from './schema';
-import { SPARQLQuery } from './sparql/types';
-import { SelectQueryPlan } from './select-plan';
-import { QueryCondition } from './query-conditions';
-import type { UriResolver } from './uri';
-export type { SPARQLQuery };
-interface SimpleSelectOperation {
-    table: PodTable;
-    where?: Record<string, unknown>;
-    limit?: number;
-    offset?: number;
-    orderBy?: Array<{
-        column: string;
-        direction: 'asc' | 'desc';
-    }>;
-    distinct?: boolean;
-}
-interface InsertPlanInput {
-    table: PodTable;
-    rows: Array<Record<string, unknown>>;
-}
-/**
- * Table registry context for URI resolution
- */
-export interface TableRegistryContext {
-    tableRegistry: Map<string, PodTable[]>;
-    tableNameRegistry: Map<string, PodTable>;
-    baseUri?: string;
-    record?: Record<string, unknown>;
-    currentTable?: PodTable;
-}
-export declare class ASTToSPARQLConverter {
-    private podUrl;
-    private webId?;
-    private selectBuilder;
-    private updateBuilder;
-    private expressionBuilder;
-    private tableContext?;
-    private uriResolver;
-    private prefixes;
-    constructor(podUrl: string, webId?: string | undefined, uriResolver?: UriResolver);
-    /**
-     * Set table registry for URI link resolution
-     */
-    setTableRegistry(tableRegistry: Map<string, PodTable[]>, tableNameRegistry: Map<string, PodTable>, baseUri?: string): void;
-    convertSelect(ast: Record<string, unknown>, table: PodTable, targetGraph?: string, fromSources?: string[], allowGraphVariable?: boolean): SPARQLQuery;
-    buildWhereClauseForCondition(whereAst: QueryCondition, table: PodTable): string;
-    convertSelectPlan(plan: SelectQueryPlan, targetGraph?: string, fromSources?: string[], allowGraphVariable?: boolean): SPARQLQuery;
-    convertSimpleSelect(operation: SimpleSelectOperation, targetGraph?: string, fromSources?: string[], allowGraphVariable?: boolean): SPARQLQuery;
-    convertInsert(valuesOrPlan: Array<Record<string, unknown>> | InsertPlanInput, table?: PodTable, targetGraph?: string): SPARQLQuery;
-    convertUpdate(setData: Record<string, unknown>, whereConditions: QueryCondition | Record<string, unknown>, table: PodTable, targetGraph?: string): SPARQLQuery;
-    convertDelete(whereConditions: QueryCondition | Record<string, unknown>, table: PodTable, targetGraph?: string): SPARQLQuery;
-    getPrefixes(): Record<string, string>;
-    addPrefix(prefix: string, uri: string): void;
-    getPredicateForColumnPublic(column: PodColumnBase | string | Record<string, unknown>, table: PodTable): string;
-    formatLiteralValue(value: unknown, column?: PodColumnBase | Record<string, unknown>): string | string[];
-    generateSubjectUri(record: Record<string, unknown>, table: PodTable): string;
-    parseDrizzleAST(sql: SQL, _table?: PodTable): {
-        type: 'select';
-        columns: '*';
-        where: Record<string, never>;
-    };
-    private parseWhereClause;
-}
-//# sourceMappingURL=ast-to-sparql.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/compile-time-types.d.ts

@@ -1,40 +0,0 @@
-import { PodTable, PodTableOptions } from './schema';
-type AnyTypedField = TypedField<string>;
-type TypedFieldMap = Record<string, AnyTypedField>;
-export interface TypedField<T extends string> {
-    name: T;
-    predicate: string;
-    type: 'string' | 'number' | 'boolean' | 'Date';
-    primaryKey?: boolean;
-}
-export type TypedTableDefinition<T extends TypedFieldMap> = {
-    [K in keyof T]: T[K];
-};
-export declare function createTypedTable<T extends TypedFieldMap>(name: string, definition: TypedTableDefinition<T>, options: PodTableOptions): PodTable;
-export declare function field<T extends string>(name: T, predicate: string, type: 'string' | 'number' | 'boolean' | 'Date', options?: {
-    primaryKey?: boolean;
-}): TypedField<T>;
-export declare const CommonFields: {
-    readonly name: (predicate?: string) => TypedField<"name">;
-    readonly email: (predicate?: string) => TypedField<"email">;
-    readonly age: (predicate?: string) => TypedField<"age">;
-    readonly dateCreated: (predicate?: string) => TypedField<"dateCreated">;
-    readonly isActive: (predicate?: string) => TypedField<"isActive">;
-    readonly url: (predicate?: string) => TypedField<"url">;
-    readonly description: (predicate?: string) => TypedField<"description">;
-    readonly identifier: (predicate?: string) => TypedField<"identifier">;
-};
-export declare class TypedTableBuilder<T extends TypedFieldMap> {
-    private name;
-    private options;
-    private definition;
-    constructor(name: string, options: PodTableOptions, definition?: TypedTableDefinition<T>);
-    addField<K extends string>(fieldDef: TypedField<K>): TypedTableBuilder<T & Record<K, TypedField<K>>>;
-    build(): PodTable;
-}
-export declare function typedTable(name: string, options: PodTableOptions): TypedTableBuilder<Record<string, never>>;
-export type TypedTableResult<T extends TypedFieldMap> = {
-    [K in keyof T]: T[K] extends TypedField<string> ? T[K]['type'] extends 'string' ? string : T[K]['type'] extends 'number' ? number : T[K]['type'] extends 'boolean' ? boolean : T[K]['type'] extends 'Date' ? Date : never : never;
-};
-export {};
-//# sourceMappingURL=compile-time-types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/comunica-patch.d.ts

@@ -1,2 +0,0 @@
-export declare const applyComunicaPatches: (requireModule?: NodeRequire | null) => boolean;
-//# sourceMappingURL=comunica-patch.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/conflict-resolution.d.ts

@@ -1,110 +0,0 @@
-import { SolidDataset, Thing } from '@inrupt/solid-client';
-/**
- * 合并策略类型
- */
-export type MergeStrategy = 'last-write-wins' | 'field-level-merge' | 'timestamp-based' | 'user-resolution';
-/**
- * 冲突解析配置
- */
-export interface ConflictResolutionConfig {
-    /** 最大重试次数 */
-    maxRetries?: number;
-    /** 合并策略 */
-    strategy?: MergeStrategy;
-    /** 用户自定义解析函数（当 strategy = 'user-resolution' 时使用） */
-    resolver?: (local: Thing, remote: Thing, predicates: string[]) => Thing;
-    /** 重试延迟（毫秒） */
-    retryDelay?: number;
-    /** 是否启用日志 */
-    logging?: boolean;
-}
-/**
- * 冲突解析结果
- */
-export interface ConflictResolutionResult {
-    success: boolean;
-    retries: number;
-    strategy?: string;
-    error?: string;
-}
-/**
- * 并发写入冲突解析器
- *
- * 处理 412 Precondition Failed 错误（ETag 不匹配），
- * 通过不同的合并策略自动重试保存操作。
- */
-export declare class ConflictResolver {
-    private config;
-    private fetchFn;
-    constructor(fetchFn: typeof fetch, config?: ConflictResolutionConfig);
-    /**
-     * 执行带冲突解析的保存操作
-     *
-     * @param resourceUrl - 资源 URL
-     * @param modifier - 修改函数，接收当前 dataset 并返回修改后的 dataset
-     * @returns 解析结果
-     */
-    saveWithRetry(resourceUrl: string, modifier: (dataset: SolidDataset) => SolidDataset | Promise<SolidDataset>): Promise<ConflictResolutionResult>;
-    /**
-     * 执行带字段级合并的保存操作
-     *
-     * @param resourceUrl - 资源 URL
-     * @param thingUrl - Thing URL
-     * @param localChanges - 本地修改的 Thing
-     * @param predicates - 需要更新的谓词列表
-     * @returns 解析结果
-     */
-    saveThingWithMerge(resourceUrl: string, thingUrl: string, localChanges: Thing, predicates: string[]): Promise<ConflictResolutionResult>;
-    /**
-     * 合并两个 Thing
-     *
-     * @param local - 本地版本（包含我们的修改）
-     * @param remote - 远程版本（最新状态）
-     * @param predicates - 需要合并的谓词列表
-     * @returns 合并后的 Thing
-     */
-    private mergeThings;
-    /**
-     * 字段级合并
-     *
-     * 策略：
-     * - 对于 predicates 中的谓词，使用本地版本
-     * - 对于其他谓词，保留远程版本
-     */
-    private fieldLevelMerge;
-    /**
-     * 基于时间戳的合并
-     *
-     * 策略：
-     * - 如果有 updatedAt 字段，比较时间戳，选择最新的
-     * - 否则 fallback 到 field-level-merge
-     */
-    private timestampBasedMerge;
-    /**
-     * 获取 Thing 的 updatedAt 时间戳
-     */
-    private getUpdatedAt;
-    /**
-     * 获取谓词的值（支持多种类型）
-     */
-    private getPredicateValue;
-    /**
-     * 设置谓词的值（根据类型）
-     *
-     * 注意：这是简化实现，实际使用时应该用 buildThing 模式
-     */
-    private setPredicateValue;
-    /**
-     * 延迟函数
-     */
-    private delay;
-}
-/**
- * 便捷函数：使用默认配置创建冲突解析器
- */
-export declare function createConflictResolver(fetchFn: typeof fetch, config?: ConflictResolutionConfig): ConflictResolver;
-/**
- * 便捷函数：执行单次带重试的保存操作
- */
-export declare function saveWithConflictResolution(fetchFn: typeof fetch, resourceUrl: string, modifier: (dataset: SolidDataset) => SolidDataset | Promise<SolidDataset>, config?: ConflictResolutionConfig): Promise<ConflictResolutionResult>;
-//# sourceMappingURL=conflict-resolution.d.ts.map

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

@@ -1,18 +0,0 @@
-import { PodTable } from '../schema';
-import { DataDiscovery, DataLocation, DiscoverOptions, RegisterOptions, DataRegistrationInfo } from './types';
-export declare class CompositeDiscovery implements DataDiscovery {
-    private strategies;
-    constructor(strategies: DataDiscovery[]);
-    register(table: PodTable, options?: RegisterOptions): Promise<void>;
-    discover(rdfClass: string, options?: DiscoverOptions): Promise<DataLocation[]>;
-    isRegistered(rdfClass: string): Promise<boolean>;
-    /**
-     * 获取所有数据注册 - 聚合所有支持此方法的策略结果
-     */
-    discoverAll(): Promise<DataRegistrationInfo[]>;
-    /**
-     * 按应用 ID 发现数据位置 - 聚合所有支持此方法的策略结果
-     */
-    discoverByApp(appId: string): Promise<DataLocation[]>;
-}
-//# sourceMappingURL=composite-discovery.d.ts.map

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

@@ -1,7 +0,0 @@
-export * from './types';
-export * from './typeindex-discovery';
-export * from './interop-discovery';
-export * from './interop-types';
-export * from './composite-discovery';
-export * from './provider-cache';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,36 +0,0 @@
-import { PodTable } from '../schema';
-import { DataDiscovery, DataLocation, DiscoverOptions, DataRegistrationInfo, RegisterOptions } from './types';
-export declare class InteropDiscovery implements DataDiscovery {
-    private webId;
-    private fetchFn;
-    private clientId?;
-    private shapeTreeCache;
-    constructor(webId: string, fetchFn: typeof fetch, clientId?: string | undefined);
-    private ensureRegistrySet;
-    register(table: PodTable, options?: RegisterOptions): Promise<void>;
-    discover(rdfClass: string, options?: DiscoverOptions): Promise<DataLocation[]>;
-    /**
-     * 按 container 合并原始结果
-     * 同一个 container 的多个 Shape 合并到 shapes 数组中
-     */
-    private mergeByContainer;
-    private discoverDataRegistrationsRaw;
-    private discoverAccessGrantsRaw;
-    isRegistered(rdfClass: string): Promise<boolean>;
-    /**
-     * 按应用 ID 发现所有数据位置
-     * @param appId 应用标识符
-     */
-    discoverByApp(appId: string): Promise<DataLocation[]>;
-    /**
-     * 获取所有数据注册
-     */
-    discoverAll(): Promise<DataRegistrationInfo[]>;
-    private checkShapeTreeMatchesClass;
-    /**
-     * 解析 ShapeTree，获取 expectsType 和 shape URL
-     * 结果会被缓存以提高性能
-     */
-    private resolveShapeTree;
-}
-//# sourceMappingURL=interop-discovery.d.ts.map

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

@@ -1,37 +0,0 @@
-export declare const registrySetSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
-    id: import("../schema").PodStringColumn<false, false>;
-    hasDataRegistry: import("../schema").ColumnBuilder<"array", "uri", false, false>;
-    hasAgentRegistry: import("../schema").ColumnBuilder<"array", "uri", false, false>;
-}>>;
-export declare const dataRegistrySchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
-    id: import("../schema").PodStringColumn<false, false>;
-    hasDataRegistration: import("../schema").ColumnBuilder<"array", "uri", false, false>;
-}>>;
-export declare const dataRegistrationSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
-    id: import("../schema").PodStringColumn<false, false>;
-    registeredShapeTree: import("../schema").ColumnBuilder<"uri", null, false, false>;
-    registeredBy: import("../schema").ColumnBuilder<"uri", null, false, false>;
-    registeredAt: import("../schema").ColumnBuilder<"string", null, false, false>;
-    subjectTemplate: import("../schema").ColumnBuilder<"string", null, false, false>;
-}>>;
-export declare const applicationRegistrationSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
-    id: import("../schema").PodStringColumn<false, false>;
-    registeredAgent: import("../schema").ColumnBuilder<"uri", null, false, false>;
-    hasAccessGrant: import("../schema").ColumnBuilder<"uri", null, false, false>;
-}>>;
-export declare const accessGrantSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
-    id: import("../schema").PodStringColumn<false, false>;
-    grantedBy: import("../schema").ColumnBuilder<"uri", null, false, false>;
-    grantedAt: import("../schema").ColumnBuilder<"string", null, false, false>;
-    grantee: import("../schema").ColumnBuilder<"uri", null, false, false>;
-    hasDataGrant: import("../schema").ColumnBuilder<"array", "uri", false, false>;
-}>>;
-export declare const dataGrantSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
-    id: import("../schema").PodStringColumn<false, false>;
-    registeredShapeTree: import("../schema").ColumnBuilder<"uri", null, false, false>;
-    hasDataRegistration: import("../schema").ColumnBuilder<"uri", null, false, false>;
-    scopeOfGrant: import("../schema").ColumnBuilder<"uri", null, false, false>;
-    accessMode: import("../schema").ColumnBuilder<"array", "uri", false, false>;
-    dataOwner: import("../schema").ColumnBuilder<"uri", null, false, false>;
-}>>;
-//# sourceMappingURL=interop-tables.d.ts.map

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

@@ -1,36 +0,0 @@
-/**
- * Solid Application Interoperability (SAI) 相关的常量和类型定义
- */
-export declare const INTEROP: {
-    readonly NS: "http://www.w3.org/ns/solid/interop#";
-    readonly ApplicationRegistration: "http://www.w3.org/ns/solid/interop#ApplicationRegistration";
-    readonly DataRegistration: "http://www.w3.org/ns/solid/interop#DataRegistration";
-    readonly AccessGrant: "http://www.w3.org/ns/solid/interop#AccessGrant";
-    readonly DataGrant: "http://www.w3.org/ns/solid/interop#DataGrant";
-    readonly RegistrySet: "http://www.w3.org/ns/solid/interop#RegistrySet";
-    readonly DataRegistry: "http://www.w3.org/ns/solid/interop#DataRegistry";
-    readonly hasRegistrySet: "http://www.w3.org/ns/solid/interop#hasRegistrySet";
-    readonly hasDataRegistry: "http://www.w3.org/ns/solid/interop#hasDataRegistry";
-    readonly hasDataRegistration: "http://www.w3.org/ns/solid/interop#hasDataRegistration";
-    readonly registeredShapeTree: "http://www.w3.org/ns/solid/interop#registeredShapeTree";
-    readonly registeredBy: "http://www.w3.org/ns/solid/interop#registeredBy";
-    readonly hasAccessGrant: "http://www.w3.org/ns/solid/interop#hasAccessGrant";
-    readonly hasDataGrant: "http://www.w3.org/ns/solid/interop#hasDataGrant";
-    readonly scopeOfGrant: "http://www.w3.org/ns/solid/interop#scopeOfGrant";
-    readonly dataOwner: "http://www.w3.org/ns/solid/interop#dataOwner";
-    readonly registeredShapeTreeProp: "http://www.w3.org/ns/solid/interop#registeredShapeTree";
-};
-export declare const SHAPETREES: {
-    readonly NS: "http://www.w3.org/ns/shapetrees#";
-    readonly ShapeTree: "http://www.w3.org/ns/shapetrees#ShapeTree";
-    readonly expectsType: "http://www.w3.org/ns/shapetrees#expectsType";
-    readonly shape: "http://www.w3.org/ns/shapetrees#shape";
-};
-/**
- * Undefineds.co vocabulary extensions for Solid
- */
-export declare const UDFS: {
-    readonly NS: "https://vocab.undefineds.co/";
-    readonly subjectTemplate: "https://vocab.undefineds.co/subjectTemplate";
-};
-//# sourceMappingURL=interop-types.d.ts.map

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

@@ -1,99 +0,0 @@
-/**
- * Provider Cache
- *
- * 缓存 Pod 供应商的 .well-known/solid 响应
- * 同一供应商的用户共享缓存，减少重复请求
- */
-/**
- * .well-known/solid 响应内容
- */
-export interface WellKnownResponse {
-    /** 公开 TypeIndex 位置 */
-    typeIndex?: string;
-    /** 私有 TypeIndex 位置 */
-    privateTypeIndex?: string;
-    /** SAI Registry Set 位置 */
-    registrySet?: string;
-    /** OIDC Issuer */
-    oidcIssuer?: string;
-    /** 原始响应（保留未来扩展字段） */
-    raw?: Record<string, string>;
-}
-export declare class ProviderCache {
-    private cache;
-    private ttl;
-    private fetchFn;
-    constructor(options?: {
-        ttl?: number;
-        fetch?: typeof fetch;
-    });
-    /**
-     * 获取 Pod 的 .well-known 信息
-     * 优先使用缓存
-     */
-    getWellKnown(podUrl: string): Promise<WellKnownResponse>;
-    /**
-     * 发现指定类型的数据位置
-     * SAI 优先，TypeIndex 兜底
-     */
-    discover(podUrl: string, type: string, discoverFromSAI: (registrySet: string, type: string) => Promise<string | null>, discoverFromTypeIndex: (typeIndex: string, type: string) => Promise<string | null>): Promise<string | null>;
-    /**
-     * 设置 TTL
-     */
-    setTTL(ms: number): void;
-    /**
-     * 清除缓存
-     */
-    clear(): void;
-    /**
-     * 清除指定供应商的缓存
-     */
-    clearProvider(provider: string): void;
-    /**
-     * 从 Pod URL 提取供应商标识
-     * https://bob.solidcommunity.net/ → solidcommunity.net
-     * https://alice.inrupt.net/ → inrupt.net
-     */
-    private extractProvider;
-    /**
-     * 请求 .well-known/solid
-     */
-    private fetchWellKnown;
-    /**
-     * 解析 Turtle 格式的 .well-known/solid
-     */
-    private parseTurtle;
-    /**
-     * 从行中提取 URL
-     */
-    private extractUrl;
-    /**
-     * 解析 JSON-LD 格式
-     */
-    private parseJsonLd;
-    /**
-     * 从 JSON-LD 值中提取 URL
-     */
-    private extractJsonLdValue;
-    /**
-     * 解析 URL（处理相对路径）
-     */
-    private resolveUrl;
-    /**
-     * 从完整 URL 提取相对路径
-     */
-    private extractPaths;
-    /**
-     * 将完整 URL 转换为相对路径
-     */
-    private toRelativePath;
-    /**
-     * 将缓存的相对路径应用到指定 Pod
-     */
-    private applyToPod;
-    /**
-     * 将相对路径转换为完整 URL
-     */
-    private toAbsoluteUrl;
-}
-//# sourceMappingURL=provider-cache.d.ts.map

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

@@ -1,32 +0,0 @@
-import { PodTable } from '../schema';
-import { TypeIndexManager } from '../typeindex-manager';
-import { DataDiscovery, DataLocation, DiscoverOptions, RegisterOptions } from './types';
-import type { UriResolver } from '../uri';
-/**
- * 基于 TypeIndex 的数据发现实现
- */
-export declare class TypeIndexDiscovery implements DataDiscovery {
-    private manager;
-    private podUrl;
-    private uriResolver;
-    constructor(manager: TypeIndexManager, podUrl: string, uriResolver?: UriResolver);
-    setPodUrl(podUrl: string): void;
-    private getPodUrl;
-    /**
-     * 注册表的类型到 TypeIndex
-     */
-    register(table: PodTable, _options?: RegisterOptions): Promise<void>;
-    /**
-     * 发现某类型数据的位置
-     */
-    discover(rdfClass: string, _options?: DiscoverOptions): Promise<DataLocation[]>;
-    /**
-     * 检查类型是否已注册
-     */
-    isRegistered(rdfClass: string): Promise<boolean>;
-    private getRdfClass;
-    private resolveTableResource;
-    private toAbsolute;
-    private handleRegistrationError;
-}
-//# sourceMappingURL=typeindex-discovery.d.ts.map

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

@@ -1,132 +0,0 @@
-import { PodTable } from '../schema';
-/**
- * 数据注册选项
- */
-export interface RegisterOptions {
-    /** RegistrySet 基础路径（用于自动创建 SAI registry） */
-    registryPath?: string;
-    /** Shape URL - 如果提供，会在 ShapeTree 中引用此 Shape */
-    shapeUrl?: string;
-    /** 自定义容器路径（相对于 DataRegistry） */
-    containerSlug?: string;
-    /** 是否强制重新注册（即使已存在） */
-    force?: boolean;
-}
-/**
- * Shape 信息
- */
-export interface ShapeInfo {
-    /** Shape URL - 实际的 SHACL Shape 定义位置 */
-    url: string;
-    /** ShapeTree URL - SAI 发现时的 ShapeTree 位置 */
-    shapeTree?: string;
-    /** 注册此 Shape 的应用 ID (clientId/appId) */
-    registeredBy?: string;
-    /** 发现来源 */
-    source: 'typeindex' | 'interop' | 'config';
-}
-/**
- * 数据位置信息 - 以 container 为准
- *
- * 一个 container 可能有多个 Shape 描述（来自不同 app 的注册）
- * 数据在同一个位置，但可以用不同的 Shape 来解释
- */
-export interface DataLocation {
-    /** 数据容器 URL - 唯一标识数据位置 */
-    container: string;
-    /** 主体 URI 模式 (可选) - deprecated, use subjectTemplate */
-    subjectPattern?: string;
-    /**
-     * @deprecated Legacy/explicit Subject URI template. Prefer exact base-relative ids.
-     */
-    subjectTemplate?: string;
-    /** 可用的 Shape 列表（按注册顺序） */
-    shapes: ShapeInfo[];
-    /** 发现来源（取第一个注册的来源） */
-    source: 'typeindex' | 'interop' | 'config';
-}
-/**
- * 发现选项
- */
-export interface DiscoverOptions {
-    /** 只查找自己注册的 */
-    selfOnly?: boolean;
-    /** 按应用 origin 过滤 */
-    origin?: string;
-    /** 按应用 ID 过滤 */
-    appId?: string;
-}
-/**
- * locationToTable 转换选项
- *
- * 三种选择 Shape 的方式（按优先级）：
- * 1. shape - 直接传入 ShapeInfo 对象或 Shape URL
- * 2. appId - 选择该 app 注册的 Shape
- * 3. 都不传 - 使用第一个可用的 Shape
- */
-export interface LocationToTableOptions {
-    /** 直接指定 Shape（ShapeInfo 对象或 Shape URL 字符串） */
-    shape?: ShapeInfo | string;
-    /** 按 appId 选择该 app 注册的 Shape */
-    appId?: string;
-}
-/**
- * 数据注册信息 - 包含完整的注册元数据
- */
-export interface DataRegistrationInfo {
-    /** 注册资源的 URL */
-    registrationUrl: string;
-    /** 数据容器 URL */
-    container: string;
-    /** RDF 类型 */
-    rdfClass: string;
-    /** ShapeTree URL */
-    shapeTree: string;
-    /** Shape URL - 实际的 SHACL Shape 定义 */
-    shape?: string;
-    /**
-     * @deprecated Legacy/explicit Subject URI template. Prefer exact base-relative ids.
-     */
-    subjectTemplate?: string;
-    /** 注册此数据的应用/代理 */
-    registeredBy?: string;
-    /** 注册时间 */
-    registeredAt?: Date;
-}
-/**
- * 数据发现接口
- *
- * 负责：
- * 1. 注册表的类型到发现机制 (TypeIndex / Interop Registry)
- * 2. 发现某类型数据的存储位置
- * 3. 检查类型是否已注册
- */
-export interface DataDiscovery {
-    /**
-     * 注册表的类型
-     * @param table PodTable 定义
-     * @param options 注册选项
-     */
-    register(table: PodTable, options?: RegisterOptions): Promise<void>;
-    /**
-     * 发现某类型数据的位置
-     * @param rdfClass RDF 类型 URI
-     * @param options 可选的过滤选项
-     */
-    discover(rdfClass: string, options?: DiscoverOptions): Promise<DataLocation[]>;
-    /**
-     * 检查类型是否已注册
-     * @param rdfClass RDF 类型 URI
-     */
-    isRegistered(rdfClass: string): Promise<boolean>;
-    /**
-     * 获取所有数据注册 (可选实现)
-     */
-    discoverAll?(): Promise<DataRegistrationInfo[]>;
-    /**
-     * 按应用 ID 发现数据位置 (可选实现)
-     * @param appId 应用标识符
-     */
-    discoverByApp?(appId: string): Promise<DataLocation[]>;
-}
-//# sourceMappingURL=types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/exact-records.d.ts

@@ -1,21 +0,0 @@
-import type { PodTable } from './schema';
-type ExactRecordTarget = string | Record<string, unknown> | null | undefined;
-type ExactRecordResolvedTarget = string | Record<string, unknown>;
-type ExactPodTable = PodTable<any>;
-export type ExactRecordDatabase = {
-    findByResource?: <TResource extends ExactPodTable>(resource: TResource, target: ExactRecordResolvedTarget) => Promise<unknown | null>;
-    updateByResource?: <TResource extends ExactPodTable>(resource: TResource, target: ExactRecordResolvedTarget, data: any) => Promise<unknown | null>;
-    deleteByResource?: <TResource extends ExactPodTable>(resource: TResource, target: ExactRecordResolvedTarget) => Promise<unknown>;
-    insert?: <TResource extends ExactPodTable>(resource: TResource) => {
-        values(value: any): {
-            execute(): Promise<unknown>;
-        };
-    };
-};
-export declare function findExactRecord<T>(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget): Promise<T | null>;
-export declare function updateExactRecord(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget, updates: Record<string, unknown>): Promise<void>;
-export declare function upsertExactRecord(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget, row: Record<string, unknown>, updates: Record<string, unknown>): Promise<'inserted' | 'updated'>;
-export declare function insertExactRecordOnce(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget, row: Record<string, unknown>): Promise<boolean>;
-export declare function deleteExactRecord(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget): Promise<void>;
-export {};
-//# sourceMappingURL=exact-records.d.ts.map