@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Ast-vcw2W-lf.d.mts

@@ -0,0 +1,827 @@
+import { O as Triple, _ as Quad, d as NamedNode, j as Variable, l as Literal, r as DefaultGraph, s as GroundTerm, t as BlankNode } from "./Term-B_4ezyXq.mjs";
+declare namespace Ast_d_exports {
+  export { AggregateExpression, AggregateName, AskQuery, BgpPattern, BindPattern, BuiltInName, ClearOperation, ConstructQuery, CreateOperation, DatasetClause, DeleteDataOperation, DeleteWhereOperation, DescribeQuery, DropOperation, ExistsExpression, Expression, FilterPattern, FunctionCallExpression, GraphOrDefault, GraphPattern, GraphTarget, GroupCondition, GroupPattern, InsertDataOperation, LoadOperation, MinusPattern, ModifyOperation, OperationExpression, Operator, OptionalPattern, OrderCondition, Path, PathAlternative, PathInverse, PathLink, PathNegated, PathOneOrMore, PathPattern, PathSequence, PathZeroOrMore, PathZeroOrOne, Pattern, Projection, Prologue, QuadPattern, Query, QueryBase, SelectQuery, ServicePattern, SubSelectPattern, TermPattern, TransferOperation, TriplePattern, UnionPattern, Update, UpdateOperation, ValuesPattern, VarOrIri, aggregate, alternative, ask, bgp, bind, builtInArity, construct, containsAggregate, describe, emptyPrologue, exists, expressionVariables, filter, functionCall, graph, group, inScopeVariables, inverse, isBuiltInName, isPath, isQuery, isUpdate, link, minus, negated, oneOrMore, operation, optional, pathPattern, projectedVariables, projection, quadPattern, select, sequence, service, subSelect, triplePattern, union, update, values, zeroOrMore, zeroOrOne };
+}
+/**
+ * A term that may appear in a triple pattern: an IRI, literal, blank node,
+ * variable or triple term (whose components may themselves be variables).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type TermPattern = NamedNode | BlankNode | Literal | Variable | Triple<any, any, any>;
+/**
+ * An IRI or a variable.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type VarOrIri = NamedNode | Variable;
+/**
+ * A property path expression (SPARQL 1.1 §9).
+ *
+ * A path consisting of a single IRI is represented as `PathLink`; triple
+ * patterns whose predicate is a plain IRI use `TriplePattern` instead.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Path = PathLink | PathInverse | PathSequence | PathAlternative | PathZeroOrMore | PathOneOrMore | PathZeroOrOne | PathNegated;
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface PathLink {
+  readonly _tag: 'PathLink';
+  readonly iri: NamedNode;
+}
+/**
+ * `^path`
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface PathInverse {
+  readonly _tag: 'PathInverse';
+  readonly path: Path;
+}
+/**
+ * `path1 / path2 / …`
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface PathSequence {
+  readonly _tag: 'PathSequence';
+  readonly paths: ReadonlyArray<Path>;
+}
+/**
+ * `path1 | path2 | …`
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface PathAlternative {
+  readonly _tag: 'PathAlternative';
+  readonly paths: ReadonlyArray<Path>;
+}
+/**
+ * `path*`
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface PathZeroOrMore {
+  readonly _tag: 'PathZeroOrMore';
+  readonly path: Path;
+}
+/**
+ * `path+`
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface PathOneOrMore {
+  readonly _tag: 'PathOneOrMore';
+  readonly path: Path;
+}
+/**
+ * `path?`
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface PathZeroOrOne {
+  readonly _tag: 'PathZeroOrOne';
+  readonly path: Path;
+}
+/**
+ * A negated property set `!(iri1 | ^iri2 | …)`. `iris` are the forward
+ * IRIs and `inverse` the IRIs written with `^`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface PathNegated {
+  readonly _tag: 'PathNegated';
+  readonly iris: ReadonlyArray<NamedNode>;
+  readonly inverse: ReadonlyArray<NamedNode>;
+}
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isPath: (u: unknown) => u is Path;
+/**
+ * A triple pattern whose predicate is an IRI or a variable.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface TriplePattern {
+  readonly _tag: 'TriplePattern';
+  readonly subject: TermPattern;
+  readonly predicate: VarOrIri;
+  readonly object: TermPattern;
+}
+/**
+ * A triple pattern whose predicate is a (non-trivial) property path.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface PathPattern {
+  readonly _tag: 'PathPattern';
+  readonly subject: TermPattern;
+  readonly path: Path;
+  readonly object: TermPattern;
+}
+/**
+ * A triple pattern within a graph: used by update templates (`INSERT`,
+ * `DELETE`, `DELETE WHERE`). `graph` is the default graph for triples
+ * outside of a `GRAPH` block.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface QuadPattern {
+  readonly _tag: 'QuadPattern';
+  readonly subject: TermPattern;
+  readonly predicate: VarOrIri;
+  readonly object: TermPattern;
+  readonly graph: NamedNode | Variable | DefaultGraph;
+}
+/**
+ * The built-in operators and functions of SPARQL 1.1 and 1.2, in their
+ * canonical (upper case) spelling. Unary plus and minus are `UPLUS` and
+ * `UMINUS`; `IN` and `NOT IN` take the tested expression as their first
+ * argument.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Operator = '||' | '&&' | '!' | '=' | '!=' | '<' | '>' | '<=' | '>=' | '+' | '-' | '*' | '/' | 'UPLUS' | 'UMINUS' | 'IN' | 'NOT IN' | BuiltInName;
+/**
+ * Names of the built-in function calls (`BuiltInCall` in the grammar,
+ * excluding aggregates and `EXISTS`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type BuiltInName = 'STR' | 'LANG' | 'LANGMATCHES' | 'LANGDIR' | 'DATATYPE' | 'BOUND' | 'IRI' | 'URI' | 'BNODE' | 'RAND' | 'ABS' | 'CEIL' | 'FLOOR' | 'ROUND' | 'CONCAT' | 'SUBSTR' | 'STRLEN' | 'REPLACE' | 'UCASE' | 'LCASE' | 'ENCODE_FOR_URI' | 'CONTAINS' | 'STRSTARTS' | 'STRENDS' | 'STRBEFORE' | 'STRAFTER' | 'YEAR' | 'MONTH' | 'DAY' | 'HOURS' | 'MINUTES' | 'SECONDS' | 'TIMEZONE' | 'TZ' | 'NOW' | 'UUID' | 'STRUUID' | 'MD5' | 'SHA1' | 'SHA256' | 'SHA384' | 'SHA512' | 'COALESCE' | 'IF' | 'STRLANG' | 'STRLANGDIR' | 'STRDT' | 'SAMETERM' | 'ISIRI' | 'ISURI' | 'ISBLANK' | 'ISLITERAL' | 'ISNUMERIC' | 'HASLANG' | 'HASLANGDIR' | 'REGEX' | 'ISTRIPLE' | 'TRIPLE' | 'SUBJECT' | 'PREDICATE' | 'OBJECT';
+/**
+ * Arity of each built-in function: `[min, max]` (`max` = `Infinity` for
+ * variadic functions).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare const builtInArity: Readonly<Record<BuiltInName, readonly [number, number]>>;
+/**
+ * Whether a (case-insensitive) name is a built-in function.
+ *
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isBuiltInName: (name: string) => name is BuiltInName;
+/**
+ * A SPARQL expression. Variables and constant terms are expressions as-is.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Expression = Variable | NamedNode | Literal | BlankNode | Triple<any, any, any> | OperationExpression | FunctionCallExpression | AggregateExpression | ExistsExpression;
+/**
+ * An operator or built-in function application.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface OperationExpression {
+  readonly _tag: 'Operation';
+  readonly operator: Operator;
+  readonly args: ReadonlyArray<Expression>;
+}
+/**
+ * A call to an extension function (or a cast such as `xsd:integer(?x)`)
+ * identified by IRI.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface FunctionCallExpression {
+  readonly _tag: 'FunctionCall';
+  readonly function: NamedNode;
+  readonly args: ReadonlyArray<Expression>;
+  /** `DISTINCT` was given (only meaningful for custom aggregates). */
+  readonly distinct: boolean;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+type AggregateName = 'COUNT' | 'SUM' | 'MIN' | 'MAX' | 'AVG' | 'SAMPLE' | 'GROUP_CONCAT';
+/**
+ * An aggregate. `expression` is `'*'` for `COUNT(*)`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface AggregateExpression {
+  readonly _tag: 'Aggregate';
+  readonly name: AggregateName;
+  readonly distinct: boolean;
+  readonly expression: Expression | '*';
+  /** The `SEPARATOR` of `GROUP_CONCAT` (defaults to a single space). */
+  readonly separator?: string | undefined;
+}
+/**
+ * `EXISTS { … }` / `NOT EXISTS { … }`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ExistsExpression {
+  readonly _tag: 'Exists';
+  readonly negated: boolean;
+  readonly pattern: GroupPattern;
+}
+/**
+ * An element of a group graph pattern.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Pattern = BgpPattern | GroupPattern | OptionalPattern | UnionPattern | MinusPattern | GraphPattern | ServicePattern | FilterPattern | BindPattern | ValuesPattern | SubSelectPattern;
+/**
+ * A block of triple patterns (`TriplesBlock`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface BgpPattern {
+  readonly _tag: 'Bgp';
+  readonly triples: ReadonlyArray<TriplePattern | PathPattern>;
+}
+/**
+ * A group graph pattern `{ … }`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface GroupPattern {
+  readonly _tag: 'Group';
+  readonly patterns: ReadonlyArray<Pattern>;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface OptionalPattern {
+  readonly _tag: 'Optional';
+  readonly pattern: GroupPattern;
+}
+/**
+ * `{ … } UNION { … } UNION …`
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface UnionPattern {
+  readonly _tag: 'Union';
+  readonly patterns: ReadonlyArray<GroupPattern>;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface MinusPattern {
+  readonly _tag: 'Minus';
+  readonly pattern: GroupPattern;
+}
+/**
+ * `GRAPH ?g { … }`
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface GraphPattern {
+  readonly _tag: 'Graph';
+  readonly name: VarOrIri;
+  readonly pattern: GroupPattern;
+}
+/**
+ * `SERVICE [SILENT] <endpoint> { … }`
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ServicePattern {
+  readonly _tag: 'Service';
+  readonly name: VarOrIri;
+  readonly silent: boolean;
+  readonly pattern: GroupPattern;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface FilterPattern {
+  readonly _tag: 'Filter';
+  readonly expression: Expression;
+}
+/**
+ * `BIND (expr AS ?var)`
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface BindPattern {
+  readonly _tag: 'Bind';
+  readonly expression: Expression;
+  readonly variable: Variable;
+}
+/**
+ * Inline data. Each row has one entry per variable; `undefined` is `UNDEF`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ValuesPattern {
+  readonly _tag: 'Values';
+  readonly variables: ReadonlyArray<Variable>;
+  readonly rows: ReadonlyArray<ReadonlyArray<GroundTerm | undefined>>;
+}
+/**
+ * A nested `SELECT` query.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface SubSelectPattern {
+  readonly _tag: 'SubSelect';
+  readonly query: SelectQuery;
+}
+/**
+ * The prologue of a query or update: the declared base IRI, prefixes and
+ * version. Declarations are kept for pretty printing only; the parser has
+ * already expanded all IRIs.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Prologue {
+  readonly base?: string | undefined;
+  readonly prefixes: Readonly<Record<string, string>>;
+  readonly version?: string | undefined;
+}
+/**
+ * `FROM` and `FROM NAMED` (or `USING` / `USING NAMED`) clauses.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface DatasetClause {
+  readonly default: ReadonlyArray<NamedNode>;
+  readonly named: ReadonlyArray<NamedNode>;
+}
+/**
+ * A `GROUP BY` condition, optionally bound to a variable with `AS`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface GroupCondition {
+  readonly expression: Expression;
+  readonly variable?: Variable | undefined;
+}
+/**
+ * An `ORDER BY` condition.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface OrderCondition {
+  readonly expression: Expression;
+  readonly descending: boolean;
+}
+/**
+ * A projected `(expression AS ?variable)`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Projection {
+  readonly _tag: 'Projection';
+  readonly expression: Expression;
+  readonly variable: Variable;
+}
+/**
+ * Fields shared by all query forms.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface QueryBase {
+  readonly prologue: Prologue;
+  readonly dataset?: DatasetClause | undefined;
+  readonly where: GroupPattern;
+  readonly groupBy: ReadonlyArray<GroupCondition>;
+  readonly having: ReadonlyArray<Expression>;
+  readonly orderBy: ReadonlyArray<OrderCondition>;
+  readonly limit?: number | undefined;
+  readonly offset?: number | undefined;
+  /** A trailing `VALUES` clause. */
+  readonly values?: ValuesPattern | undefined;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface SelectQuery extends QueryBase {
+  readonly _tag: 'Select';
+  readonly distinct: boolean;
+  readonly reduced: boolean;
+  readonly projection: '*' | ReadonlyArray<Variable | Projection>;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface ConstructQuery extends QueryBase {
+  readonly _tag: 'Construct';
+  readonly template: ReadonlyArray<TriplePattern>;
+  /** Whether the short form `CONSTRUCT WHERE { … }` was used. */
+  readonly short?: boolean | undefined;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface AskQuery extends QueryBase {
+  readonly _tag: 'Ask';
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface DescribeQuery extends QueryBase {
+  readonly _tag: 'Describe';
+  readonly terms: '*' | ReadonlyArray<VarOrIri>;
+}
+/**
+ * Any query.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Query = SelectQuery | ConstructQuery | AskQuery | DescribeQuery;
+/**
+ * The target of `CLEAR` / `DROP`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type GraphTarget = NamedNode | {
+  readonly _tag: 'Default';
+} | {
+  readonly _tag: 'Named';
+} | {
+  readonly _tag: 'All';
+};
+/**
+ * A graph or the default graph (`ADD`, `MOVE`, `COPY`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type GraphOrDefault = NamedNode | DefaultGraph;
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface InsertDataOperation {
+  readonly _tag: 'InsertData';
+  readonly quads: ReadonlyArray<Quad>;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface DeleteDataOperation {
+  readonly _tag: 'DeleteData';
+  readonly quads: ReadonlyArray<Quad>;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface DeleteWhereOperation {
+  readonly _tag: 'DeleteWhere';
+  readonly patterns: ReadonlyArray<QuadPattern>;
+}
+/**
+ * `[WITH <g>] DELETE { … } INSERT { … } [USING …] WHERE { … }`
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ModifyOperation {
+  readonly _tag: 'Modify';
+  readonly with?: NamedNode | undefined;
+  readonly delete: ReadonlyArray<QuadPattern>;
+  readonly insert: ReadonlyArray<QuadPattern>;
+  readonly using?: DatasetClause | undefined;
+  readonly where: GroupPattern;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface LoadOperation {
+  readonly _tag: 'Load';
+  readonly silent: boolean;
+  readonly source: NamedNode;
+  readonly destination?: NamedNode | undefined;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface ClearOperation {
+  readonly _tag: 'Clear';
+  readonly silent: boolean;
+  readonly target: GraphTarget;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface DropOperation {
+  readonly _tag: 'Drop';
+  readonly silent: boolean;
+  readonly target: GraphTarget;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface CreateOperation {
+  readonly _tag: 'Create';
+  readonly silent: boolean;
+  readonly graph: NamedNode;
+}
+/**
+ * `ADD`, `MOVE` and `COPY`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface TransferOperation {
+  readonly _tag: 'Add' | 'Move' | 'Copy';
+  readonly silent: boolean;
+  readonly source: GraphOrDefault;
+  readonly destination: GraphOrDefault;
+}
+/**
+ * A single update operation.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type UpdateOperation = InsertDataOperation | DeleteDataOperation | DeleteWhereOperation | ModifyOperation | LoadOperation | ClearOperation | DropOperation | CreateOperation | TransferOperation;
+/**
+ * An update request: a sequence of operations.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Update {
+  readonly _tag: 'Update';
+  readonly prologue: Prologue;
+  readonly operations: ReadonlyArray<UpdateOperation>;
+}
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isQuery: (u: unknown) => u is Query;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isUpdate: (u: unknown) => u is Update;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const emptyPrologue: Prologue;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const triplePattern: (subject: TermPattern, predicate: VarOrIri, object: TermPattern) => TriplePattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const pathPattern: (subject: TermPattern, path: Path, object: TermPattern) => PathPattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const quadPattern: (subject: TermPattern, predicate: VarOrIri, object: TermPattern, graph?: NamedNode | Variable | DefaultGraph) => QuadPattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const link: (iri: NamedNode) => PathLink;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const inverse: (path: Path) => PathInverse;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const sequence: (...paths: ReadonlyArray<Path>) => PathSequence;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const alternative: (...paths: ReadonlyArray<Path>) => PathAlternative;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const zeroOrMore: (path: Path) => PathZeroOrMore;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const oneOrMore: (path: Path) => PathOneOrMore;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const zeroOrOne: (path: Path) => PathZeroOrOne;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const negated: (iris: ReadonlyArray<NamedNode>, inverse?: ReadonlyArray<NamedNode>) => PathNegated;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const operation: (operator: Operator, ...args: ReadonlyArray<Expression>) => OperationExpression;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const functionCall: (fn: NamedNode, args: ReadonlyArray<Expression>, distinct?: boolean) => FunctionCallExpression;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const aggregate: (name: AggregateName, expression: Expression | "*", options?: {
+  readonly distinct?: boolean;
+  readonly separator?: string;
+}) => AggregateExpression;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const exists: (pattern: GroupPattern, negated?: boolean) => ExistsExpression;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const bgp: (triples: ReadonlyArray<TriplePattern | PathPattern>) => BgpPattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const group: (patterns: ReadonlyArray<Pattern>) => GroupPattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const optional: (pattern: GroupPattern) => OptionalPattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const union: (patterns: ReadonlyArray<GroupPattern>) => UnionPattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const minus: (pattern: GroupPattern) => MinusPattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const graph: (name: VarOrIri, pattern: GroupPattern) => GraphPattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const service: (name: VarOrIri, pattern: GroupPattern, silent?: boolean) => ServicePattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const filter: (expression: Expression) => FilterPattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const bind: (expression: Expression, variable: Variable) => BindPattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const values: (variables: ReadonlyArray<Variable>, rows: ReadonlyArray<ReadonlyArray<GroundTerm | undefined>>) => ValuesPattern;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const subSelect: (query: SelectQuery) => SubSelectPattern;
+/**
+ * A projected `(expression AS ?variable)`.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const projection: (expression: Expression, variable: Variable) => Projection;
+/**
+ * Creates a `SELECT` query; omitted fields take their defaults.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const select: (fields: Partial<Omit<SelectQuery, "_tag">> & Pick<SelectQuery, "where">) => SelectQuery;
+/**
+ * Creates a `CONSTRUCT` query.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const construct: (fields: Partial<Omit<ConstructQuery, "_tag">> & Pick<ConstructQuery, "where" | "template">) => ConstructQuery;
+/**
+ * Creates an `ASK` query.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const ask: (fields: Partial<Omit<AskQuery, "_tag">> & Pick<AskQuery, "where">) => AskQuery;
+/**
+ * Creates a `DESCRIBE` query.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const describe: (fields: Partial<Omit<DescribeQuery, "_tag">> & Pick<DescribeQuery, "terms">) => DescribeQuery;
+/**
+ * Creates an update request.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const update: (operations: ReadonlyArray<UpdateOperation>, prologue?: Prologue) => Update;
+/**
+ * The variables that are in-scope after a graph pattern (SPARQL 1.1 §18.2.1),
+ * in order of first appearance. Blank nodes are not included.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const inScopeVariables: (pattern: Pattern) => ReadonlyArray<string>;
+/**
+ * The variables projected by a `SELECT` query (for `SELECT *`, the
+ * in-scope variables of its pattern and trailing `VALUES`).
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const projectedVariables: (query: SelectQuery) => ReadonlyArray<string>;
+/**
+ * All variables mentioned anywhere in an expression (including inside
+ * `EXISTS` patterns when `deep` is set).
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const expressionVariables: (expression: Expression, deep?: boolean) => ReadonlyArray<string>;
+/**
+ * Whether an expression contains an aggregate (outside of nested `EXISTS`
+ * patterns).
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const containsAggregate: (expression: Expression) => boolean;
+export { TransferOperation as $, Operator as A, negated as At, PathSequence as B, service as Bt, GroupCondition as C, inverse as Ct, MinusPattern as D, isUpdate as Dt, LoadOperation as E, isQuery as Et, PathInverse as F, projectedVariables as Ft, Prologue as G, values as Gt, PathZeroOrOne as H, triplePattern as Ht, PathLink as I, projection as It, QueryBase as J, QuadPattern as K, zeroOrMore as Kt, PathNegated as L, quadPattern as Lt, OrderCondition as M, operation as Mt, Path as N, optional as Nt, ModifyOperation as O, link as Ot, PathAlternative as P, pathPattern as Pt, TermPattern as Q, PathOneOrMore as R, select as Rt, GraphTarget as S, inScopeVariables as St, InsertDataOperation as T, isPath as Tt, Pattern as U, union as Ut, PathZeroOrMore as V, subSelect as Vt, Projection as W, update as Wt, ServicePattern as X, SelectQuery as Y, SubSelectPattern as Z, Expression as _, expressionVariables as _t, BgpPattern as a, VarOrIri as at, GraphOrDefault as b, graph as bt, ClearOperation as c, ask as ct, DatasetClause as d, builtInArity as dt, TriplePattern as et, DeleteDataOperation as f, construct as ft, ExistsExpression as g, exists as gt, DropOperation as h, emptyPrologue as ht, Ast_d_exports as i, ValuesPattern as it, OptionalPattern as j, oneOrMore as jt, OperationExpression as k, minus as kt, ConstructQuery as l, bgp as lt, DescribeQuery as m, describe as mt, AggregateName as n, Update as nt, BindPattern as o, aggregate as ot, DeleteWhereOperation as p, containsAggregate as pt, Query as q, zeroOrOne as qt, AskQuery as r, UpdateOperation as rt, BuiltInName as s, alternative as st, AggregateExpression as t, UnionPattern as tt, CreateOperation as u, bind as ut, FilterPattern as v, filter as vt, GroupPattern as w, isBuiltInName as wt, GraphPattern as x, group as xt, FunctionCallExpression as y, functionCall as yt, PathPattern as z, sequence as zt };
+//# sourceMappingURL=Ast-vcw2W-lf.d.mts.map