terminusdb 12.0.2

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

@@ -0,0 +1,718 @@
+export = WOQLLibrary;
+/**
+ * @typedef {Object} WOQLQuery - WOQL Query Builder class
+ * @property {function} triple - Add a triple pattern
+ * @property {function} and - Logical AND
+ * @property {function} or - Logical OR
+ * @property {function} select - Select variables
+ * @property {function} ask - Ask query
+ * @property {function} limit - Limit results
+ * @property {function} offset - Offset results
+ * @property {function} start - Start query
+ * @property {function} path - Path query
+ * @property {function} subquery - Subquery
+ * @property {function} from - Graph specifier
+ * @property {function} eq - Equality
+ * @property {function} not - Negation
+ * @property {function} greaterThan - Greater than
+ * @property {function} lessThan - Less than
+ * @property {function} greaterThanOrEqual - Greater than or equal
+ * @property {function} lessThanOrEqual - Less than or equal
+ * @property {function} like - String pattern matching
+ * @property {function} plus - Addition
+ * @property {function} minus - Subtraction
+ * @property {function} times - Multiplication
+ * @property {function} divide - Division
+ * @property {function} count - Count aggregation
+ * @property {function} sum - Sum aggregation
+ * @property {function} min - Minimum aggregation
+ * @property {function} max - Maximum aggregation
+ * @property {function} avg - Average aggregation
+ * @property {function} groupBy - Group by
+ * @property {function} orderBy - Order by
+ * @property {function} asc - Ascending order
+ * @property {function} desc - Descending order
+ * @property {function} json - JSON object
+ * @property {function} id - IRI
+ * @property {function} string - String literal
+ * @property {function} datetime - DateTime literal
+ * @property {function} date - Date literal
+ * @property {function} time - Time literal
+ * @property {function} boolean - Boolean literal
+ * @property {function} integer - Integer literal
+ * @property {function} decimal - Decimal literal
+ * @property {function} double - Double literal
+ * @property {function} value - Value literal
+ * @property {function} var - Variable
+ * @property {function} v - Variable shorthand
+ * @property {function} doc - Document
+ * @property {function} class - Class
+ * @property {function} property - Property
+ * @property {function} comment - Comment
+ * @property {function} label - Label
+ * @property {function} prefix - Prefix
+ * @property {function} using - Using
+ * @property {function} optional - Optional
+ * @property {function} union - Union
+ * @property {function} filter - Filter
+ * @property {function} bind - Bind
+ * @property {function} exists - Exists
+ * @property {function} notExists - Not exists
+ * @property {function} graph - Graph
+ * @property {function} named - Named graph
+ * @property {function} values - Values
+ * @property {function} minus - Minus
+ * @property {function} service - Service
+ * @property {function} load - Load
+ * @property {function} clear - Clear
+ * @property {function} drop - Drop
+ * @property {function} add - Add
+ * @property {function} move - Move
+ * @property {function} copy - Copy
+ * @property {function} insert - Insert
+ * @property {function} delete - Delete
+ * @property {function} modify - Modify
+ * @property {function} construct - Construct
+ * @property {function} describe - Describe
+ */
+/**
+ * @license Apache Version 2
+ * @module WOQLLibrary
+ * @constructor WOQLLibrary
+ * @description Library Functions to manage the commits graph
+ * @example
+ *  const woqlLib = WOQLLibrary()
+ *  woqlLib.branches()
+ *
+ *  //or you can call this functions using WOQL Class
+ *  WOQL.lib().branches()
+ * */
+declare class WOQLLibrary {
+    default_schema_resource: string;
+    default_commit_resource: string;
+    default_meta_resource: string;
+    masterdb_resource: string;
+    empty: string;
+    /**
+     * General Pattern 4: Retrieves Branches, Their ID, Head Commit ID, Head Commit Time
+     * (if present, new branches have no commits)
+     */
+    branches(): import("./woqlQuery");
+    /**
+     * get all the commits of a specific branch
+     * if a timestamp is given, gets all the commits before the specified timestamp
+     * @param {string} [branch] - the branch name
+     * @param {number} [limit] - the max number of result
+     * @param {number} [start] - the start of the pagination
+     * @param {number} [timestamp] - Unix timestamp in seconds
+     */
+    commits(branch?: string, limit?: number, start?: number, timestamp?: number): import("./woqlQuery");
+    /**
+    *get commits older than the specified commit id
+    * @param {string} [commit_id] - the commit id
+    * @param {number} [limit] - the max number of result
+    */
+    previousCommits(commit_id?: string, limit?: number): import("./woqlQuery");
+    /**
+     * Finds the id of the very first commit in a database's history
+     *
+     * This is useful for finding information about when, by who and why the database was created
+     * The first commit is the only commit in the database that does not have a parent commit
+     *
+     */
+    first_commit(): import("./woqlQuery");
+    /**
+     * Collect all rdf:List elements into a single array.
+     * Works in two modes:
+     * - Generator: If listVar is unbound, binds it to the array of all rdf:first values
+     * - Matching: If listVar is bound to an array, succeeds only if values match
+     * Uses group_by to collect all values in order (path queries return in hop-count order).
+     * @param {string} consSubject - Variable or IRI of the list cons cell (rdf:List head)
+     * @param {string} listVar - Variable to bind/match the resulting list values array
+     * @returns {WOQLQuery} Query that binds list as array to listVar (single binding)
+     * @example
+     * // Collect all task titles from a document's task list
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_list("v:list_head", "v:all_tasks")
+     * );
+     * // Result: { bindings: [{ "v:all_tasks": ["Task A", "Task B", "Task C"] }] }
+     */
+    rdflist_list(consSubject: string, listVar: string): WOQLQuery;
+    private _rdflist_peek_raw;
+    /**
+     * Get the first element of an rdf:List (peek operation).
+     * Works as generator (binds value) or matcher (checks if first element matches).
+     * @param {string} consSubject - Variable or IRI of the list cons cell
+     * @param {string} valueVar - Variable to bind the first value
+     * @returns {WOQLQuery} Query that binds first value to valueVar
+     * @example
+     * // Get the first task from a project's task list
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_peek("v:list_head", "v:first_task")
+     * );
+     * // Result: { bindings: [{ "v:first_task": "Task A" }] }
+     */
+    rdflist_peek(consSubject: string, valueVar: string): WOQLQuery;
+    /**
+     * Get the last element of an rdf:List
+     * Traverses to the final cons cell (whose rdf:rest is rdf:nil) and gets its rdf:first
+     * @param {string} consSubject - Variable or IRI of the list cons cell
+     * @param {string} valueVar - Variable to bind the last value
+     * @returns {WOQLQuery} Query that binds last value to valueVar
+     */
+    rdflist_last(consSubject: string, valueVar: string): WOQLQuery;
+    private _rdflist_nth0_raw;
+    /**
+     * Get element at 0-indexed position in an rdf:List.
+     * Works as generator (binds value) or matcher (checks if element at index matches).
+     * @param {string} consSubject - Variable or IRI of the list cons cell
+     * @param {number|string} index - 0-based index (number or variable)
+     * @param {string} valueVar - Variable to bind the value at that index
+     * @returns {WOQLQuery} Query that binds value at index to valueVar
+     * @example
+     * // Get the second task (index 1) from a project's task list
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_nth0("v:list_head", 1, "v:second_task")
+     * );
+     * // Result: { bindings: [{ "v:second_task": "Task B" }] }
+     */
+    rdflist_nth0(consSubject: string, index: number | string, valueVar: string): WOQLQuery;
+    /**
+     * Get element at 1-indexed position in an rdf:List.
+     * Works as generator (binds value) or matcher (checks if element at index matches).
+     * @param {string} consSubject - Variable or IRI of the list cons cell
+     * @param {number|string} index - 1-based index (number or variable)
+     * @param {string} valueVar - Variable to bind the value at that index
+     * @returns {WOQLQuery} Query that binds value at index to valueVar
+     * @example
+     * // Get the second task (index 2, 1-based) from a project's task list
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_nth1("v:list_head", 2, "v:second_task")
+     * );
+     * // Result: { bindings: [{ "v:second_task": "Task B" }] }
+     */
+    rdflist_nth1(consSubject: string, index: number | string, valueVar: string): WOQLQuery;
+    private _rdflist_member_raw;
+    /**
+     * Traverse an rdf:List and yield each element as a separate binding (streaming).
+     * Works in two modes:
+     * - Generator: If value is unbound, yields one binding per list element
+     * - Matcher: If value is bound, succeeds only if value is a member of the list
+     * Ideal for large lists and streaming use cases.
+     * @param {string} consSubject - Variable or IRI of the list cons cell (rdf:List head)
+     * @param {string} value - Variable to bind each value, or value to check membership
+     * @returns {WOQLQuery} Query that yields/matches list elements
+     * @example
+     * // Stream all tasks from a project's task list (one binding per element)
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_member("v:list_head", "v:task")
+     * );
+     * // Result: { bindings: [{ "v:task": "Task A" }, { "v:task": "Task B" }, ...] }
+     */
+    rdflist_member(consSubject: string, value: string): WOQLQuery;
+    private _rdflist_length_raw;
+    /**
+     * Get the length of an rdf:List.
+     * Uses path query to traverse all rest links and count them.
+     * Works as generator (binds length) or matcher (checks if length matches).
+     * @param {string} consSubject - Variable or IRI of the list cons cell
+     * @param {string} lengthVar - Variable to bind the length
+     * @returns {WOQLQuery} Query that binds list length to lengthVar
+     * @example
+     * // Get the number of tasks in a project's task list
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_length("v:list_head", "v:count")
+     * );
+     * // Result: { bindings: [{ "v:count": 3 }] }
+     */
+    rdflist_length(consSubject: string, lengthVar: string): WOQLQuery;
+    /**
+     * Pop the first element from an rdf:List in-place.
+     * Removes the first element and promotes the second element to head position.
+     * The list head IRI remains unchanged - the second cons cell is removed.
+     * @param {string} consSubject - Variable or IRI of the list cons cell
+     * @param {string} valueVar - Variable to bind the popped value
+     * @returns {WOQLQuery} Query that pops first element and binds it to valueVar
+     * @example
+     * // Pop the first task from a project's task list
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_pop("v:list_head", "v:first_task")
+     * );
+     * // Result: list [A, B, C] becomes [B, C], binds "A" to v:first_task
+     */
+    rdflist_pop(consSubject: string, valueVar: string): WOQLQuery;
+    /**
+     * Push a new element to the front of an rdf:List in-place.
+     * Modifies the existing cons cell: moves old first value to a new cons cell,
+     * sets new value as rdf:first, and links to the new cons as rdf:rest.
+     * The list head IRI remains unchanged.
+     * @param {string|Var} consSubject - Variable or IRI of the list cons cell
+     * @param {string|Var} value - Value to push to the front
+     * @returns {WOQLQuery} Query that pushes value to front of list in-place
+     * @example
+     * // Push a new task to the front of a project's task list
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_push("v:list_head", WOQL.string("New Task"))
+     * );
+     * // Result: list [A, B, C] becomes [New Task, A, B, C], head IRI unchanged
+     */
+    rdflist_push(consSubject: string | Var, value: string | Var): WOQLQuery;
+    /**
+     * Append an element to the end of an rdf:List.
+     * Traverses to the last cell and adds new cell there.
+     * @param {string|Var} consSubject - Variable or IRI of the list head
+     * @param {string|Var} value - Value to append
+     * @param {string} [newCellVar] - Optional variable to bind the new cell
+     * @returns {WOQLQuery} Query that appends value to end of list
+     * @example
+     * // Append a new task to the end of a project's task list
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_append("v:list_head", WOQL.string("New Task"))
+     * );
+     * // Result: appends "New Task" to end of list
+     */
+    rdflist_append(consSubject: string | Var, value: string | Var, newCell?: string): WOQLQuery;
+    /**
+     * Delete all cons cells of an rdf:List and return rdf:nil as the new list value.
+     * Since a cons cell cannot become rdf:nil, this deletes all cells and binds
+     * rdf:nil to a variable so the caller can update the reference to the list.
+     * NOTE: This only removes the list structure. To delete subdocuments
+     * referenced by the list, use rdflist_member with delete_document first.
+     * @param {string} consSubject - Variable or IRI of the list head
+     * @param {string} newListVar - Variable to bind rdf:nil (the empty list)
+     * @returns {WOQLQuery} Query that deletes all cons cells and binds rdf:nil
+     * @example
+     * // Clear a list of literals and update the reference to point to rdf:nil:
+     * const clearListQuery = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:old_list"),
+     *   WOQL.lib().rdflist_clear("v:old_list", "v:empty_list"),
+     *   WOQL.delete_triple("doc:Project/1", "tasks", "v:old_list"),
+     *   WOQL.add_triple("doc:Project/1", "tasks", "v:empty_list")
+     * );
+     *
+     * // Full pattern: delete subdocuments, clear list, update reference:
+     * const fullClearQuery = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:old_list"),
+     *   WOQL.group_by([], "v:subdoc", "v:members",
+     *     WOQL.and(
+     *       WOQL.lib().rdflist_member("v:old_list", "v:subdoc"),
+     *       WOQL.delete_document("v:subdoc")
+     *     )
+     *   ),
+     *   WOQL.lib().rdflist_clear("v:old_list", "v:empty_list"),
+     *   WOQL.delete_triple("doc:Project/1", "tasks", "v:old_list"),
+     *   WOQL.add_triple("doc:Project/1", "tasks", "v:empty_list")
+     * );
+     */
+    rdflist_clear(consSubject: string, newListVar: string): WOQLQuery;
+    /**
+     * Insert a value at a specific position in an rdf:List.
+     * @param {string} consSubject - Variable or IRI of the list head
+     * @param {number} position - Position to insert at (0-indexed)
+     * @param {string|Var} value - Value to insert
+     * @param {string|Var} [newNodeVar] - Optional variable to bind the new node
+     * @returns {WOQLQuery} Query that inserts value at position
+     * @example
+     * // Insert a task at position 1 in a project's task list
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_insert("v:list_head", 1, WOQL.string("Inserted Task"))
+     * );
+     * // Result: [A, Inserted Task, B, C]
+     */
+    rdflist_insert(consSubject: string, position: number, value: string | Var, newNodeVar?: string | Var): WOQLQuery;
+    /**
+     * Drop/remove a single element from an rdf:List at a specific position.
+     * @param {string} consSubject - Variable or IRI of the list head
+     * @param {number} position - Position of element to remove (0-indexed)
+     * @returns {WOQLQuery} Query that removes the element at position
+     * @example
+     * // Remove the task at position 1 from a project's task list
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_drop("v:list_head", 1)
+     * );
+     * // Result: [A, C] (B removed)
+     */
+    rdflist_drop(consSubject: string, position: number): WOQLQuery;
+    /**
+     * Swap elements at two positions in an rdf:List by exchanging their rdf:first values.
+     * This is a simplified implementation that swaps values in-place without moving cons cells.
+     * @param {string} consSubject - Variable or IRI of the list head
+     * @param {number} posA - First position (0-indexed)
+     * @param {number} posB - Second position (0-indexed)
+     * @returns {WOQLQuery} Query that swaps elements at the two positions
+     * @example
+     * // Swap the first and third tasks in a project's task list
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_swap("v:list_head", 0, 2)
+     * );
+     * // Result: [C, B, A] (A and C swapped)
+     */
+    rdflist_swap(consSubject: string, posA: number, posB: number): WOQLQuery;
+    /**
+     * Create an empty rdf:List (just rdf:nil).
+     * @param {string} listVar - Variable to bind to rdf:nil
+     * @returns {WOQLQuery} Query that creates empty list
+     * @example
+     * // Create an empty list reference
+     * const query = WOQL.lib().rdflist_empty("v:empty_list");
+     * // Result: { bindings: [{ "v:empty_list": "rdf:nil" }] }
+     */
+    rdflist_empty(listVar: string): WOQLQuery;
+    /**
+     * Check if an rdf:List is empty (equals rdf:nil).
+     * @param {string} consSubject - Variable or IRI to check
+     * @returns {WOQLQuery} Query that succeeds if list is empty
+     * @example
+     * // Check if a project's task list is empty
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_is_empty("v:list_head")
+     * );
+     * // Succeeds only if tasks list is rdf:nil
+     */
+    rdflist_is_empty(consSubject: string): WOQLQuery;
+    /**
+     * Extract a slice of an rdf:List (range of elements) as an array.
+     * Works in two modes:
+     * - Generator: If resultVar is unbound, binds it to the array of sliced values
+     * - Matcher: If resultVar is bound to an array, succeeds only if values match
+     * Path queries return results in hop-count order, preserving list element order.
+     * @param {string} consSubject - Variable or IRI of the list head
+     * @param {number|string} start - Start index (inclusive) or variable
+     * @param {number|string} end - End index (exclusive) or variable
+     * @param {string} resultVar - Variable to bind/match the array of sliced values
+     * @returns {WOQLQuery} Query that extracts/matches list slice values
+     * @example
+     * // Get the first two tasks from a project's task list
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_slice("v:list_head", 0, 2, "v:first_two")
+     * );
+     * // Result: { bindings: [{ "v:first_two": ["Task A", "Task B"] }] }
+     */
+    rdflist_slice(consSubject: string, start: number | string, end: number | string, resultVar: string): WOQLQuery;
+    /**
+     * Reverse an rdf:List in-place by swapping rdf:first values across nodes.
+     * Optimized: collects all values once via group_by, then uses slice+member
+     * to index into the collected list instead of double path traversal.
+     * @param {string} consSubject - Variable or IRI of the list to reverse
+     * @returns {WOQLQuery} Query that reverses the list in place
+     * @example
+     * // Reverse a project's task list in place
+     * const query = WOQL.and(
+     *   WOQL.triple("doc:Project/1", "tasks", "v:list_head"),
+     *   WOQL.lib().rdflist_reverse("v:list_head")
+     * );
+     * // Result: [A, B, C] becomes [C, B, A]
+     */
+    rdflist_reverse(consSubject: string): WOQLQuery;
+}
+declare namespace WOQLLibrary {
+    export { WOQLQuery };
+}
+import WOQLQuery = require("./woqlBuilder");
+/**
+ * - WOQL Query Builder class
+ */
+type WOQLQuery = {
+    /**
+     * - Add a triple pattern
+     */
+    triple: Function;
+    /**
+     * - Logical AND
+     */
+    and: Function;
+    /**
+     * - Logical OR
+     */
+    or: Function;
+    /**
+     * - Select variables
+     */
+    select: Function;
+    /**
+     * - Ask query
+     */
+    ask: Function;
+    /**
+     * - Limit results
+     */
+    limit: Function;
+    /**
+     * - Offset results
+     */
+    offset: Function;
+    /**
+     * - Start query
+     */
+    start: Function;
+    /**
+     * - Path query
+     */
+    path: Function;
+    /**
+     * - Subquery
+     */
+    subquery: Function;
+    /**
+     * - Graph specifier
+     */
+    from: Function;
+    /**
+     * - Equality
+     */
+    eq: Function;
+    /**
+     * - Negation
+     */
+    not: Function;
+    /**
+     * - Greater than
+     */
+    greaterThan: Function;
+    /**
+     * - Less than
+     */
+    lessThan: Function;
+    /**
+     * - Greater than or equal
+     */
+    greaterThanOrEqual: Function;
+    /**
+     * - Less than or equal
+     */
+    lessThanOrEqual: Function;
+    /**
+     * - String pattern matching
+     */
+    like: Function;
+    /**
+     * - Addition
+     */
+    plus: Function;
+    /**
+     * - Subtraction
+     */
+    minus: Function;
+    /**
+     * - Multiplication
+     */
+    times: Function;
+    /**
+     * - Division
+     */
+    divide: Function;
+    /**
+     * - Count aggregation
+     */
+    count: Function;
+    /**
+     * - Sum aggregation
+     */
+    sum: Function;
+    /**
+     * - Minimum aggregation
+     */
+    min: Function;
+    /**
+     * - Maximum aggregation
+     */
+    max: Function;
+    /**
+     * - Average aggregation
+     */
+    avg: Function;
+    /**
+     * - Group by
+     */
+    groupBy: Function;
+    /**
+     * - Order by
+     */
+    orderBy: Function;
+    /**
+     * - Ascending order
+     */
+    asc: Function;
+    /**
+     * - Descending order
+     */
+    desc: Function;
+    /**
+     * - JSON object
+     */
+    json: Function;
+    /**
+     * - IRI
+     */
+    id: Function;
+    /**
+     * - String literal
+     */
+    string: Function;
+    /**
+     * - DateTime literal
+     */
+    datetime: Function;
+    /**
+     * - Date literal
+     */
+    date: Function;
+    /**
+     * - Time literal
+     */
+    time: Function;
+    /**
+     * - Boolean literal
+     */
+    boolean: Function;
+    /**
+     * - Integer literal
+     */
+    integer: Function;
+    /**
+     * - Decimal literal
+     */
+    decimal: Function;
+    /**
+     * - Double literal
+     */
+    double: Function;
+    /**
+     * - Value literal
+     */
+    value: Function;
+    /**
+     * - Variable
+     */
+    var: Function;
+    /**
+     * - Variable shorthand
+     */
+    v: Function;
+    /**
+     * - Document
+     */
+    doc: Function;
+    /**
+     * - Class
+     */
+    class: Function;
+    /**
+     * - Property
+     */
+    property: Function;
+    /**
+     * - Comment
+     */
+    comment: Function;
+    /**
+     * - Label
+     */
+    label: Function;
+    /**
+     * - Prefix
+     */
+    prefix: Function;
+    /**
+     * - Using
+     */
+    using: Function;
+    /**
+     * - Optional
+     */
+    optional: Function;
+    /**
+     * - Union
+     */
+    union: Function;
+    /**
+     * - Filter
+     */
+    filter: Function;
+    /**
+     * - Bind
+     */
+    bind: Function;
+    /**
+     * - Exists
+     */
+    exists: Function;
+    /**
+     * - Not exists
+     */
+    notExists: Function;
+    /**
+     * - Graph
+     */
+    graph: Function;
+    /**
+     * - Named graph
+     */
+    named: Function;
+    /**
+     * - Values
+     */
+    values: Function;
+    /**
+     * - Service
+     */
+    service: Function;
+    /**
+     * - Load
+     */
+    load: Function;
+    /**
+     * - Clear
+     */
+    clear: Function;
+    /**
+     * - Drop
+     */
+    drop: Function;
+    /**
+     * - Add
+     */
+    add: Function;
+    /**
+     * - Move
+     */
+    move: Function;
+    /**
+     * - Copy
+     */
+    copy: Function;
+    /**
+     * - Insert
+     */
+    insert: Function;
+    /**
+     * - Delete
+     */
+    delete: Function;
+    /**
+     * - Modify
+     */
+    modify: Function;
+    /**
+     * - Construct
+     */
+    construct: Function;
+    /**
+     * - Describe
+     */
+    describe: Function;
+};