@undefineds.co/xpod 0.4.18 → 0.4.19

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

@@ -0,0 +1,50 @@
+import { PodTable, PodColumnBase } from './schema';
+import { AggregateExpression } from './aggregates';
+import { QueryCondition } from './query-conditions';
+type GenericPodTable = PodTable<any>;
+export type SelectField = PodColumnBase | GenericPodTable | string | AggregateExpression | SelectFieldMap;
+export interface SelectFieldMap {
+    [key: string]: SelectField;
+}
+export interface ColumnReference {
+    table: GenericPodTable;
+    alias: string;
+    column: string;
+}
+export interface JoinCondition {
+    left: ColumnReference;
+    right: ColumnReference;
+}
+export type JoinType = 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin' | 'crossJoin';
+export interface JoinPlan {
+    type: JoinType;
+    table: GenericPodTable;
+    alias: string;
+    conditions: JoinCondition[];
+    filters?: QueryCondition[];
+}
+export interface OrderByDescriptor {
+    reference?: ColumnReference;
+    rawColumn?: string;
+    direction: 'asc' | 'desc';
+}
+export interface SelectQueryPlan {
+    baseTable: GenericPodTable;
+    baseAlias: string;
+    select?: SelectFieldMap;
+    selectAll?: boolean;
+    where?: Record<string, unknown>;
+    conditionTree?: QueryCondition;
+    joins?: JoinPlan[];
+    joinFilters?: QueryCondition[];
+    groupBy?: ColumnReference[];
+    having?: QueryCondition;
+    orderBy?: OrderByDescriptor[];
+    distinct?: boolean;
+    limit?: number;
+    offset?: number;
+    aliasToTable: Map<string, GenericPodTable>;
+    tableToAlias: Map<GenericPodTable, string>;
+}
+export {};
+//# sourceMappingURL=select-plan.d.ts.map

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

@@ -0,0 +1,43 @@
+import { ASTToSPARQLConverter } from '../ast-to-sparql';
+import { type DataDiscovery } from '../discovery';
+import { LdpExecutor } from '../execution/ldp-executor';
+import { ExecutionStrategyFactoryImpl } from '../execution';
+import { ResourceResolverFactoryImpl } from '../resource-resolver';
+import { type ShapeManager } from '../shape';
+import { ComunicaSPARQLExecutor } from '../sparql-executor';
+import type { SPARQLQueryEngineFactory } from '../sparql-engine';
+import { TypeIndexManager } from '../typeindex-manager';
+import { UriResolverImpl } from '../uri';
+import type { PodTable } from '../schema';
+import type { QueryCondition } from '../query-conditions';
+import type { PodRuntime } from '../runtime/pod-runtime';
+export interface PodServiceOptions {
+    runtime: PodRuntime;
+    clientId?: string;
+    createQueryEngine?: SPARQLQueryEngineFactory;
+    disableInteropDiscovery?: boolean;
+    listContainerResources: (containerUrl: string) => Promise<string[]>;
+    findSubjectsForCondition: (condition: QueryCondition, table: PodTable, resourceUrl: string) => Promise<string[]>;
+}
+export declare class PodServices {
+    private uriResolver;
+    private sparqlConverter;
+    private sparqlExecutor;
+    private ldpExecutor;
+    private typeIndexManager;
+    private discovery;
+    private shapeManager;
+    private resolverFactory;
+    private strategyFactory;
+    constructor(options: PodServiceOptions);
+    getUriResolver(): UriResolverImpl;
+    getSparqlConverter(): ASTToSPARQLConverter;
+    getSparqlExecutor(): ComunicaSPARQLExecutor;
+    getLdpExecutor(): LdpExecutor;
+    getTypeIndexManager(): TypeIndexManager;
+    getDiscovery(): DataDiscovery;
+    getShapeManager(): ShapeManager;
+    getResolverFactory(): ResourceResolverFactoryImpl;
+    getStrategyFactory(): ExecutionStrategyFactoryImpl;
+}
+//# sourceMappingURL=pod-services.d.ts.map

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

@@ -0,0 +1,12 @@
+/**
+ * Shape Generator
+ *
+ * 从 PodTable 生成 Shape 定义
+ */
+import type { PodTable } from '../schema';
+import type { Shape } from './types';
+/**
+ * 从 PodTable 生成 Shape
+ */
+export declare function generateShape(table: PodTable): Shape;
+//# sourceMappingURL=generator.d.ts.map

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

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './manager';
+export * from './shacl-parser';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,45 @@
+import { PodTable } from '../schema';
+import { Shape, ShapeManager, ValidationResult } from './types';
+/**
+ * 从 Shape 生成的表定义
+ */
+export interface GeneratedTable {
+    /** 表名 */
+    name: string;
+    /** 表定义 */
+    table: PodTable;
+    /** 来源 Shape */
+    shape: Shape;
+}
+export declare class DrizzleShapeManager implements ShapeManager {
+    private podUrl;
+    private authenticatedFetch;
+    constructor(podUrl: string, authenticatedFetch?: typeof fetch);
+    generateShape(table: PodTable): Shape;
+    toSHACL(shape: Shape): string;
+    saveShape(shape: Shape, location: string, fetchFn?: typeof fetch): Promise<void>;
+    loadShape(uri: string, fetchFn?: typeof fetch): Promise<Shape | null>;
+    /**
+     * 从 Shape 生成 PodTable 定义
+     *
+     * @param shape Shape 定义
+     * @param containerPath 容器路径（可选）
+     * @returns 生成的表定义
+     */
+    shapeToTable(shape: Shape, containerPath?: string): GeneratedTable;
+    /**
+     * 从 Shape URI 或 targetClass 提取表名
+     */
+    private extractTableName;
+    /**
+     * 从 URI 路径提取名称
+     */
+    private extractNameFromPath;
+    /**
+     * 将 ShapeProperty 转换为 PodTable 列定义
+     */
+    private propertyToColumn;
+    validate(data: Record<string, unknown>, shape: Shape): ValidationResult;
+    private shapeToZod;
+}
+//# sourceMappingURL=manager.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/shape/shacl-parser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * SHACL Shape 解析器
+ *
+ * 从 Turtle 格式的 SHACL 定义解析出 Shape 对象
+ */
+import { Shape } from './types';
+/**
+ * 从 Turtle 内容解析 SHACL Shape
+ */
+export declare function parseSHACL(turtle: string, baseUri?: string): Promise<Shape[]>;
+/**
+ * XSD 类型到 Drizzle-Solid 类型的映射
+ */
+export declare function xsdToDrizzleType(xsdType: string | undefined): string;
+/**
+ * 从 nodeKind 推断类型
+ */
+export declare function nodeKindToDrizzleType(nodeKind: string | undefined): string | undefined;
+//# sourceMappingURL=shacl-parser.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * SHACL Serializer
+ *
+ * 将 Shape 定义转换为 SHACL Turtle 格式
+ */
+import type { Shape } from './types';
+/**
+ * 生成 SHACL Turtle 格式
+ */
+export declare function toSHACL(shape: Shape): string;
+//# sourceMappingURL=shacl.d.ts.map

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

@@ -0,0 +1,149 @@
+/**
+ * ShapeManager Types
+ *
+ * RDF Shape (SHACL) 相关的类型定义
+ */
+import type { PodTable } from '../schema';
+/**
+ * Shape 属性定义
+ */
+export interface ShapeProperty {
+    /** 谓词 URI (SHACL sh:path) */
+    path: string;
+    /** XSD 数据类型 */
+    datatype?: string;
+    /** 节点类型 (SHACL sh:nodeKind) */
+    nodeKind?: 'IRI' | 'Literal' | 'BlankNode' | string;
+    /** 最小出现次数 (SHACL sh:minCount) */
+    minCount?: number;
+    /** 最大出现次数 (SHACL sh:maxCount) */
+    maxCount?: number;
+    /** 正则约束 (SHACL sh:pattern) */
+    pattern?: string;
+    /** 属性名称 (用于错误消息) */
+    name?: string;
+    /** 是否为逆向属性 */
+    inverse?: boolean;
+    /** 目标类 (用于对象属性) */
+    class?: string;
+}
+/**
+ * Shape 定义
+ */
+export interface Shape {
+    /** Shape URI */
+    uri: string;
+    /** 目标 RDF 类型 (SHACL sh:targetClass) */
+    targetClass: string;
+    /** 属性定义 */
+    properties: ShapeProperty[];
+    /** 父 Shape (SHACL sh:conformsTo) */
+    conformsTo?: string[];
+    /** Shape 名称 (用于显示) */
+    name?: string;
+    /** Shape 描述 */
+    description?: string;
+}
+/**
+ * 验证结果
+ */
+export interface ValidationResult {
+    /** 是否有效 */
+    valid: boolean;
+    /** 验证错误列表 */
+    errors?: ValidationError[];
+}
+/**
+ * 验证错误
+ */
+export interface ValidationError {
+    /** 属性路径 (谓词 URI) */
+    path: string;
+    /** 错误消息 */
+    message: string;
+    /** 实际值 */
+    value?: unknown;
+    /** 约束名称 */
+    constraint?: string;
+}
+/**
+ * Shape 管理器接口
+ */
+export interface ShapeManager {
+    /**
+     * 从 PodTable 生成 Shape
+     * @param table PodTable 定义
+     */
+    generateShape(table: PodTable): Shape;
+    /**
+     * 生成 SHACL Turtle 格式
+     * @param shape Shape 定义
+     */
+    toSHACL(shape: Shape): string;
+    /**
+     * 保存 Shape 到 Pod
+     * @param shape Shape 定义
+     * @param location 存储位置
+     * @param fetchFn 认证 fetch
+     */
+    saveShape(shape: Shape, location: string, fetchFn?: typeof fetch): Promise<void>;
+    /**
+     * 从 Pod 加载 Shape
+     * @param uri Shape URI
+     * @param fetchFn 认证 fetch
+     */
+    loadShape(uri: string, fetchFn?: typeof fetch): Promise<Shape | null>;
+    /**
+     * 从 Shape 生成 PodTable 定义
+     * @param shape Shape 定义
+     * @param containerPath 容器路径（可选）
+     */
+    shapeToTable(shape: Shape, containerPath?: string): {
+        name: string;
+        table: PodTable;
+        shape: Shape;
+    };
+    /**
+     * 验证数据是否符合 Shape
+     * @param data 数据记录
+     * @param shape Shape 定义
+     */
+    validate(data: Record<string, unknown>, shape: Shape): ValidationResult;
+}
+/**
+ * XSD 数据类型常量
+ */
+export declare const XSD: {
+    readonly STRING: "http://www.w3.org/2001/XMLSchema#string";
+    readonly INTEGER: "http://www.w3.org/2001/XMLSchema#integer";
+    readonly BOOLEAN: "http://www.w3.org/2001/XMLSchema#boolean";
+    readonly DATETIME: "http://www.w3.org/2001/XMLSchema#dateTime";
+    readonly DATE: "http://www.w3.org/2001/XMLSchema#date";
+    readonly DECIMAL: "http://www.w3.org/2001/XMLSchema#decimal";
+    readonly DOUBLE: "http://www.w3.org/2001/XMLSchema#double";
+    readonly ANYURI: "http://www.w3.org/2001/XMLSchema#anyURI";
+};
+/**
+ * SHACL 命名空间常量
+ */
+export declare const SHACL: {
+    readonly PREFIX: "sh";
+    readonly NS: "http://www.w3.org/ns/shacl#";
+    readonly NODE_SHAPE: "http://www.w3.org/ns/shacl#NodeShape";
+    readonly TARGET_CLASS: "http://www.w3.org/ns/shacl#targetClass";
+    readonly PROPERTY: "http://www.w3.org/ns/shacl#property";
+    readonly PATH: "http://www.w3.org/ns/shacl#path";
+    readonly DATATYPE: "http://www.w3.org/ns/shacl#datatype";
+    readonly NODE_KIND: "http://www.w3.org/ns/shacl#nodeKind";
+    readonly MIN_COUNT: "http://www.w3.org/ns/shacl#minCount";
+    readonly MAX_COUNT: "http://www.w3.org/ns/shacl#maxCount";
+    readonly PATTERN: "http://www.w3.org/ns/shacl#pattern";
+    readonly NAME: "http://www.w3.org/ns/shacl#name";
+    readonly DESCRIPTION: "http://www.w3.org/ns/shacl#description";
+    readonly CLASS: "http://www.w3.org/ns/shacl#class";
+    readonly INVERSE_PATH: "http://www.w3.org/ns/shacl#inversePath";
+    readonly IRI: "http://www.w3.org/ns/shacl#IRI";
+    readonly LITERAL: "http://www.w3.org/ns/shacl#Literal";
+    readonly BLANK_NODE: "http://www.w3.org/ns/shacl#BlankNode";
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * Shape Validator
+ *
+ * 验证数据是否符合 Shape 定义
+ */
+import type { Shape, ValidationResult } from './types';
+/**
+ * 验证数据是否符合 Shape
+ */
+export declare function validate(data: Record<string, unknown>, shape: Shape): ValidationResult;
+//# sourceMappingURL=validator.d.ts.map

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

@@ -0,0 +1,86 @@
+/**
+ * SolidN3Client - 轻量级 Solid Pod 客户端
+ *
+ * 使用 N3.js + 原生 SPARQL UPDATE 替代 Comunica
+ *
+ * 架构:
+ * - 查询: HTTP GET → JSON-LD → N3 Store → 本地 SPARQL 查询
+ * - 修改: SPARQL UPDATE → HTTP PATCH → Solid Pod
+ */
+import { Store, Quad } from 'n3';
+export interface QueryResult {
+    bindings: Record<string, string>[];
+}
+export interface SparqlBinding {
+    [variable: string]: {
+        type: 'uri' | 'literal' | 'bnode';
+        value: string;
+        datatype?: string;
+        'xml:lang'?: string;
+    };
+}
+export declare class SolidN3Client {
+    private defaultFetch;
+    private cache;
+    private cacheTimeout;
+    constructor(defaultFetch?: typeof globalThis.fetch);
+    /**
+     * 执行 SPARQL SELECT 查询
+     * 通过 HTTP GET 获取数据，然后在本地 N3 Store 中查询
+     */
+    query(endpoint: string, sparqlQuery: string): Promise<QueryResult>;
+    /**
+     * 执行 SPARQL UPDATE 操作
+     * 直接发送到 Solid Pod
+     */
+    update(endpoint: string, sparqlUpdate: string): Promise<void>;
+    /**
+     * 获取资源的 N3 Store（带缓存）
+     */
+    private getResourceStore;
+    /**
+     * 解析 JSON-LD 到 N3 Store
+     */
+    private parseJsonLd;
+    /**
+     * 处理单个 JSON-LD 项目
+     */
+    private processJsonLdItem;
+    /**
+     * 在本地 Store 中执行 SPARQL 查询
+     */
+    private executeLocalQuery;
+    /**
+     * 从 SPARQL 查询中提取需要访问的资源
+     */
+    private extractResourcesFromQuery;
+    /**
+     * 简化的 SPARQL SELECT 解析器
+     */
+    private parseSparqlSelect;
+    /**
+     * 获取解析器格式
+     */
+    private getParserFormat;
+    /**
+     * 解析相对 URI
+     */
+    private resolveUri;
+    /**
+     * 清除缓存
+     */
+    private invalidateCache;
+    /**
+     * 清除所有缓存
+     */
+    clearCache(): void;
+    /**
+     * 便捷方法：获取资源的所有三元组
+     */
+    getResource(resourceUrl: string): Promise<Quad[]>;
+    /**
+     * 便捷方法：将 Store 序列化为 Turtle
+     */
+    serializeToTurtle(store: Store): Promise<string>;
+}
+//# sourceMappingURL=solid-n3-client.d.ts.map

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

@@ -0,0 +1,56 @@
+import { QueryCondition } from '../../query-conditions';
+import { PodTable } from '../../schema';
+import type { UriResolver } from '../../uri';
+import type { TableRegistryContext } from '../../ast-to-sparql';
+export declare class ExpressionBuilder {
+    private tableContext?;
+    private uriResolver;
+    constructor(uriResolver?: UriResolver);
+    /**
+     * Set table context for URI link resolution
+     */
+    setTableContext(context: TableRegistryContext): void;
+    /**
+     * Convert TableRegistryContext to UriContext
+     */
+    private getUriContext;
+    buildWhereClause(condition: QueryCondition | any, table: PodTable): string;
+    extractSubjectConstraint(condition: QueryCondition | any, table: PodTable): {
+        values: string[];
+        remainingCondition?: QueryCondition | any;
+    } | null;
+    /**
+     * Check if a column is a link column that needs URI resolution
+     * Delegates to uriResolver for consistency
+     */
+    private isLinkColumn;
+    /**
+     * Format a value for a link column, resolving URI if needed
+     * Uses uriResolver for consistent URI resolution
+     */
+    private formatLinkValue;
+    private isPartialTemplateError;
+    private isPartialLinkValue;
+    private formatPartialLinkCondition;
+    private parseTemplateVariable;
+    private getTemplateVariableFields;
+    private getMissingLocatorVariables;
+    private buildMissingLocatorError;
+    /**
+     * Format a subject comparison value, resolving UUID/relative IDs to full URIs.
+     */
+    private formatSubjectValue;
+    /**
+     * Check if value is a drizzle-orm SQL object
+     */
+    private isDrizzleSQL;
+    private buildExpression;
+    private buildLogicalExpression;
+    private extractSubjectConstraintInternal;
+    private extractSubjectConstraintFromBinary;
+    private extractExactSubjectConstraintFromLogical;
+    private buildUnaryExpression;
+    private buildBinaryExpression;
+    private resolveColumnName;
+}
+//# sourceMappingURL=expression-builder.d.ts.map

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

@@ -0,0 +1,44 @@
+import { PodTable } from '../../schema';
+import { SelectQueryPlan } from '../../select-plan';
+import { SPARQLQuery } from '../types';
+import type { UriResolver } from '../../uri';
+import type { TableRegistryContext } from '../../ast-to-sparql';
+export declare class SelectBuilder {
+    private generator;
+    private prefixes;
+    private expressionBuilder;
+    private tableContext?;
+    private uriResolver;
+    constructor(prefixes: Record<string, string>, uriResolver?: UriResolver);
+    /**
+     * Set table context for URI link resolution
+     */
+    setTableContext(context: TableRegistryContext): void;
+    convertSelect(ast: any, table: PodTable, targetGraph?: string, fromSources?: string[], allowGraphVariable?: boolean): SPARQLQuery;
+    convertSelectPlan(plan: SelectQueryPlan, targetGraph?: string, fromSources?: string[], allowGraphVariable?: boolean): SPARQLQuery;
+    private buildHavingExpressions;
+    private buildHavingExpression;
+    private buildHavingLogicalExpression;
+    private buildHavingUnaryExpression;
+    private buildHavingBinaryExpression;
+    private buildHavingOperand;
+    private buildHavingAliasOperand;
+    private buildAggregateOperand;
+    private getUriContext;
+    convertSimpleSelect(operation: {
+        table: PodTable;
+        where?: Record<string, unknown>;
+        limit?: number;
+        offset?: number;
+        orderBy?: Array<{
+            column: string;
+            direction: 'asc' | 'desc';
+        }>;
+        distinct?: boolean;
+    }, targetGraph?: string, fromSources?: string[], allowGraphVariable?: boolean): SPARQLQuery;
+    private buildSelectVariables;
+    private buildSelectEntry;
+    private buildAggregateSelectEntry;
+    private buildWherePatterns;
+}
+//# sourceMappingURL=select-builder.d.ts.map

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

@@ -0,0 +1,33 @@
+import { PodTable } from '../../schema';
+import { SPARQLQuery } from '../types';
+import type { UriResolver } from '../../uri';
+import type { TableRegistryContext } from '../../ast-to-sparql';
+export declare class UpdateBuilder {
+    private generator;
+    private prefixes;
+    private tripleBuilder;
+    private uriResolver;
+    private tableContext?;
+    constructor(prefixes: Record<string, string>, uriResolver?: UriResolver);
+    /**
+     * Set table context for URI resolution and inline child handling
+     */
+    setTableContext(context: TableRegistryContext): void;
+    private getUriContext;
+    private resolveLinkTerm;
+    private formatValueOrThrow;
+    convertInsert(valuesOrPlan: any[] | {
+        table: PodTable;
+        rows: any[];
+    }, table?: PodTable, targetGraph?: string): SPARQLQuery;
+    private buildInsertTriples;
+    convertUpdate(setData: any, whereConditions: any, table: PodTable, targetGraph?: string): SPARQLQuery;
+    convertDelete(whereConditions: any, table: PodTable, targetGraph?: string): SPARQLQuery;
+    private buildUpdatePartsForRecord;
+    private toSparqlJsTriple;
+    private parseTermString;
+    private extractSubjectRecords;
+    private isQueryCondition;
+    private findConditionValue;
+}
+//# sourceMappingURL=update-builder.d.ts.map

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

@@ -0,0 +1,19 @@
+import { PodTable, PodColumnBase, SolidSchema } from '../schema';
+import type { UriContext, UriResolver } from '../uri';
+export interface RdfTerm {
+    termType: 'NamedNode' | 'Literal' | 'BlankNode' | 'Variable';
+    value: string;
+    datatype?: RdfTerm;
+    language?: string;
+}
+/**
+ * 获取列的谓词 URI
+ * @param column 列定义
+ * @param tableOrSchema PodTable 或 SolidSchema
+ */
+export declare function getPredicateForColumn(column: PodColumnBase | any, tableOrSchema: PodTable | SolidSchema<any>): string;
+export declare function formatValue(value: any, column?: PodColumnBase | any, resolver?: UriResolver, context?: UriContext): string | string[];
+export declare function buildLiteralTerm(value: any): RdfTerm;
+export declare function resolveColumn(field: unknown, table: PodTable): PodColumnBase;
+export declare function generateSubjectUri(record: any, table: PodTable, resolver: UriResolver): string;
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1,10 @@
+export interface SPARQLQuery {
+    type: 'SELECT' | 'INSERT' | 'DELETE' | 'UPDATE' | 'ASK';
+    query: string;
+    prefixes: Record<string, string>;
+}
+export interface ASTNode {
+    type: string;
+    [key: string]: any;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,16 @@
+export type SPARQLBindingsStream = {
+    toArray(): Promise<unknown[]>;
+};
+export interface SPARQLQueryEngine {
+    queryBindings(query: string, context: Record<string, unknown>): Promise<SPARQLBindingsStream>;
+    queryBoolean(query: string, context: Record<string, unknown>): Promise<boolean>;
+    invalidateHttpCache?: (url?: string) => Promise<void>;
+}
+export type SPARQLQueryEngineFactory = () => SPARQLQueryEngine | Promise<SPARQLQueryEngine>;
+export interface SPARQLEngineConfig {
+    createQueryEngine?: SPARQLQueryEngineFactory;
+}
+export declare const configureSparqlEngine: (config?: SPARQLEngineConfig | null) => void;
+export declare const getConfiguredSparqlEngineFactory: (createQueryEngine?: SPARQLQueryEngineFactory | null) => SPARQLQueryEngineFactory;
+export declare const createNodeModuleSparqlEngineFactory: (resolveFrom: string) => SPARQLQueryEngineFactory;
+//# sourceMappingURL=sparql-engine.d.ts.map

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

@@ -0,0 +1,40 @@
+import { SPARQLQuery } from '../types/sparql-types';
+import { type SPARQLQueryEngineFactory } from './sparql-engine';
+export interface SPARQLExecutorConfig {
+    sources: string[];
+    fetch?: typeof fetch;
+    logging?: boolean;
+    createQueryEngine?: SPARQLQueryEngineFactory;
+}
+type QuerySourceType = 'auto' | 'sparql';
+export declare class ComunicaSPARQLExecutor {
+    protected sources: string[];
+    protected fetchFn: typeof fetch;
+    protected logging: boolean;
+    private createQueryEngine;
+    private engine;
+    constructor(config: SPARQLExecutorConfig);
+    private formatError;
+    private createSourceRef;
+    private createSafeFetch;
+    private initEngine;
+    executeQuery(sparqlQuery: SPARQLQuery): Promise<unknown[]>;
+    executeSelect(query: string): Promise<unknown[]>;
+    queryBindings(query: string, sourceUrl: string): Promise<unknown[]>;
+    private executeSelectInternal;
+    private executeAskInternal;
+    private executeUpdate;
+    invalidateHttpCache(url?: string): Promise<void>;
+    private invalidateCache;
+    private extractBindingKeyName;
+    private convertComunicaTerm;
+    queryContainer(containerUrl: string, customQuery?: SPARQLQuery): Promise<unknown[]>;
+    executeQueryWithSource(sparqlQuery: SPARQLQuery, sourceUrl: string, sourceType?: QuerySourceType): Promise<unknown[]>;
+    private executeDirectSparqlQuery;
+    addSource(source: string): void;
+    removeSource(source: string): void;
+    getSources(): string[];
+}
+export declare const SolidSPARQLExecutor: typeof ComunicaSPARQLExecutor;
+export {};
+//# sourceMappingURL=sparql-executor.d.ts.map