terminusdb 12.0.2

package/dist/typescript/lib/query/woqlCore.d.ts

@@ -0,0 +1,341 @@
+export = WOQLQuery;
+/**
+ * @typedef {Object} WOQLJson - JSON-LD representation of a WOQL query
+ * @property {string} @type - The WOQL operation type
+ * @property {*} [subject] - Subject for triple patterns
+ * @property {*} [predicate] - Predicate for triple patterns
+ * @property {*} [object] - Object for triple patterns
+ * @property {WOQLJson[]} [and] - Array of queries for 'And' operations
+ * @property {WOQLJson[]} [or] - Array of queries for 'Or' operations
+ * @property {WOQLJson} [query] - Nested query
+ * @property {string[]} [variables] - Variable list for 'Select' operations
+ * @property {string} [graph] - Graph identifier
+ * @property {*} [consequent] - Consequent for path queries
+ * @property {string} [path_pattern] - Pattern for path queries
+ */
+/**
+ * defines the internal functions of the woql query object - the
+ * language API is defined in WOQLQuery
+ * @module WOQLQuery
+ * @constructor
+ * @param {object} [query] json-ld query for initialisation
+ * @returns {WOQLQuery}
+ */
+declare class WOQLQuery {
+    /**
+     * defines the internal functions of the woql query object - the
+     * language API is defined in WOQLQuery
+     * @module WOQLQuery
+     * @constructor
+     * @param {object} [query] json-ld query for initialisation
+     * @returns {WOQLQuery}
+     */
+    constructor(query?: object);
+    triple_builder_context: {};
+    query: any;
+    counter: number;
+    errors: any[];
+    cursor: {};
+    chain_ended: boolean;
+    contains_update: boolean;
+    paging_transitive_properties: string[];
+    update_operators: string[];
+    vocab: {
+        Class: string;
+        DatatypeProperty: string;
+        ObjectProperty: string;
+        Document: string;
+        abstract: string;
+        comment: string;
+        range: string;
+        domain: string;
+        subClassOf: string;
+        string: string;
+        integer: string;
+        decimal: string;
+        boolean: string;
+        email: string;
+        json: string;
+        dateTime: string;
+        date: string;
+        coordinate: string;
+        line: string;
+        polygon: string;
+    };
+    tripleBuilder: boolean;
+    /**
+     * Basic Error handling
+     */
+    parameterError(msg: any): import("./woqlCore");
+    hasErrors(): boolean;
+    /**
+     * Internal library function which adds a subquery and sets the cursor
+     */
+    addSubQuery(Subq: any): import("./woqlCore");
+    /**
+     * Does this query contain an update
+     */
+    containsUpdate(json: any): any;
+    /**
+     * Called to inidicate that this query will cause an update to the DB
+     */
+    updated(): import("./woqlCore");
+    /**
+     * A bunch of internal functions for formatting values for JSON-LD translation
+     */
+    /**
+     * Wraps the passed value in a json-ld literal carriage
+     */
+    jlt(val: any, type: any): {
+        '@type': any;
+        '@value': any;
+    };
+    varj(varb: any): any;
+    rawVar(varb: any): any;
+    rawVarList(vl: any): any[];
+    /**
+     * Transforms a javascript representation of a query into a json object if needs be
+     */
+    jobj(qobj: any): any;
+    /**
+     * Wraps the elements of an AS variable in the appropriate json-ld
+     */
+    asv(colname_or_index: any, variable: any, type: any): {
+        '@type': string;
+        indicator: {
+            '@type': string;
+            index: number;
+            name?: undefined;
+        } | {
+            '@type': string;
+            name: string;
+            index?: undefined;
+        };
+        variable: any;
+        type: any;
+    };
+    /**
+     * JSON LD Format Descriptor
+     * @param {object} opts
+     */
+    wform(opts: object): import("./woqlCore");
+    /**
+     * Wraps arithmetic operators in the appropriate json-ld
+     */
+    arop(arg: any): any;
+    /**
+     * takes input that can be either a string (variable name)
+     * or an array - each element of the array is a member of the list
+     */
+    dataList(wvar: any, string_only: any): any[] | {
+        '@type': any;
+        variable: any;
+        node?: undefined;
+    } | {
+        '@type': any;
+        node: any;
+        variable?: undefined;
+    };
+    /**
+     * takes a list of input that can be any value
+     */
+    valueList(wvar: any, string_only: any): any[] | {
+        '@type': any;
+        variable: any;
+        node?: undefined;
+    } | {
+        '@type': any;
+        node: any;
+        variable?: undefined;
+    };
+    /**
+     * creates an unadorned variable name list
+     */
+    vlist(list: any): any[];
+    /**
+     * Wraps data values
+     */
+    dataValueList(list: any): any[];
+    /**
+     * Transforms whatever is passed in as the subject into the appropriate json-ld for variable or id
+     */
+    cleanSubject(s: any): any;
+    /**
+     * Transforms whatever is passed in as the predicate (id or variable) into the
+     * appropriate json-ld form
+     */
+    cleanPredicate(p: any): any;
+    wellKnownPredicate(p: any, noxsd: any): boolean;
+    cleanPathPredicate(p: any): boolean;
+    /**
+     * Transforms whatever is passed in as the object of
+     * a triple into the appropriate json-ld form (variable, literal or id)
+     */
+    cleanObject(o: any, t: any): any;
+    cleanDataValue(o: any, t: any): any;
+    cleanArithmeticValue(o: any, t: any): any;
+    cleanNodeValue(o: any, t: any): any;
+    /**
+     * Transforms a graph filter or graph id into the proper json-ld form
+     */
+    cleanGraph(g: any): any;
+    /**
+     * Transforms strings that start with v: into variable json-ld structures
+     * @param varname - will be transformed if it starts with v:
+     */
+    expandVariable(varname: any, type: any, always: any): {
+        '@type': any;
+        variable: any;
+        node?: undefined;
+    } | {
+        '@type': any;
+        node: any;
+        variable?: undefined;
+    };
+    expandValueVariable(varname: any, always: any): {
+        '@type': any;
+        variable: any;
+        node?: undefined;
+    } | {
+        '@type': any;
+        node: any;
+        variable?: undefined;
+    };
+    expandNodeVariable(varname: any, always: any): {
+        '@type': any;
+        variable: any;
+        node?: undefined;
+    } | {
+        '@type': any;
+        node: any;
+        variable?: undefined;
+    };
+    expandDataVariable(varname: any, always: any): {
+        '@type': any;
+        variable: any;
+        node?: undefined;
+    } | {
+        '@type': any;
+        node: any;
+        variable?: undefined;
+    };
+    expandArithmeticVariable(varname: any, always: any): {
+        '@type': any;
+        variable: any;
+        node?: undefined;
+    } | {
+        '@type': any;
+        node: any;
+        variable?: undefined;
+    };
+    defaultContext(DB_IRI: any): {
+        scm: string;
+        doc: string;
+    };
+    /**
+     * Retrieves the value of the current json-ld context
+     */
+    getContext(q: any): any;
+    /**
+     * sets the value of the current json-ld context on a full query scope
+     */
+    context(c: any): void;
+    /**
+     * vocabulary elements that can be used without prefixes in woql.js queries
+     */
+    loadDefaultVocabulary(): {
+        Class: string;
+        DatatypeProperty: string;
+        ObjectProperty: string;
+        Document: string;
+        abstract: string;
+        comment: string;
+        range: string;
+        domain: string;
+        subClassOf: string;
+        string: string;
+        integer: string;
+        decimal: string;
+        boolean: string;
+        email: string;
+        json: string;
+        dateTime: string;
+        date: string;
+        coordinate: string;
+        line: string;
+        polygon: string;
+    };
+    /**
+     * Provides the query with a 'vocabulary' a list of well known predicates that can be used without
+     * prefixes mapping: id: prefix:id ...
+     */
+    setVocabulary(vocab: any): void;
+    getVocabulary(vocab: any): {
+        Class: string;
+        DatatypeProperty: string;
+        ObjectProperty: string;
+        Document: string;
+        abstract: string;
+        comment: string;
+        range: string;
+        domain: string;
+        subClassOf: string;
+        string: string;
+        integer: string;
+        decimal: string;
+        boolean: string;
+        email: string;
+        json: string;
+        dateTime: string;
+        date: string;
+        coordinate: string;
+        line: string;
+        polygon: string;
+    };
+    /**
+     * Use instead woqlclient.query('myWOQLQuery')
+     * @deprecated
+     * Executes the query using the passed client to connect to a server
+     *
+     */
+    execute(client: any, commit_msg: any): any;
+    /**
+     * converts back and forward from json
+     * if the argument is present, the current query is set to it,
+     * if the argument is not present, the current json version of this query is returned
+     * @param {WOQLJson} [json] - a query in json format
+     * @returns {WOQLQuery | WOQLJson} Returns WOQLQuery when setting (for chaining),
+     * or WOQLJson when getting
+     */
+    json(json?: WOQLJson): WOQLQuery | WOQLJson;
+    /**
+     * Returns a script version of the query
+     *
+     * @param {string} [clang] - either "js" or "python"
+     */
+    prettyPrint(clang?: string): any;
+    /**
+     * Finds the last woql element that has a subject in it and returns the json for that
+     * used for triplebuilder to chain further calls - when they may be inside ands or ors or subqueries
+     * @param {object} json
+     */
+    findLastSubject(json: object): any;
+    /**
+     * Finds the last woql element that has a subject in that is a property id
+     * used for triplebuilder to chain further calls - when they may be inside ands or ors or subqueries
+     * @param {object} json
+     */
+    findLastProperty(json: object): any;
+    _is_property_triple(pred: any, obj: any): boolean;
+    /**
+     * Turns a textual path pattern into a JSON-LD description
+     */
+    compilePathPattern(pat: any): any;
+}
+declare namespace WOQLQuery {
+    export { WOQLJson };
+}
+/**
+ * - JSON-LD representation of a WOQL query
+ */
+type WOQLJson = any;

package/dist/typescript/lib/query/woqlDoc.d.ts

@@ -0,0 +1,63 @@
+/**
+* @param  {...string} varNames
+* @returns {object<Var>}
+*/
+export function Vars(...args: any[]): object;
+/**
+* @param  {...string} varNames
+* @returns {object<Var>}
+*/
+export function VarsUnique(...args: any[]): object;
+/**
+ * @param {string} name The variable name
+ * @returns {Var}
+ */
+export function Var(name: string): Var;
+export class Var {
+    /**
+     * @param {string} name The variable name
+     * @returns {Var}
+     */
+    constructor(name: string);
+    name: string;
+    json: () => {
+        '@type': string;
+        variable: string;
+    };
+}
+/**
+ * @param {string} name The variable name
+ * @returns {VarUnique}
+ */
+export function VarUnique(name: string): VarUnique;
+export class VarUnique {
+    /**
+     * @param {string} name The variable name
+     * @returns {VarUnique}
+     */
+    constructor(name: string);
+    name: string;
+    json: () => {
+        '@type': string;
+        variable: string;
+    };
+}
+/**
+ * @param {object} name
+ * @returns {object}
+ */
+export function Doc(obj: any): object;
+export class Doc {
+    /**
+     * @param {object} name
+     * @returns {object}
+     */
+    constructor(obj: any);
+    doc: any;
+    encoded: any;
+}
+/**
+ * Reset the unique variable counter to a specific value
+ * @param {number} start - starting value
+ */
+export function SetVarsUniqueCounter(start: number): void;