@undefineds.co/xpod 0.4.15 → 0.4.17

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

@@ -1,50 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,12 +0,0 @@
-/**
- * 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

@@ -1,4 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,19 +0,0 @@
-/**
- * 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

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,149 +0,0 @@
-/**
- * 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

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,86 +0,0 @@
-/**
- * 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

@@ -1,56 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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