ldkit 1.1.0 → 2.1.0

package/types/library/rdf.d.ts

@@ -1,20 +1,13 @@
-import type * as RDF from "rdf-js";
+import type * as RDF from "@rdfjs/types";
 export type { RDF };
 export { fromRdf, toRdf } from "rdf-literal";
 import { DataFactory, DefaultGraph } from "rdf-data-factory";
 export { DataFactory, DefaultGraph };
 export * as N3 from "n3";
-import type { IDataSource, IQueryContextCommon } from "@comunica/types";
-export type LDkitContext = {
-    graph?: string;
-    language?: string;
-};
-export type Context = LDkitContext & RDF.QueryStringContext & RDF.QuerySourceContext<IDataSource> & IQueryContextCommon;
-export type IQueryEngine = RDF.StringSparqlQueryable<RDF.SparqlResultSupport, Context>;
-export type Iri = string;
-export type Node = Map<Iri, RDF.Term[]>;
-export type Graph = Map<Iri, Node>;
-export declare const quadsToGraph: (quads: RDF.Quad[]) => Graph;
+export type IRI = string;
+export type Node = Map<IRI, RDF.Term[]>;
+export type Graph = Map<IRI, Node>;
+export declare const quadsToGraph: (quads: Iterable<RDF.Quad>) => Graph;
 export declare namespace RDFJSON {
     type Term = {
         type: "uri" | "literal" | "bnode";
@@ -23,7 +16,7 @@ export declare namespace RDFJSON {
         datatype?: string;
     };
     type Bindings = Record<string, Term>;
-    type Triple = [Iri, Iri, Term];
+    type Triple = [IRI, IRI, Term];
     type SparqlResultsJsonFormat = {
         head: {
             vars?: string[];
@@ -33,7 +26,7 @@ export declare namespace RDFJSON {
         };
         boolean?: boolean;
     };
-    type RdfJsonFormat = Record<Iri, Record<Iri, Term[]>>;
+    type RdfJsonFormat = Record<IRI, Record<IRI, Term[]>>;
     interface TermFactory {
         fromJson(jsonTerm: Term): RDF.Term;
     }
@@ -80,5 +73,5 @@ export declare class QuadFactory implements RDFJSON.QuadFactory {
     protected readonly dataFactory: RDF.DataFactory;
     protected readonly termFactory: RDFJSON.TermFactory;
     constructor(dataFactory?: RDF.DataFactory, termFactory?: RDFJSON.TermFactory);
-    fromJson(jsonRdf: [Iri, Iri, RDFJSON.Term]): RDF.Quad;
+    fromJson(jsonRdf: [IRI, IRI, RDFJSON.Term]): RDF.Quad;
 }

package/types/library/schema/data_types.d.ts

@@ -1,39 +1,46 @@
-declare const SupportedDataTypesPrototype: {
-    "xsd:dateTime": Date;
-    "xsd:date": Date;
-    "xsd:gDay": Date;
-    "xsd:gMonthDay": Date;
-    "xsd:gYear": Date;
-    "xsd:gYearMonth": Date;
-    "xsd:boolean": boolean;
-    "xsd:double": number;
-    "xsd:decimal": number;
-    "xsd:float": number;
-    "xsd:integer": number;
-    "xsd:long": number;
-    "xsd:int": number;
-    "xsd:byte": number;
-    "xsd:short": number;
-    "xsd:negativeInteger": number;
-    "xsd:nonNegativeInteger": number;
-    "xsd:nonPositiveInteger": number;
-    "xsd:positiveInteger": number;
-    "xsd:unsignedByte": number;
-    "xsd:unsignedInt": number;
-    "xsd:unsignedLong": number;
-    "xsd:unsignedShort": number;
-    "xsd:string": string;
-    "xsd:normalizedString": string;
-    "xsd:anyURI": string;
-    "xsd:base64Binary": string;
-    "xsd:language": string;
-    "xsd:Name": string;
-    "xsd:NCName": string;
-    "xsd:NMTOKEN": string;
-    "xsd:token": string;
-    "xsd:hexBinary": string;
-    "rdf:langString": string;
+import { xsd } from "../../namespaces/xsd.js";
+import { rdf } from "../../namespaces/rdf.js";
+import { ldkit } from "../../namespaces/ldkit.js";
+import { type IRI } from "../rdf.js";
+/** Map of supported RDF data types and their JavaScript native counterparts */
+export type SupportedDataTypes = {
+    [xsd.dateTime]: Date;
+    [xsd.date]: Date;
+    [xsd.gDay]: Date;
+    [xsd.gMonthDay]: Date;
+    [xsd.gYear]: Date;
+    [xsd.gYearMonth]: Date;
+    [xsd.boolean]: boolean;
+    [xsd.double]: number;
+    [xsd.decimal]: number;
+    [xsd.float]: number;
+    [xsd.integer]: number;
+    [xsd.long]: number;
+    [xsd.int]: number;
+    [xsd.byte]: number;
+    [xsd.short]: number;
+    [xsd.negativeInteger]: number;
+    [xsd.nonNegativeInteger]: number;
+    [xsd.nonPositiveInteger]: number;
+    [xsd.positiveInteger]: number;
+    [xsd.unsignedByte]: number;
+    [xsd.unsignedInt]: number;
+    [xsd.unsignedLong]: number;
+    [xsd.unsignedShort]: number;
+    [xsd.string]: string;
+    [xsd.normalizedString]: string;
+    [xsd.anyURI]: string;
+    [xsd.base64Binary]: string;
+    [xsd.language]: string;
+    [xsd.Name]: string;
+    [xsd.NCName]: string;
+    [xsd.NMTOKEN]: string;
+    [xsd.token]: string;
+    [xsd.hexBinary]: string;
+    [rdf.langString]: string;
+    [xsd.time]: string;
+    [xsd.duration]: string;
+    [ldkit.IRI]: IRI;
 };
-export type SupportedDataTypes = typeof SupportedDataTypesPrototype;
+/** List of supported native JavaScript types */
 export type SupportedNativeTypes = SupportedDataTypes[keyof SupportedDataTypes];
-export {};

package/types/library/schema/interface.d.ts

@@ -1,32 +1,87 @@
+import { IRI } from "../rdf.js";
 import type { SupportedDataTypes } from "./data_types.js";
-import type { PropertyPrototype, SchemaPrototype } from "./schema.js";
-type IsOptional<Property extends PropertyPrototype> = Property extends {
+import type { Property, Schema } from "./schema.js";
+import type { SearchFilters } from "./search.js";
+type Unite<T> = T extends Record<string, unknown> ? {
+    [Key in keyof T]: T[Key];
+} : T;
+type IsOptional<T extends Property> = T extends {
     "@optional": true;
 } ? true : false;
-type IsArray<Property extends PropertyPrototype> = Property extends {
+type IsArray<T extends Property> = T extends {
     "@array": true;
 } ? true : false;
-type IsMultilang<Property extends PropertyPrototype> = Property extends {
+type IsMultilang<T extends Property> = T extends {
     "@multilang": true;
 } ? true : false;
-type ValidPropertyDefinition = PropertyPrototype | string;
-type ConvertPropertyType<T extends PropertyPrototype> = T extends {
-    "@context": SchemaPrototype;
-} ? SchemaInterface<T["@context"]> : T extends {
+type IsInverse<T extends Property> = T extends {
+    "@inverse": true;
+} ? true : false;
+type ValidPropertyDefinition = Property | string;
+type ConvertPropertyType<T extends Property> = T extends {
     "@type": unknown;
 } ? T["@type"] extends keyof SupportedDataTypes ? SupportedDataTypes[T["@type"]] : never : string;
-type ConvertPropertyOptional<T extends PropertyPrototype> = IsOptional<T> extends true ? ConvertPropertyType<T> | undefined : ConvertPropertyType<T>;
-type ConvertPropertyArray<T extends PropertyPrototype> = IsArray<T> extends true ? ConvertPropertyType<T>[] : ConvertPropertyOptional<T>;
-type ConvertPropertyMultilang<T extends PropertyPrototype> = IsMultilang<T> extends true ? IsArray<T> extends true ? Record<string, ConvertPropertyType<T>[]> : Record<string, ConvertPropertyType<T>> : ConvertPropertyArray<T>;
-type ConvertPropertyObject<T extends PropertyPrototype> = ConvertPropertyMultilang<T>;
-type ConvertProperty<T extends ValidPropertyDefinition> = T extends PropertyPrototype ? ConvertPropertyObject<T> : string;
-export type SchemaInterfaceIdentity = {
-    $id: string;
-};
-export type SchemaInterfaceType = {
-    $type: string[];
+type ConvertPropertySchema<T extends Property> = T extends {
+    "@schema": Schema;
+} ? Unite<SchemaInterface<T["@schema"]>> : ConvertPropertyType<T>;
+type ConvertPropertyOptional<T extends Property> = IsOptional<T> extends true ? ConvertPropertySchema<T> | null : ConvertPropertySchema<T>;
+type ConvertPropertyArray<T extends Property> = IsArray<T> extends true ? ConvertPropertySchema<T>[] : ConvertPropertyOptional<T>;
+type ConvertPropertyMultilang<T extends Property> = IsMultilang<T> extends true ? IsArray<T> extends true ? Record<string, ConvertPropertyType<T>[]> : Record<string, ConvertPropertyType<T>> : ConvertPropertyArray<T>;
+type ConvertPropertyObject<T extends Property> = ConvertPropertyMultilang<T>;
+type ConvertProperty<T extends ValidPropertyDefinition> = T extends Property ? ConvertPropertyObject<T> : string;
+/** Object that contains IRI of an entity */
+export type Identity = {
+    $id: IRI;
 };
-export type SchemaInterface<T extends SchemaPrototype> = {
+/**
+ * Describes a data model of a data entity according to its schema,. as resolved
+ * by LDkit, i.e. the shape of data that LDkit returns when querying for entities.
+ *
+ * See {@link Lens.prototype.find} for usage example.
+ */
+export type SchemaInterface<T extends Schema> = Identity & {
     [X in Exclude<keyof T, "@type">]: T[X] extends ValidPropertyDefinition ? ConvertProperty<T[X]> : never;
-} & SchemaInterfaceIdentity & SchemaInterfaceType;
+};
+type ConvertUpdatePropertySchema<T extends Property> = T extends {
+    "@schema": Schema;
+} ? Unite<SchemaUpdateInterface<T["@schema"]>> : ConvertPropertyType<T>;
+type ConvertUpdatePropertyOptional<T extends Property> = IsOptional<T> extends true ? ConvertPropertySchema<T> | null : ConvertUpdatePropertySchema<T>;
+type CreateArrayUpdateInterface<T extends Property> = {
+    $set?: ConvertPropertyType<T>[];
+    $add?: ConvertPropertyType<T>[];
+    $remove?: ConvertPropertyType<T>[];
+} | ConvertPropertyType<T>[];
+type ConvertUpdatePropertyArray<T extends Property> = IsArray<T> extends true ? CreateArrayUpdateInterface<T> : ConvertUpdatePropertyOptional<T>;
+type ConvertUpdatePropertyMultilang<T extends Property> = IsMultilang<T> extends true ? IsArray<T> extends true ? Record<string, CreateArrayUpdateInterface<T>> : Record<string, ConvertPropertyType<T>> : ConvertUpdatePropertyArray<T>;
+type ConvertUpdatePropertyObject<T extends Property> = ConvertUpdatePropertyMultilang<T>;
+type ConvertUpdateProperty<T extends ValidPropertyDefinition> = T extends Property ? ConvertUpdatePropertyObject<T> : string;
+/**
+ * Describes a shape of data for updating an entity, according to its data schema.
+ *
+ * See {@link Lens.prototype.update} for usage example.
+ */
+export type SchemaUpdateInterface<T extends Schema> = Identity & {
+    [X in Exclude<keyof T, "@type">]?: T[X] extends ValidPropertyDefinition ? ConvertUpdateProperty<T[X]> : never;
+};
+type ConvertSearchPropertySchema<T extends Property> = T extends {
+    "@schema": Schema;
+} ? Unite<SchemaSearchInterfaceProperties<T["@schema"]>> : IsInverse<T> extends true ? never : SearchFilters<ConvertPropertyType<T>>;
+type ConvertSearchProperty<T extends ValidPropertyDefinition> = T extends Property ? ConvertSearchPropertySchema<T> : SearchFilters<string>;
+type InversePropertiesMap<T extends Schema> = {
+    [X in keyof T]: T[X] extends {
+        "@inverse": true;
+    } ? X : never;
+};
+type InverseProperties<T extends Schema> = InversePropertiesMap<T>[keyof InversePropertiesMap<T>];
+type SchemaSearchInterfaceProperties<T extends Schema> = {
+    [X in Exclude<keyof T, "@type" | InverseProperties<T>>]?: T[X] extends ValidPropertyDefinition ? ConvertSearchProperty<T[X]> : never;
+};
+/**
+ * Describes a shape of data for updating an entity, according to its data schema.
+ *
+ * See {@link Lens.prototype.find} for usage example.
+ */
+export type SchemaSearchInterface<T extends Schema> = {
+    $id?: IRI | IRI[];
+} & SchemaSearchInterfaceProperties<T>;
 export {};

package/types/library/schema/mod.d.ts

@@ -1,3 +1,5 @@
-export type { SchemaInterface, SchemaInterfaceIdentity, SchemaInterfaceType, } from "./interface.js";
-export type { Property, PropertyPrototype, Schema, SchemaPrototype, } from "./schema.js";
+export type { SupportedDataTypes, SupportedNativeTypes } from "./data_types.js";
+export type { Identity, SchemaInterface, SchemaSearchInterface, SchemaUpdateInterface, } from "./interface.js";
+export type { ExpandedProperty, ExpandedSchema, Property, Schema, } from "./schema.js";
+export type { SearchFilters, SearchSchema } from "./search.js";
 export { expandSchema, getSchemaProperties } from "./utils.js";

package/types/library/schema/schema.d.ts

@@ -1,30 +1,37 @@
 import type { SupportedDataTypes } from "./data_types.js";
-type PropertyType = keyof SupportedDataTypes;
-export type PropertyPrototype = {
+/**
+ * Data property prototype that describes RDF predicate of a data entity.
+ * Includes specification of other metadata, such as whether the property
+ * is optional, array, inverse, or whether it is a nested data entity, etc.
+ */
+export type Property = {
     "@id": string;
-    "@type"?: PropertyType;
-    "@context"?: SchemaPrototype;
+    "@type"?: keyof SupportedDataTypes;
+    "@schema"?: Schema;
     "@optional"?: true;
     "@array"?: true;
     "@multilang"?: true;
+    "@inverse"?: true;
 };
-export type SchemaPrototypeProperties = {
-    [key: string]: PropertyPrototype | string | readonly string[];
-};
-export type SchemaPrototypeType = {
-    "@type": string | readonly string[];
+/**
+ * Data schema prototype that describes a data entity. Includes an optional
+ * specification of RDF type and a map of RDF properties.
+ */
+export type Schema = {
+    "@type"?: string | readonly string[];
+} & {
+    [key: string]: Property | string | readonly string[];
 };
-export type SchemaPrototype = SchemaPrototypeProperties & SchemaPrototypeType;
-export type Property = {
+export type ExpandedProperty = {
     "@id": string;
-    "@type"?: PropertyType;
-    "@context"?: Schema;
+    "@type"?: keyof SupportedDataTypes;
+    "@schema"?: ExpandedSchema;
     "@optional"?: true;
     "@array"?: true;
     "@multilang"?: true;
+    "@inverse"?: true;
 };
-export type Schema = {
-    [key: string]: Property | string[];
+export type ExpandedSchema = {
+    [key: string]: ExpandedProperty | string[];
     "@type": string[];
 };
-export {};

package/types/library/schema/search.d.ts

@@ -0,0 +1,20 @@
+import { SparqlValue } from "../sparql/mod.js";
+export type SearchFilters<T> = T | {
+    $equals?: T;
+    $not?: T;
+    $contains?: T;
+    $strStarts?: T;
+    $strEnds?: T;
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+    $regex?: string;
+    $langMatches?: string;
+    $in?: T[];
+    $notIn?: T[];
+    $filter?: SparqlValue;
+};
+export type SearchSchema = {
+    [key: string]: SearchFilters<unknown> | SearchSchema;
+};

package/types/library/schema/utils.d.ts

@@ -1,3 +1,3 @@
-import type { Property, Schema, SchemaPrototype } from "./schema.js";
-export declare const expandSchema: (schemaPrototype: SchemaPrototype) => Schema;
-export declare const getSchemaProperties: (schema: Schema) => Record<string, Property>;
+import type { ExpandedProperty, ExpandedSchema, Schema } from "./schema.js";
+export declare const expandSchema: (schemaPrototype: Schema) => ExpandedSchema;
+export declare const getSchemaProperties: (schema: ExpandedSchema) => Record<string, ExpandedProperty>;

package/types/library/sparql/mod.d.ts

@@ -1,3 +1,4 @@
-export { sparql, type SparqlValue } from "./sparql_tag.js";
+export * from "./sparql_tag.js";
 export { ASK, CONSTRUCT, DESCRIBE, SELECT } from "./sparql_query_builders.js";
 export { DELETE, INSERT, WITH } from "./sparql_update_builders.js";
+export * from "./sparql_expression_builders.js";

package/types/library/sparql/sparql_expression_builders.d.ts

@@ -0,0 +1,19 @@
+import { SparqlBuilder } from "./sparql_shared_builders.js";
+import { type SparqlValue } from "./sparql_tag.js";
+type Builders<T extends keyof SparqlExpressionBuilder> = Pick<SparqlExpressionBuilder, T>;
+declare class SparqlExpressionBuilder extends SparqlBuilder {
+    OPTIONAL(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build">;
+}
+/**
+ * SPARQL OPTIONAL expression fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { OPTIONAL } from "ldkit/sparql";
+ *
+ * const query = OPTIONAL`?s ?p ?o`.build();
+ * console.log(query); // OPTIONAL { ?s ?p ?o }
+ * ```
+ */
+export declare const OPTIONAL: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"build">;
+export {};

package/types/library/sparql/sparql_query_builders.d.ts

@@ -22,18 +22,83 @@ declare class SparqlQueryBuilder extends SparqlBuilder {
     ASK_WHERE(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build" | "GROUP_BY" | "ORDER_BY" | "LIMIT">;
     DESCRIBE(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build" | "FROM" | "FROM_NAMED" | "WHERE">;
 }
+/**
+ * SPARQL SELECT query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { SELECT } from "ldkit/sparql";
+ *
+ * const query = SELECT`?s`.WHERE`?s ?p ?o`.ORDER_BY`?s`.LIMIT(100).build();
+ * console.log(query);
+ * // SELECT ?s WHERE { ?s ?p ?o } ORDER BY ?s LIMIT 100
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { SELECT } from "ldkit/sparql";
+ *
+ * const query = SELECT.DISTINCT`?s`.WHERE`?s ?p ?o`.build();
+ * console.log(query);
+ * // SELECT DISTINCT ?s WHERE { ?s ?p ?o }
+ * ```
+ */
 export declare const SELECT: ((strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"WHERE" | "FROM_NAMED" | "FROM">) & {
     DISTINCT: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"WHERE" | "FROM_NAMED" | "FROM">;
     REDUCED: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"WHERE" | "FROM_NAMED" | "FROM">;
     readonly ALL: Builders<"WHERE" | "FROM_NAMED" | "FROM">;
 };
+/**
+ * SPARQL CONSTRUCT query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { CONSTRUCT } from "ldkit/sparql";
+ * import { DataFactory } from "ldkit/rdf";
+ *
+ * const df = new DataFactory();
+ * const sNode = df.namedNode("http://example.org/datasource");
+ * const pNode = df.namedNode("http://example.org/hasSubject");
+ *
+ * const query = CONSTRUCT`${sNode} ${pNode} ?s`.WHERE`?s ?p ?o`.build();
+ * console.log(query);
+ * // CONSTRUCT { <http://example.org/datasource> <http://example.org/hasSubject> ?s }
+ * // WHERE { ?s ?p ?o }
+ * ```
+ */
 export declare const CONSTRUCT: ((strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"WHERE">) & {
-    WHERE: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"LIMIT" | "ORDER_BY" | "GROUP_BY" | "build">;
+    WHERE: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"build" | "LIMIT" | "ORDER_BY" | "GROUP_BY">;
 };
+/**
+ * SPARQL ASK query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { ASK } from "ldkit/sparql";
+ *
+ * const query = ASK`?s ?p ?o`.build();
+ * console.log(query); // ASK { ?s ?p ?o }
+ * ```
+ */
 export declare const ASK: ((strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"build">) & {
     FROM: (stringOrNamedNode: string | RDF.NamedNode<string>) => Builders<"WHERE" | "FROM_NAMED" | "FROM">;
     FROM_NAMED: (stringOrNamedNode: string | RDF.NamedNode<string>) => Builders<"WHERE" | "FROM_NAMED">;
-    WHERE: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"LIMIT" | "ORDER_BY" | "GROUP_BY" | "build">;
+    WHERE: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"build" | "LIMIT" | "ORDER_BY" | "GROUP_BY">;
 };
-export declare const DESCRIBE: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"WHERE" | "FROM_NAMED" | "FROM" | "build">;
+/**
+ * SPARQL DESCRIBE query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { DESCRIBE } from "ldkit/sparql";
+ * import { DataFactory } from "ldkit/rdf";
+ *
+ * const df = new DataFactory();
+ * const node = df.namedNode("http://example.org/resource");
+ *
+ * const query = DESCRIBE`${node}`.build();
+ * console.log(query); // DESCRIBE <http://example.org/resource>
+ * ```
+ */
+export declare const DESCRIBE: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"build" | "WHERE" | "FROM_NAMED" | "FROM">;
 export {};

package/types/library/sparql/sparql_shared_builders.d.ts

@@ -2,6 +2,7 @@ import { DataFactory, RDF } from "../rdf.js";
 import { type SparqlValue } from "./sparql_tag.js";
 type Wrap = (keyword: string, value: string) => string;
 export declare const braces: Wrap;
+export declare const bracesInline: Wrap;
 export declare const parentheses: Wrap;
 export declare abstract class SparqlBuilder {
     protected value: string;

package/types/library/sparql/sparql_tag.d.ts

@@ -1,3 +1,31 @@
 import { type RDF } from "../rdf.js";
-export type SparqlValue = RDF.Term | string | number | boolean | Date | Iterable<SparqlValue> | null | undefined;
+/**
+ * Any value that can be used in LDkit SPARQL builders
+ */
+export type SparqlValue = RDF.Term | string | number | boolean | Date | Iterable<SparqlValue> | {
+    build: () => string;
+} | null | undefined;
+/**
+ * A template tag for SPARQL queries or its parts. Automatically converts
+ * values to SPARQL literals and escapes strings as needed.
+ *
+ * @example
+ * ```typescript
+ * import { sparql } from "ldkit/sparql";
+ * import { DataFactory } from "ldkit/rdf";
+ *
+ * const df = new DataFactory();
+ * const quad = df.quad(
+ *   df.namedNode("http://example.org/s"),
+ *   df.namedNode("http://example.org/p"),
+ *   df.literal("o"),
+ * );
+ * const query = sparql`SELECT * WHERE { ${quad} }`;
+ * console.log(query); // SELECT * WHERE { <http://example.org/s> <http://example.org/p> "o" . }
+ * ```
+ *
+ * @param strings {TemplateStringsArray} template strings
+ * @param values {SparqlValue[]}
+ * @returns {string} SPARQL query or its part
+ */
 export declare const sparql: (strings: TemplateStringsArray, ...values: SparqlValue[]) => string;

package/types/library/sparql/sparql_update_builders.d.ts

@@ -10,13 +10,81 @@ declare class SparqlUpdateBuilder extends SparqlBuilder {
     INSERT_DATA(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build">;
     DELETE(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"INSERT" | "USING" | "USING_NAMED" | "WHERE">;
     DELETE_DATA(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build">;
+    DELETE_WHERE(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build">;
     WITH(stringOrNamedNode: string | RDF.NamedNode<string>): Builders<"INSERT" | "DELETE">;
 }
+/**
+ * SPARQL INSERT query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { INSERT } from "ldkit/sparql";
+ * import { foaf } from "ldkit/namespaces";
+ * import { DataFactory } from "ldkit/rdf";
+ *
+ * const df = new DataFactory();
+ * const firstName = df.namedNode(foaf.firstName);
+ *
+ * const query = INSERT`?person ${firstName} "Paul"`
+ *   .WHERE`?person ${firstName} "Jean"`
+ *   .build();
+ * console.log(query);
+ * // INSERT { ?person <http://xmlns.com/foaf/0.1/firstName> "Paul" }
+ * // WHERE { ?person <http://xmlns.com/foaf/0.1/firstName> "Jean" }
+ * ```
+ */
 export declare const INSERT: ((strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"WHERE" | "USING_NAMED" | "USING">) & {
     DATA: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"build">;
 };
+/**
+ * SPARQL DELETE query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { DELETE } from "ldkit/sparql";
+ * import { foaf } from "ldkit/namespaces";
+ * import { DataFactory } from "ldkit/rdf";
+ *
+ * const df = new DataFactory();
+ * const firstName = df.namedNode(foaf.firstName);
+ *
+ * const query = DELETE`?person ${firstName} "Jean"`
+ *   .INSERT`?person ${firstName} "Paul"`
+ *   .WHERE`?person ${firstName} "Jean"`
+ *   .build();
+ * console.log(query);
+ * // DELETE { ?person <http://xmlns.com/foaf/0.1/firstName> "Jean" }
+ * // INSERT { ?person <http://xmlns.com/foaf/0.1/firstName> "Paul" }
+ * // WHERE { ?person <http://xmlns.com/foaf/0.1/firstName> "Jean" }
+ * ```
+ */
 export declare const DELETE: ((strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"WHERE" | "USING_NAMED" | "USING" | "INSERT">) & {
     DATA: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"build">;
+    WHERE: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"build">;
 };
+/**
+ * SPARQL WITH query fluent interface
+ *
+ * @example
+ * ```typescript
+ * import { DELETE } from "ldkit/sparql";
+ * import { foaf } from "ldkit/namespaces";
+ * import { DataFactory } from "ldkit/rdf";
+ *
+ * const df = new DataFactory();
+ * const firstName = df.namedNode(foaf.firstName);
+ * const graph = df.namedNode("http://example.org/graph");
+ *
+ * const query = WITH(graph).DELETE`?person ${firstName} "Jean"`
+ *   .INSERT`?person ${firstName} "Paul"`
+ *   .WHERE`?person ${firstName} "Jean"`
+ *   .build();
+ * console.log(query);
+ * // WITH <http://example.org/graph>
+ * // DELETE { ?person <http://xmlns.com/foaf/0.1/firstName> "Jean" }
+ * // INSERT { ?person <http://xmlns.com/foaf/0.1/firstName> "Paul" }
+ * // WHERE { ?person <http://xmlns.com/foaf/0.1/firstName> "Jean" }
+ * ```
+ */
 export declare const WITH: (stringOrNamedNode: string | RDF.NamedNode<string>) => Builders<"INSERT" | "DELETE">;
 export {};

package/types/mod.d.ts

@@ -1,6 +1,5 @@
-export { type Context, type IQueryEngine } from "./library/rdf.js";
-export { setDefaultContext, setDefaultEngine } from "./library/global.js";
-export { type SchemaInterface } from "./library/schema/mod.js";
-export { createLens, createResource, type Lens } from "./library/lens/mod.js";
-export { createNamespace } from "./library/namespaces/namespace.js";
-export { QueryEngine } from "./library/engine/mod.js";
+export { type Options, setGlobalOptions } from "./library/options.js";
+export type { Identity, Property, Schema, SchemaInterface, SchemaSearchInterface, SchemaUpdateInterface, SupportedDataTypes, } from "./library/schema/mod.js";
+export * from "./library/lens/mod.js";
+export * from "./library/namespace.js";
+export * from "./library/engine/mod.js";