nextgraph/ng_sdk_js.js

nodeJS SDK of NextGraph

let imports = {};
imports['./snippets/ng-sdk-js-9b14f41364028a18/js/node.js'] = require('./snippets/ng-sdk-js-9b14f41364028a18/js/node.js');
imports['__wbindgen_placeholder__'] = module.exports;
let wasm;
const { session_save, session_get, session_remove, local_save, local_get, upload_file, client_details, version, get_env_vars } = require(String.raw`./snippets/ng-sdk-js-9b14f41364028a18/js/node.js`);
const { TextDecoder, TextEncoder } = require(`util`);

let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });

cachedTextDecoder.decode();

let cachedUint8Memory0 = null;

function getUint8Memory0() {
    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
    }
    return cachedUint8Memory0;
}

function getStringFromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
}

const heap = new Array(128).fill(undefined);

heap.push(undefined, null, true, false);

let heap_next = heap.length;

function addHeapObject(obj) {
    if (heap_next === heap.length) heap.push(heap.length + 1);
    const idx = heap_next;
    heap_next = heap[idx];

    heap[idx] = obj;
    return idx;
}

function getObject(idx) { return heap[idx]; }

function dropObject(idx) {
    if (idx < 132) return;
    heap[idx] = heap_next;
    heap_next = idx;
}

function takeObject(idx) {
    const ret = getObject(idx);
    dropObject(idx);
    return ret;
}

let WASM_VECTOR_LEN = 0;

let cachedTextEncoder = new TextEncoder('utf-8');

const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
    ? function (arg, view) {
    return cachedTextEncoder.encodeInto(arg, view);
}
    : function (arg, view) {
    const buf = cachedTextEncoder.encode(arg);
    view.set(buf);
    return {
        read: arg.length,
        written: buf.length
    };
});

function passStringToWasm0(arg, malloc, realloc) {

    if (realloc === undefined) {
        const buf = cachedTextEncoder.encode(arg);
        const ptr = malloc(buf.length, 1) >>> 0;
        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
        WASM_VECTOR_LEN = buf.length;
        return ptr;
    }

    let len = arg.length;
    let ptr = malloc(len, 1) >>> 0;

    const mem = getUint8Memory0();

    let offset = 0;

    for (; offset < len; offset++) {
        const code = arg.charCodeAt(offset);
        if (code > 0x7F) break;
        mem[ptr + offset] = code;
    }

    if (offset !== len) {
        if (offset !== 0) {
            arg = arg.slice(offset);
        }
        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
        const ret = encodeString(arg, view);

        offset += ret.written;
    }

    WASM_VECTOR_LEN = offset;
    return ptr;
}

function isLikeNone(x) {
    return x === undefined || x === null;
}

let cachedInt32Memory0 = null;

function getInt32Memory0() {
    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
    }
    return cachedInt32Memory0;
}

let cachedBigInt64Memory0 = null;

function getBigInt64Memory0() {
    if (cachedBigInt64Memory0 === null || cachedBigInt64Memory0.byteLength === 0) {
        cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
    }
    return cachedBigInt64Memory0;
}

let cachedFloat64Memory0 = null;

function getFloat64Memory0() {
    if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
        cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
    }
    return cachedFloat64Memory0;
}

function debugString(val) {
    // primitive types
    const type = typeof val;
    if (type == 'number' || type == 'boolean' || val == null) {
        return  `${val}`;
    }
    if (type == 'string') {
        return `"${val}"`;
    }
    if (type == 'symbol') {
        const description = val.description;
        if (description == null) {
            return 'Symbol';
        } else {
            return `Symbol(${description})`;
        }
    }
    if (type == 'function') {
        const name = val.name;
        if (typeof name == 'string' && name.length > 0) {
            return `Function(${name})`;
        } else {
            return 'Function';
        }
    }
    // objects
    if (Array.isArray(val)) {
        const length = val.length;
        let debug = '[';
        if (length > 0) {
            debug += debugString(val[0]);
        }
        for(let i = 1; i < length; i++) {
            debug += ', ' + debugString(val[i]);
        }
        debug += ']';
        return debug;
    }
    // Test for built-in
    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
    let className;
    if (builtInMatches.length > 1) {
        className = builtInMatches[1];
    } else {
        // Failed to match the standard '[object ClassName]'
        return toString.call(val);
    }
    if (className == 'Object') {
        // we're a user defined class or Object
        // JSON.stringify avoids problems with cycles, and is generally much
        // easier than looping through ownProperties of `val`.
        try {
            return 'Object(' + JSON.stringify(val) + ')';
        } catch (_) {
            return 'Object';
        }
    }
    // errors
    if (val instanceof Error) {
        return `${val.name}: ${val.message}\n${val.stack}`;
    }
    // TODO we could test for more things here, like `Set`s and `Map`s.
    return className;
}

function makeClosure(arg0, arg1, dtor, f) {
    const state = { a: arg0, b: arg1, cnt: 1, dtor };
    const real = (...args) => {
        // First up with a closure we increment the internal reference
        // count. This ensures that the Rust closure environment won't
        // be deallocated while we're invoking it.
        state.cnt++;
        try {
            return f(state.a, state.b, ...args);
        } finally {
            if (--state.cnt === 0) {
                wasm.__wbindgen_export_2.get(state.dtor)(state.a, state.b);
                state.a = 0;

            }
        }
    };
    real.original = state;

    return real;
}
function __wbg_adapter_54(arg0, arg1, arg2) {
    const ret = wasm._dyn_core__ops__function__Fn__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h1cc9a716422a7194(arg0, arg1, addHeapObject(arg2));
    return takeObject(ret);
}

function __wbg_adapter_57(arg0, arg1, arg2) {
    const ptr0 = passStringToWasm0(arg2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm._dyn_core__ops__function__Fn__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__habb19bb0e5ddad75(arg0, arg1, ptr0, len0);
    return takeObject(ret);
}

function makeMutClosure(arg0, arg1, dtor, f) {
    const state = { a: arg0, b: arg1, cnt: 1, dtor };
    const real = (...args) => {
        // First up with a closure we increment the internal reference
        // count. This ensures that the Rust closure environment won't
        // be deallocated while we're invoking it.
        state.cnt++;
        const a = state.a;
        state.a = 0;
        try {
            return f(a, state.b, ...args);
        } finally {
            if (--state.cnt === 0) {
                wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);

            } else {
                state.a = a;
            }
        }
    };
    real.original = state;

    return real;
}
function __wbg_adapter_60(arg0, arg1) {
    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h4843fe8383e88f1a(arg0, arg1);
}

function __wbg_adapter_63(arg0, arg1, arg2) {
    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h127e6f48f973feba(arg0, arg1, addHeapObject(arg2));
}

function handleError(f, args) {
    try {
        return f.apply(this, args);
    } catch (e) {
        wasm.__wbindgen_exn_store(addHeapObject(e));
    }
}

function getArrayU8FromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
}
function __wbg_adapter_166(arg0, arg1, arg2, arg3) {
    wasm.wasm_bindgen__convert__closures__invoke2_mut__h5a2c72dc49a623c8(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
}

/**
* @returns {Promise<any>}
*/
module.exports.locales = function() {
    const ret = wasm.locales();
    return takeObject(ret);
};

/**
* @returns {Promise<any>}
*/
module.exports.get_device_name = function() {
    const ret = wasm.get_device_name();
    return takeObject(ret);
};

/**
* @param {string} location
* @param {any} invite
* @returns {Promise<any>}
*/
module.exports.get_local_bootstrap = function(location, invite) {
    const ptr0 = passStringToWasm0(location, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.get_local_bootstrap(ptr0, len0, addHeapObject(invite));
    return takeObject(ret);
};

/**
* @param {string} location
* @returns {Promise<any>}
*/
module.exports.get_local_bootstrap_and_domain = function(location) {
    const ptr0 = passStringToWasm0(location, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.get_local_bootstrap_and_domain(ptr0, len0);
    return takeObject(ret);
};

/**
* @param {string} location
* @param {any} invite
* @param {boolean} must_be_public
* @returns {Promise<any>}
*/
module.exports.get_local_bootstrap_with_public = function(location, invite, must_be_public) {
    const ptr0 = passStringToWasm0(location, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.get_local_bootstrap_with_public(ptr0, len0, addHeapObject(invite), must_be_public);
    return takeObject(ret);
};

/**
* @param {string} invite
* @returns {Promise<any>}
*/
module.exports.decode_invitation = function(invite) {
    const ptr0 = passStringToWasm0(invite, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.decode_invitation(ptr0, len0);
    return takeObject(ret);
};

/**
* @param {string} location
* @returns {Promise<any>}
*/
module.exports.get_local_url = function(location) {
    const ptr0 = passStringToWasm0(location, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.get_local_url(ptr0, len0);
    return takeObject(ret);
};

/**
* @param {string} invitation_string
* @returns {Promise<any>}
*/
module.exports.get_ngone_url_of_invitation = function(invitation_string) {
    const ptr0 = passStringToWasm0(invitation_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.get_ngone_url_of_invitation(ptr0, len0);
    return takeObject(ret);
};

/**
* @param {number} pazzle_length
* @returns {any}
*/
module.exports.wallet_gen_shuffle_for_pazzle_opening = function(pazzle_length) {
    const ret = wasm.wallet_gen_shuffle_for_pazzle_opening(pazzle_length);
    return takeObject(ret);
};

/**
* @returns {Uint8Array}
*/
module.exports.wallet_gen_shuffle_for_pin = function() {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.wallet_gen_shuffle_for_pin(retptr);
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var v1 = getArrayU8FromWasm0(r0, r1).slice();
        wasm.__wbindgen_free(r0, r1 * 1);
        return v1;
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
};

/**
* @param {any} privkey
* @returns {string}
*/
module.exports.privkey_to_string = function(privkey) {
    let deferred2_0;
    let deferred2_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.privkey_to_string(retptr, addHeapObject(privkey));
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        var r3 = getInt32Memory0()[retptr / 4 + 3];
        var ptr1 = r0;
        var len1 = r1;
        if (r3) {
            ptr1 = 0; len1 = 0;
            throw takeObject(r2);
        }
        deferred2_0 = ptr1;
        deferred2_1 = len1;
        return getStringFromWasm0(ptr1, len1);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
    }
};

function passArray8ToWasm0(arg, malloc) {
    const ptr = malloc(arg.length * 1, 1) >>> 0;
    getUint8Memory0().set(arg, ptr / 1);
    WASM_VECTOR_LEN = arg.length;
    return ptr;
}
/**
* @param {any} wallet
* @param {Uint8Array} pazzle
* @param {any} pin
* @returns {any}
*/
module.exports.wallet_open_with_pazzle = function(wallet, pazzle, pin) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(pazzle, wasm.__wbindgen_malloc);
        const len0 = WASM_VECTOR_LEN;
        wasm.wallet_open_with_pazzle(retptr, addHeapObject(wallet), ptr0, len0, addHeapObject(pin));
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        if (r2) {
            throw takeObject(r1);
        }
        return takeObject(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
};

/**
* @param {any} wallet
* @param {any} mnemonic
* @param {any} pin
* @returns {any}
*/
module.exports.wallet_open_with_mnemonic = function(wallet, mnemonic, pin) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.wallet_open_with_mnemonic(retptr, addHeapObject(wallet), addHeapObject(mnemonic), addHeapObject(pin));
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        if (r2) {
            throw takeObject(r1);
        }
        return takeObject(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
};

/**
* @param {any} wallet
* @param {Array<any>} mnemonic_words
* @param {any} pin
* @returns {any}
*/
module.exports.wallet_open_with_mnemonic_words = function(wallet, mnemonic_words, pin) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.wallet_open_with_mnemonic_words(retptr, addHeapObject(wallet), addHeapObject(mnemonic_words), addHeapObject(pin));
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        if (r2) {
            throw takeObject(r1);
        }
        return takeObject(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
};

/**
* @param {any} wallet_id
* @param {any} operations
* @returns {any}
*/
module.exports.wallet_update = function(wallet_id, operations) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.wallet_update(retptr, addHeapObject(wallet_id), addHeapObject(operations));
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        if (r2) {
            throw takeObject(r1);
        }
        return takeObject(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
};

/**
* @returns {Promise<any>}
*/
module.exports.get_wallets = function() {
    const ret = wasm.get_wallets();
    return takeObject(ret);
};

/**
* @param {string} wallet_name
* @param {any} user_js
* @returns {Promise<any>}
*/
module.exports.session_start = function(wallet_name, user_js) {
    const ptr0 = passStringToWasm0(wallet_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.session_start(ptr0, len0, addHeapObject(user_js));
    return takeObject(ret);
};

/**
* @param {string} wallet_name
* @param {any} user_js
* @returns {Promise<any>}
*/
module.exports.session_in_memory_start = function(wallet_name, user_js) {
    const ptr0 = passStringToWasm0(wallet_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.session_in_memory_start(ptr0, len0, addHeapObject(user_js));
    return takeObject(ret);
};

/**
* @param {string} user_js
* @returns {Promise<any>}
*/
module.exports.session_headless_start = function(user_js) {
    const ptr0 = passStringToWasm0(user_js, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.session_headless_start(ptr0, len0);
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {boolean} force_close
* @returns {Promise<void>}
*/
module.exports.session_headless_stop = function(session_id, force_close) {
    const ret = wasm.session_headless_stop(addHeapObject(session_id), force_close);
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {string} sparql
* @param {any} base
* @param {any} nuri
* @returns {Promise<any>}
*/
module.exports.sparql_query = function(session_id, sparql, base, nuri) {
    const ptr0 = passStringToWasm0(sparql, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.sparql_query(addHeapObject(session_id), ptr0, len0, addHeapObject(base), addHeapObject(nuri));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {any} update
* @param {Array<any>} heads
* @param {string} crdt
* @param {string} nuri
* @returns {Promise<void>}
*/
module.exports.discrete_update = function(session_id, update, heads, crdt, nuri) {
    const ptr0 = passStringToWasm0(crdt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passStringToWasm0(nuri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.discrete_update(addHeapObject(session_id), addHeapObject(update), addHeapObject(heads), ptr0, len0, ptr1, len1);
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {string} sparql
* @param {any} nuri
* @returns {Promise<any>}
*/
module.exports.sparql_update = function(session_id, sparql, nuri) {
    const ptr0 = passStringToWasm0(sparql, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.sparql_update(addHeapObject(session_id), ptr0, len0, addHeapObject(nuri));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {string} nuri
* @param {any} title
* @param {any} about
* @returns {Promise<void>}
*/
module.exports.update_header = function(session_id, nuri, title, about) {
    const ptr0 = passStringToWasm0(nuri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.update_header(addHeapObject(session_id), ptr0, len0, addHeapObject(title), addHeapObject(about));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {string} nuri
* @returns {Promise<any>}
*/
module.exports.fetch_header = function(session_id, nuri) {
    const ptr0 = passStringToWasm0(nuri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.fetch_header(addHeapObject(session_id), ptr0, len0);
    return takeObject(ret);
};

/**
* @param {any} session_id
* @returns {Promise<string>}
*/
module.exports.rdf_dump = function(session_id) {
    const ret = wasm.rdf_dump(addHeapObject(session_id));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {any} nuri
* @returns {Promise<any>}
*/
module.exports.branch_history = function(session_id, nuri) {
    const ret = wasm.branch_history(addHeapObject(session_id), addHeapObject(nuri));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {any} nuri
* @returns {Promise<any>}
*/
module.exports.signature_status = function(session_id, nuri) {
    const ret = wasm.signature_status(addHeapObject(session_id), addHeapObject(nuri));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {any} nuri
* @returns {Promise<any>}
*/
module.exports.signed_snapshot_request = function(session_id, nuri) {
    const ret = wasm.signed_snapshot_request(addHeapObject(session_id), addHeapObject(nuri));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {any} nuri
* @returns {Promise<any>}
*/
module.exports.signature_request = function(session_id, nuri) {
    const ret = wasm.signature_request(addHeapObject(session_id), addHeapObject(nuri));
    return takeObject(ret);
};

/**
* @param {any} config
* @returns {Promise<any>}
*/
module.exports.admin_create_user = function(config) {
    const ret = wasm.admin_create_user(addHeapObject(config));
    return takeObject(ret);
};

/**
* @param {string} wallet_name
* @param {any} user_js
* @param {any} peer_id_js
* @returns {Promise<any>}
*/
module.exports.session_start_remote = function(wallet_name, user_js, peer_id_js) {
    const ptr0 = passStringToWasm0(wallet_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.session_start_remote(ptr0, len0, addHeapObject(user_js), addHeapObject(peer_id_js));
    return takeObject(ret);
};

/**
* @returns {Promise<void>}
*/
module.exports.wallets_reload = function() {
    const ret = wasm.wallets_reload();
    return takeObject(ret);
};

/**
* @param {any} lws_js
* @returns {Promise<void>}
*/
module.exports.add_in_memory_wallet = function(lws_js) {
    const ret = wasm.add_in_memory_wallet(addHeapObject(lws_js));
    return takeObject(ret);
};

/**
* @param {any} params
* @returns {Promise<any>}
*/
module.exports.wallet_create = function(params) {
    const ret = wasm.wallet_create(addHeapObject(params));
    return takeObject(ret);
};

/**
* @param {string} wallet_name
* @returns {Promise<any>}
*/
module.exports.wallet_get_file = function(wallet_name) {
    const ptr0 = passStringToWasm0(wallet_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.wallet_get_file(ptr0, len0);
    return takeObject(ret);
};

/**
* @param {any} file
* @returns {Promise<any>}
*/
module.exports.wallet_read_file = function(file) {
    const ret = wasm.wallet_read_file(addHeapObject(file));
    return takeObject(ret);
};

/**
* @param {any} code
* @returns {Promise<any>}
*/
module.exports.wallet_import_from_code = function(code) {
    const ret = wasm.wallet_import_from_code(addHeapObject(code));
    return takeObject(ret);
};

/**
* @param {any} size
* @returns {Promise<any>}
*/
module.exports.wallet_import_rendezvous = function(size) {
    const ret = wasm.wallet_import_rendezvous(addHeapObject(size));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {any} size
* @returns {Promise<any>}
*/
module.exports.wallet_export_get_qrcode = function(session_id, size) {
    const ret = wasm.wallet_export_get_qrcode(addHeapObject(session_id), addHeapObject(size));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @returns {Promise<any>}
*/
module.exports.wallet_export_get_textcode = function(session_id) {
    const ret = wasm.wallet_export_get_textcode(addHeapObject(session_id));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {any} code
* @returns {Promise<void>}
*/
module.exports.wallet_export_rendezvous = function(session_id, code) {
    const ret = wasm.wallet_export_rendezvous(addHeapObject(session_id), addHeapObject(code));
    return takeObject(ret);
};

/**
* @param {any} opened_wallet
* @returns {Promise<any>}
*/
module.exports.wallet_was_opened = function(opened_wallet) {
    const ret = wasm.wallet_was_opened(addHeapObject(opened_wallet));
    return takeObject(ret);
};

/**
* @param {any} encrypted_wallet
* @param {any} opened_wallet
* @param {boolean} in_memory
* @returns {Promise<any>}
*/
module.exports.wallet_import = function(encrypted_wallet, opened_wallet, in_memory) {
    const ret = wasm.wallet_import(addHeapObject(encrypted_wallet), addHeapObject(opened_wallet), in_memory);
    return takeObject(ret);
};

/**
* @returns {any}
*/
module.exports.client_info = function() {
    const ret = wasm.client_info();
    return takeObject(ret);
};

/**
* @param {any} payload
* @returns {any}
*/
module.exports.encode_create_account = function(payload) {
    const ret = wasm.encode_create_account(addHeapObject(payload));
    return takeObject(ret);
};

/**
* @returns {Promise<void>}
*/
module.exports.test = function() {
    const ret = wasm.test();
    return takeObject(ret);
};

/**
* @param {any} request
* @param {Function} callback
* @returns {Promise<any>}
*/
module.exports.app_request_stream = function(request, callback) {
    const ret = wasm.app_request_stream(addHeapObject(request), addHeapObject(callback));
    return takeObject(ret);
};

/**
* @param {any} request
* @returns {Promise<any>}
*/
module.exports.app_request = function(request) {
    const ret = wasm.app_request(addHeapObject(request));
    return takeObject(ret);
};

/**
* @param {string} nuri
* @param {any} command
* @param {any} session_id
* @param {any} payload
* @returns {Promise<any>}
*/
module.exports.app_request_with_nuri_command = function(nuri, command, session_id, payload) {
    const ptr0 = passStringToWasm0(nuri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.app_request_with_nuri_command(ptr0, len0, addHeapObject(command), addHeapObject(session_id), addHeapObject(payload));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {string} crdt
* @param {string} class_name
* @param {string} destination
* @param {any} store_type
* @param {any} store_repo
* @returns {Promise<any>}
*/
module.exports.doc_create = function(session_id, crdt, class_name, destination, store_type, store_repo) {
    const ptr0 = passStringToWasm0(crdt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passStringToWasm0(class_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    const ptr2 = passStringToWasm0(destination, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len2 = WASM_VECTOR_LEN;
    const ret = wasm.doc_create(addHeapObject(session_id), ptr0, len0, ptr1, len1, ptr2, len2, addHeapObject(store_type), addHeapObject(store_repo));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {string} nuri
* @param {Function} callback
* @returns {Promise<any>}
*/
module.exports.file_get_from_private_store = function(session_id, nuri, callback) {
    const ptr0 = passStringToWasm0(nuri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.file_get_from_private_store(addHeapObject(session_id), ptr0, len0, addHeapObject(callback));
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {any} reference
* @param {string} branch_nuri
* @param {Function} callback
* @returns {Promise<any>}
*/
module.exports.file_get = function(session_id, reference, branch_nuri, callback) {
    const ptr0 = passStringToWasm0(branch_nuri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.file_get(addHeapObject(session_id), addHeapObject(reference), ptr0, len0, addHeapObject(callback));
    return takeObject(ret);
};

/**
* @param {any} upload_id
* @param {any} session_id
* @param {any} nuri
* @param {string} filename
* @returns {Promise<any>}
*/
module.exports.upload_done = function(upload_id, session_id, nuri, filename) {
    const ptr0 = passStringToWasm0(filename, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.upload_done(addHeapObject(upload_id), addHeapObject(session_id), addHeapObject(nuri), ptr0, len0);
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {string} nuri
* @param {string} mimetype
* @returns {Promise<any>}
*/
module.exports.upload_start = function(session_id, nuri, mimetype) {
    const ptr0 = passStringToWasm0(nuri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passStringToWasm0(mimetype, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.upload_start(addHeapObject(session_id), ptr0, len0, ptr1, len1);
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {string} filename
* @param {string} mimetype
* @returns {Promise<string>}
*/
module.exports.file_put_to_private_store = function(session_id, filename, mimetype) {
    const ptr0 = passStringToWasm0(filename, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passStringToWasm0(mimetype, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.file_put_to_private_store(addHeapObject(session_id), ptr0, len0, ptr1, len1);
    return takeObject(ret);
};

/**
* @param {any} session_id
* @param {any} upload_id
* @param {any} chunk
* @param {string} nuri
* @returns {Promise<any>}
*/
module.exports.upload_chunk = function(session_id, upload_id, chunk, nuri) {
    const ptr0 = passStringToWasm0(nuri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.upload_chunk(addHeapObject(session_id), addHeapObject(upload_id), addHeapObject(chunk), ptr0, len0);
    return takeObject(ret);
};

/**
* @returns {Promise<any>}
*/
module.exports.doc_fetch_private_subscribe = function() {
    const ret = wasm.doc_fetch_private_subscribe();
    return takeObject(ret);
};

/**
* @param {string} repo_o
* @returns {Promise<any>}
*/
module.exports.doc_fetch_repo_subscribe = function(repo_o) {
    const ptr0 = passStringToWasm0(repo_o, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.doc_fetch_repo_subscribe(ptr0, len0);
    return takeObject(ret);
};

/**
* @param {string} repo_o
* @param {any} session_id
* @param {Function} callback
* @returns {Promise<any>}
*/
module.exports.doc_subscribe = function(repo_o, session_id, callback) {
    const ptr0 = passStringToWasm0(repo_o, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.doc_subscribe(ptr0, len0, addHeapObject(session_id), addHeapObject(callback));
    return takeObject(ret);
};

/**
* @param {Function} callback
* @returns {Promise<any>}
*/
module.exports.disconnections_subscribe = function(callback) {
    const ret = wasm.disconnections_subscribe(addHeapObject(callback));
    return takeObject(ret);
};

/**
* @returns {Promise<void>}
*/
module.exports.probe = function() {
    const ret = wasm.probe();
    return takeObject(ret);
};

/**
* @param {any} config
* @returns {Promise<void>}
*/
module.exports.init_headless = function(config) {
    const ret = wasm.init_headless(addHeapObject(config));
    return takeObject(ret);
};

/**
* @returns {Promise<void>}
*/
module.exports.start = function() {
    const ret = wasm.start();
    return takeObject(ret);
};

/**
* @param {string} user_id_js
* @returns {Promise<void>}
*/
module.exports.session_stop = function(user_id_js) {
    const ptr0 = passStringToWasm0(user_id_js, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.session_stop(ptr0, len0);
    return takeObject(ret);
};

/**
* @param {string} user_id_js
* @returns {Promise<void>}
*/
module.exports.user_disconnect = function(user_id_js) {
    const ptr0 = passStringToWasm0(user_id_js, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.user_disconnect(ptr0, len0);
    return takeObject(ret);
};

/**
* @param {string} wallet_name
* @returns {Promise<void>}
*/
module.exports.wallet_close = function(wallet_name) {
    const ptr0 = passStringToWasm0(wallet_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.wallet_close(ptr0, len0);
    return takeObject(ret);
};

/**
* @param {any} client_info_js
* @param {string} user_id_js
* @param {string | undefined} location
* @returns {Promise<any>}
*/
module.exports.user_connect = function(client_info_js, user_id_js, location) {
    const ptr0 = passStringToWasm0(user_id_js, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    var ptr1 = isLikeNone(location) ? 0 : passStringToWasm0(location, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    var len1 = WASM_VECTOR_LEN;
    const ret = wasm.user_connect(addHeapObject(client_info_js), ptr0, len0, ptr1, len1);
    return takeObject(ret);
};

/**
* @param {string} ngd_peer_id
* @returns {Promise<any>}
*/
module.exports.gen_wallet_for_test = function(ngd_peer_id) {
    const ptr0 = passStringToWasm0(ngd_peer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.gen_wallet_for_test(ptr0, len0);
    return takeObject(ret);
};

/**
* @param {string} value
* @returns {NamedNode}
*/
module.exports.namedNode = function(value) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        wasm.namedNode(retptr, ptr0, len0);
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        if (r2) {
            throw takeObject(r1);
        }
        return NamedNode.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
};

/**
* @param {string | undefined} value
* @returns {BlankNode}
*/
module.exports.blankNode = function(value) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        var ptr0 = isLikeNone(value) ? 0 : passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.blankNode(retptr, ptr0, len0);
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        if (r2) {
            throw takeObject(r1);
        }
        return BlankNode.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
};

let stack_pointer = 128;

function addBorrowedObject(obj) {
    if (stack_pointer == 1) throw new Error('out of js stack');
    heap[--stack_pointer] = obj;
    return stack_pointer;
}
/**
* @param {string | undefined} value
* @param {any} language_or_datatype
* @returns {Literal}
*/
module.exports.literal = function(value, language_or_datatype) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        var ptr0 = isLikeNone(value) ? 0 : passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.literal(retptr, ptr0, len0, addBorrowedObject(language_or_datatype));
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        if (r2) {
            throw takeObject(r1);
        }
        return Literal.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        heap[stack_pointer++] = undefined;
    }
};

/**
* @returns {DefaultGraph}
*/
module.exports.defaultGraph = function() {
    const ret = wasm.defaultGraph();
    return DefaultGraph.__wrap(ret);
};

/**
* @param {string} value
* @returns {Variable}
*/
module.exports.variable = function(value) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len0 = WASM_VECTOR_LEN;
        wasm.variable(retptr, ptr0, len0);
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        if (r2) {
            throw takeObject(r1);
        }
        return Variable.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
};

/**
* @param {any} subject
* @param {any} predicate
* @param {any} object
* @returns {Quad}
*/
module.exports.triple = function(subject, predicate, object) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.triple(retptr, addBorrowedObject(subject), addBorrowedObject(predicate), addBorrowedObject(object));
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        if (r2) {
            throw takeObject(r1);
        }
        return Quad.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        heap[stack_pointer++] = undefined;
        heap[stack_pointer++] = undefined;
        heap[stack_pointer++] = undefined;
    }
};

/**
* @param {any} subject
* @param {any} predicate
* @param {any} object
* @param {any} graph
* @returns {Quad}
*/
module.exports.quad = function(subject, predicate, object, graph) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.quad(retptr, addBorrowedObject(subject), addBorrowedObject(predicate), addBorrowedObject(object), addBorrowedObject(graph));
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        if (r2) {
            throw takeObject(r1);
        }
        return Quad.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        heap[stack_pointer++] = undefined;
        heap[stack_pointer++] = undefined;
        heap[stack_pointer++] = undefined;
        heap[stack_pointer++] = undefined;
    }
};

/**
* @param {any} original
* @returns {any}
*/
module.exports.fromTerm = function(original) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.fromTerm(retptr, addBorrowedObject(original));
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        if (r2) {
            throw takeObject(r1);
        }
        return takeObject(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        heap[stack_pointer++] = undefined;
    }
};

/**
* @param {any} original
* @returns {any}
*/
module.exports.fromQuad = function(original) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.fromQuad(retptr, addBorrowedObject(original));
        var r0 = getInt32Memory0()[retptr / 4 + 0];
        var r1 = getInt32Memory0()[retptr / 4 + 1];
        var r2 = getInt32Memory0()[retptr / 4 + 2];
        if (r2) {
            throw takeObject(r1);
        }
        return takeObject(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        heap[stack_pointer++] = undefined;
    }
};

/**
*/
class BlankNode {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(BlankNode.prototype);
        obj.__wbg_ptr = ptr;

        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;

        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_blanknode_free(ptr);
    }
    /**
    * @returns {string}
    */
    get termType() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.blanknode_term_type(retptr, this.__wbg_ptr);
            var r0 = getInt32Memory0()[retptr / 4 + 0];
            var r1 = getInt32Memory0()[retptr / 4 + 1];
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
    * @returns {string}
    */
    get value() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.blanknode_value(retptr, this.__wbg_ptr);
            var r0 = getInt32Memory0()[retptr / 4 + 0];
            var r1 = getInt32Memory0()[retptr / 4 + 1];
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
    * @returns {string}
    */
    toString() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.blanknode_toString(retptr, this.__wbg_ptr);
            var r0 = getInt32Memory0()[retptr / 4 + 0];
            var r1 = getInt32Memory0()[retptr / 4 + 1];
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
    * @param {any} other
    * @returns {boolean}
    */
    equals(other) {
        try {
            const ret = wasm.blanknode_equals(this.__wbg_ptr, addBorrowedObject(other));
            return ret !== 0;
        } finally {
            heap[stack_pointer++] = undefined;
        }
    }
}
module.exports.BlankNode = BlankNode;
/**
*/
class DefaultGraph {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(DefaultGraph.prototype);
        obj.__wbg_ptr = ptr;

        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;

        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_defaultgraph_free(ptr);
    }
    /**
    * @returns {string}
    */
    get termType() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.defaultgraph_term_type(retptr, this.__wbg_ptr);
            var r0 = getInt32Memory0()[retptr / 4 + 0];
            var r1 = getInt32Memory0()[retptr / 4 + 1];
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
    * @returns {string}
    */
    get value() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.defaultgraph_value(retptr, this.__wbg_ptr);
            var r0 = getInt32Memory0()[retptr / 4 + 0];
            var r1 = getInt32Memory0()[retptr / 4 + 1];
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
    * @returns {string}
    */
    toString() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.defaultgraph_toString(retptr, this.__wbg_ptr);
            var r0 = getInt32Memory0()[retptr / 4 + 0];
            var r1 = getInt32Memory0()[retptr / 4 + 1];
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
    * @param {any} other
    * @returns {boolean}
    */
    equals(other) {
        try {
            const ret = wasm.defaultgraph_equals(this.__wbg_ptr, addBorrowedObject(other));
            return ret !== 0;
        } finally {
            heap[stack_pointer++] = undefined;
        }
    }
}
module.exports.DefaultGraph = DefaultGraph;
/**
*/
class Literal {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(Literal.prototype);
        obj.__wbg_ptr = ptr;

        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;

        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_literal_free(ptr);
    }
    /**
    * @returns {string}
    */
    get termType() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.literal_term_type(retptr, this.__wbg_ptr);
            var r0 = getInt32Memory0()[retptr / 4 + 0];
            var r1 = getInt32Memory0()[retptr / 4 + 1];
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
    * @returns {string}
    */
    get value() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.literal_value(retptr, this.__wbg_ptr);
            var r0 = getInt32Memory0()[retptr / 4 + 0];
            var r1 = getInt32Memory0()[retptr / 4 + 1];
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
    * @returns {string}
    */
    get language() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.literal_language(retptr, this.__wbg_ptr);
            var r0 = getInt32Memory0()[retptr / 4 + 0];
            var r1 = getInt32Memory0()[retptr / 4 + 1];
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
    * @returns {NamedNode}
    */
    get datatype() {
        const ret = wasm.literal_datatype(this.__wbg_ptr);
        return NamedNode.__wrap(ret);
    }
    /**
    * @returns {string}
    */
    toString() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.literal_toString(retptr, this.__wbg_ptr);
            var r0 = getInt32Memory0()[retptr / 4 + 0];
            var r1 = getInt32Memory0()[retptr / 4 + 1];
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
    * @param {any} other
    * @returns {boolean}
    */
    equals(other) {
        try {
            const ret = wasm.literal_equals(this.__wbg_ptr, addBorrowedObject(other));
            return ret !== 0;
        } finally {
            heap[stack_pointer++] = undefined;
        }
    }
}
module.exports.Literal = Literal;
/**
*/
class NamedNode {

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(NamedNode.prototype);
        obj.__wbg_ptr = ptr;

        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;

        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_namednode_free(ptr);
    }
    /**
    * @returns {string}
    */
    get termType() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.namednode_term_type(retptr, this.__wbg_ptr);
            var r0 = getInt32Memory0()[retptr / 4 + 0];
            var r1 = getInt32Memory0()[retptr / 4 + 1];
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
    * @returns {string}
    */
    get value() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.namednode_value(retptr, this.__wbg_ptr);
            var r0 = getInt32Memory0()[retptr / 4 + 0];
            var r1 = getInt32Memory0()[retptr / 4 + 1];
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
        }
    }
    /**
    * @returns {string}
    */
    toString() {
        let deferred1_0;
        let deferred1_1