rdflib 2.2.9 → 2.2.10-4fa7e876

package/lib/patch-parser.d.ts

@@ -0,0 +1,3 @@
+export default function sparqlUpdateParser(str: any, kb: any, base: any): {
+    query: any;
+};

package/lib/query-to-sparql.d.ts

@@ -0,0 +1 @@
+export default function queryToSPARQL(query: any): string;

package/lib/query.d.ts

@@ -0,0 +1,27 @@
+/**
+ * This function will match a pattern to the current Store
+ *
+ * The callback function is called whenever a match is found
+ * When fetcher is supplied this will be called to load from the web
+ * any new nodes as they are discovered.  This will cause the query to traverse the
+ * graph of linked data, sometimes called "Link Following Query"
+ *
+ * @param myQuery - a knowledgebase containing a pattern to use as query
+ * @param callback - whenever the pattern in myQuery is met this is called with
+ *  the new bindings as parameter
+ * @param fetcher? - If and only if,  you want link following, give a fetcher
+ *                which has been created for the quadstore being queried.
+ * @param onDone -  callback when query finished
+ */
+export function indexedFormulaQuery(myQuery: any, callback: any, fetcher: any, onDone: any): void;
+/**
+ * Query class, for tracking queries the user has in the UI.
+ */
+export class Query {
+    constructor(name: any, id: any);
+    pat: IndexedFormula;
+    vars: any[];
+    name: any;
+    id: any;
+}
+import IndexedFormula from "./store";

package/lib/rdfaparser.d.ts

@@ -0,0 +1,78 @@
+declare class RDFaProcessor {
+    static parseRDFaDOM(dom: any, kb: any, base: any): void;
+    static tokenize(str: any): any;
+    static trim(str: any): any;
+    constructor(kb: any, options: any);
+    options: any;
+    kb: any;
+    target: any;
+    blankNodes: any[];
+    htmlOptions: {
+        selfClosing: string;
+    };
+    theOne: string;
+    language: any;
+    vocabulary: any;
+    blankCounter: number;
+    langAttributes: {
+        namespaceURI: string;
+        localName: string;
+    }[];
+    inXHTMLMode: boolean;
+    absURIRE: RegExp;
+    finishedHandlers: any[];
+    addTriple(origin: any, subject: any, predicate: any, object: any): void;
+    ancestorPath(node: any): string;
+    copyMappings(mappings: any): {};
+    copyProperties(): void;
+    deriveDateTimeType(value: any): string | null;
+    init(): void;
+    newBlankNode(): string;
+    newSubjectOrigin(origin: any, subject: any): void;
+    parseCURIE(value: any, prefixes: any, base: any): any;
+    parseCURIEOrURI(value: any, prefixes: any, base: any): any;
+    parsePredicate(value: any, defaultVocabulary: any, terms: any, prefixes: any, base: any, ignoreTerms: any): any;
+    parsePrefixMappings(str: any, target: any): void;
+    parseSafeCURIEOrCURIEOrURI(value: any, prefixes: any, base: any): any;
+    parseTermOrCURIEOrAbsURI(value: any, defaultVocabulary: any, terms: any, prefixes: any, base: any): any;
+    parseTermOrCURIEOrURI(value: any, defaultVocabulary: any, terms: any, prefixes: any, base: any): any;
+    parseURI(uri: any): any;
+    process(node: any, options: any): void;
+    push(parent: any, subject: any): {
+        parent: any;
+        subject: any;
+        parentObject: null;
+        incomplete: never[];
+        listMapping: any;
+        language: any;
+        prefixes: any;
+        terms: any;
+        vocabulary: any;
+    };
+    resolveAndNormalize(base: any, uri: any): string;
+    setContext(node: any): void;
+    setHTMLContext(): void;
+    inHTMLMode: boolean | undefined;
+    setInitialContext(): void;
+    setXHTMLContext(): void;
+    setXMLContext(): void;
+    tokenize(str: any): any;
+    toRDFNodeObject(x: any): any;
+    trim(str: any): any;
+}
+declare namespace RDFaProcessor {
+    const XMLLiteralURI: string;
+    const HTMLLiteralURI: string;
+    const PlainLiteralURI: string;
+    const objectURI: string;
+    const typeURI: string;
+    const nameChar: string;
+    const nameStartChar: string;
+    const NCNAME: RegExp;
+    const dateTimeTypes: {
+        pattern: RegExp;
+        type: string;
+    }[];
+}
+export default RDFaProcessor;
+export function parseRDFaDOM(dom: any, kb: any, base: any): void;

package/lib/rdfxmlparser.d.ts

@@ -0,0 +1,60 @@
+export default class RDFParser {
+    /** Standard namespaces that we know how to handle @final
+     *  @member RDFParser
+     */
+    static ns: {
+        RDF: string;
+        RDFS: string;
+    };
+    /** DOM Level 2 node type magic numbers @final
+     *  @member RDFParser
+     */
+    static nodeType: {
+        ELEMENT: number;
+        ATTRIBUTE: number;
+        TEXT: number;
+        CDATA_SECTION: number;
+        ENTITY_REFERENCE: number;
+        ENTITY: number;
+        PROCESSING_INSTRUCTION: number;
+        COMMENT: number;
+        DOCUMENT: number;
+        DOCUMENT_TYPE: number;
+        DOCUMENT_FRAGMENT: number;
+        NOTATION: number;
+    };
+    constructor(store: any);
+    /** Our triple store reference @private */
+    store: any; /** Our identified blank nodes @private */
+    bnodes: {}; /** A context for context-aware stores @private */
+    why: any; /** Reification flag */
+    reify: boolean;
+    /**
+     * Frame class for namespace and base URI lookups
+     * Base lookups will always resolve because the parser knows
+     * the default base.
+     *
+     * @private
+     */
+    private frameFactory;
+    getAttributeNodeNS(node: any, uri: any, name: any): any;
+    /**
+     * Build our initial scope frame and parse the DOM into triples
+     * @param {DOMTree} document The DOM to parse
+     * @param {String} base The base URL to use
+     * @param {Object} why The context to which this resource belongs
+     */
+    parse(document: any, base: string, why: any): boolean;
+    base: string | undefined;
+    parseDOM(frame: any): void;
+    /**
+     * Cleans out state from a previous parse run
+     * @private
+     */
+    private cleanParser;
+    /**
+     * Builds scope frame
+     * @private
+     */
+    private buildFrame;
+}