@keyhive/keyhive 0.0.0-alpha.0

package/pkg/keyhive_wasm_bg.js

@@ -0,0 +1,3444 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
+
+let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_2.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
+
+const cachedTextEncoder = new lTextEncoder('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;
+        getUint8ArrayMemory0().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 = getUint8ArrayMemory0();
+
+    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 = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+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 && 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;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(
+state => {
+    wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b);
+}
+);
+
+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_6.get(state.dtor)(a, state.b);
+                CLOSURE_DTORS.unregister(state);
+            } else {
+                state.a = a;
+            }
+        }
+    };
+    real.original = state;
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_2.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+/**
+ * Panic hook lets us get better error messages if our Rust code ever panics.
+ *
+ * This function needs to be called at least once during initialisation.
+ * https://rustwasm.github.io/docs/wasm-pack/tutorials/npm-browser-packages/template-deep-dive/src-utils-rs.html#2-what-is-console_error_panic_hook
+ */
+export function setPanicHook() {
+    wasm.setPanicHook();
+}
+
+function __wbg_adapter_12(arg0, arg1, arg2) {
+    wasm.closure388_externref_shim(arg0, arg1, arg2);
+}
+
+function __wbg_adapter_269(arg0, arg1, arg2, arg3) {
+    wasm.closure525_externref_shim(arg0, arg1, arg2, arg3);
+}
+
+const AccessFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_access_free(ptr >>> 0, 1));
+
+export class Access {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Access.prototype);
+        obj.__wbg_ptr = ptr;
+        AccessFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AccessFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_access_free(ptr, 0);
+    }
+    /**
+     * @param {string} s
+     * @returns {Access | undefined}
+     */
+    static tryFromString(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.access_tryFromString(ptr0, len0);
+        return ret === 0 ? undefined : Access.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.access_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const AddMemberErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_addmembererror_free(ptr >>> 0, 1));
+
+export class AddMemberError {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AddMemberError.prototype);
+        obj.__wbg_ptr = ptr;
+        AddMemberErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AddMemberErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_addmembererror_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.addmembererror_message(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const AgentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_agent_free(ptr >>> 0, 1));
+
+export class Agent {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Agent.prototype);
+        obj.__wbg_ptr = ptr;
+        AgentFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AgentFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_agent_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.agent_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isIndividual() {
+        const ret = wasm.agent_isIndividual(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isGroup() {
+        const ret = wasm.agent_isGroup(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isDocument() {
+        const ret = wasm.agent_isDocument(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get id() {
+        const ret = wasm.agent_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+}
+
+const ArchiveFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_archive_free(ptr >>> 0, 1));
+
+export class Archive {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Archive.prototype);
+        obj.__wbg_ptr = ptr;
+        ArchiveFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ArchiveFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_archive_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.archive_try_from_bytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        ArchiveFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.archive_toBytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @param {CiphertextStore} ciphertext_store
+     * @param {Signer} signer
+     * @param {Function} event_handler
+     * @returns {Keyhive}
+     */
+    tryToKeyhive(ciphertext_store, signer, event_handler) {
+        _assertClass(ciphertext_store, CiphertextStore);
+        var ptr0 = ciphertext_store.__destroy_into_raw();
+        _assertClass(signer, Signer);
+        const ret = wasm.archive_tryToKeyhive(this.__wbg_ptr, ptr0, signer.__wbg_ptr, event_handler);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Keyhive.__wrap(ret[0]);
+    }
+}
+
+const CannotParseEd25519SigningKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cannotparseed25519signingkey_free(ptr >>> 0, 1));
+
+export class CannotParseEd25519SigningKey {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CannotParseEd25519SigningKey.prototype);
+        obj.__wbg_ptr = ptr;
+        CannotParseEd25519SigningKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CannotParseEd25519SigningKeyFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_cannotparseed25519signingkey_free(ptr, 0);
+    }
+}
+
+const CannotParseIdentifierFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cannotparseidentifier_free(ptr >>> 0, 1));
+
+export class CannotParseIdentifier {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CannotParseIdentifier.prototype);
+        obj.__wbg_ptr = ptr;
+        CannotParseIdentifierFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CannotParseIdentifierFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_cannotparseidentifier_free(ptr, 0);
+    }
+}
+
+const CapabilityFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_capability_free(ptr >>> 0, 1));
+
+export class Capability {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Capability.prototype);
+        obj.__wbg_ptr = ptr;
+        CapabilityFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CapabilityFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_capability_free(ptr, 0);
+    }
+    /**
+     * @returns {Agent}
+     */
+    get who() {
+        const ret = wasm.capability_who(this.__wbg_ptr);
+        return Agent.__wrap(ret);
+    }
+    /**
+     * @returns {Access}
+     */
+    get can() {
+        const ret = wasm.capability_can(this.__wbg_ptr);
+        return Access.__wrap(ret);
+    }
+    /**
+     * @returns {SignedDelegation}
+     */
+    get proof() {
+        const ret = wasm.capability_proof(this.__wbg_ptr);
+        return SignedDelegation.__wrap(ret);
+    }
+}
+
+const CgkaOperationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cgkaoperation_free(ptr >>> 0, 1));
+
+export class CgkaOperation {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CgkaOperation.prototype);
+        obj.__wbg_ptr = ptr;
+        CgkaOperationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CgkaOperationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_cgkaoperation_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get variant() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.cgkaoperation_variant(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const ChangeRefFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_changeref_free(ptr >>> 0, 1));
+
+export class ChangeRef {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ChangeRef.prototype);
+        obj.__wbg_ptr = ptr;
+        ChangeRefFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof ChangeRef)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChangeRefFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_changeref_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.changeref_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        ChangeRefFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get bytes() {
+        const ret = wasm.changeref_bytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+
+const CiphertextStoreFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ciphertextstore_free(ptr >>> 0, 1));
+
+export class CiphertextStore {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CiphertextStore.prototype);
+        obj.__wbg_ptr = ptr;
+        CiphertextStoreFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CiphertextStoreFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ciphertextstore_free(ptr, 0);
+    }
+    /**
+     * @returns {CiphertextStore}
+     */
+    static newInMemory() {
+        const ret = wasm.ciphertextstore_newInMemory();
+        return CiphertextStore.__wrap(ret);
+    }
+    /**
+     * @param {Storage} storage
+     * @returns {CiphertextStore}
+     */
+    static newFromWebStorage(storage) {
+        const ret = wasm.ciphertextstore_newFromWebStorage(storage);
+        return CiphertextStore.__wrap(ret);
+    }
+}
+
+const ContactCardFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_contactcard_free(ptr >>> 0, 1));
+
+export class ContactCard {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ContactCard.prototype);
+        obj.__wbg_ptr = ptr;
+        ContactCardFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ContactCardFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_contactcard_free(ptr, 0);
+    }
+    /**
+     * @returns {IndividualId}
+     */
+    get id() {
+        const ret = wasm.contactcard_id(this.__wbg_ptr);
+        return IndividualId.__wrap(ret);
+    }
+    /**
+     * @returns {ShareKey}
+     */
+    get shareKey() {
+        const ret = wasm.contactcard_shareKey(this.__wbg_ptr);
+        return ShareKey.__wrap(ret);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    signature() {
+        const ret = wasm.contactcard_signature(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @param {string} json
+     * @returns {ContactCard}
+     */
+    static fromJson(json) {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.contactcard_fromJson(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ContactCard.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toJson() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.contactcard_toJson(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+
+const DelegationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_delegation_free(ptr >>> 0, 1));
+
+export class Delegation {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Delegation.prototype);
+        obj.__wbg_ptr = ptr;
+        DelegationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DelegationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_delegation_free(ptr, 0);
+    }
+    /**
+     * @returns {Agent}
+     */
+    get delegate() {
+        const ret = wasm.delegation_delegate(this.__wbg_ptr);
+        return Agent.__wrap(ret);
+    }
+    /**
+     * @returns {Access}
+     */
+    get can() {
+        const ret = wasm.delegation_can(this.__wbg_ptr);
+        return Access.__wrap(ret);
+    }
+    /**
+     * @returns {SignedDelegation | undefined}
+     */
+    get proof() {
+        const ret = wasm.delegation_proof(this.__wbg_ptr);
+        return ret === 0 ? undefined : SignedDelegation.__wrap(ret);
+    }
+    /**
+     * @returns {History}
+     */
+    get after() {
+        const ret = wasm.delegation_after(this.__wbg_ptr);
+        return History.__wrap(ret);
+    }
+}
+
+const DelegationErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_delegationerror_free(ptr >>> 0, 1));
+
+export class DelegationError {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DelegationErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_delegationerror_free(ptr, 0);
+    }
+}
+
+const DocContentRefsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_doccontentrefs_free(ptr >>> 0, 1));
+
+export class DocContentRefs {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DocContentRefs.prototype);
+        obj.__wbg_ptr = ptr;
+        DocContentRefsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DocContentRefsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_doccontentrefs_free(ptr, 0);
+    }
+    /**
+     * @param {DocumentId} doc_id
+     * @param {ChangeRef[]} change_hashes
+     */
+    constructor(doc_id, change_hashes) {
+        _assertClass(doc_id, DocumentId);
+        var ptr0 = doc_id.__destroy_into_raw();
+        const ptr1 = passArrayJsValueToWasm0(change_hashes, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.doccontentrefs_new(ptr0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        DocContentRefsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {ChangeRef} hash
+     */
+    addChangeRef(hash) {
+        _assertClass(hash, ChangeRef);
+        var ptr0 = hash.__destroy_into_raw();
+        wasm.doccontentrefs_addChangeRef(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {DocumentId}
+     */
+    get docId() {
+        const ret = wasm.doccontentrefs_docId(this.__wbg_ptr);
+        return DocumentId.__wrap(ret);
+    }
+    /**
+     * @returns {ChangeRef[]}
+     */
+    get change_hashes() {
+        const ret = wasm.doccontentrefs_change_hashes(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+
+const DocumentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_document_free(ptr >>> 0, 1));
+
+export class Document {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Document.prototype);
+        obj.__wbg_ptr = ptr;
+        DocumentFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof Document)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DocumentFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_document_free(ptr, 0);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get id() {
+        const ret = wasm.document_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {DocumentId}
+     */
+    get doc_id() {
+        const ret = wasm.document_doc_id(this.__wbg_ptr);
+        return DocumentId.__wrap(ret);
+    }
+    /**
+     * @returns {Peer}
+     */
+    toPeer() {
+        const ret = wasm.document_toPeer(this.__wbg_ptr);
+        return Peer.__wrap(ret);
+    }
+    /**
+     * @returns {Agent}
+     */
+    toAgent() {
+        const ret = wasm.document_toAgent(this.__wbg_ptr);
+        return Agent.__wrap(ret);
+    }
+}
+
+const DocumentIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_documentid_free(ptr >>> 0, 1));
+
+export class DocumentId {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DocumentId.prototype);
+        obj.__wbg_ptr = ptr;
+        DocumentIdFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DocumentIdFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_documentid_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.documentid_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        DocumentIdFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    fromString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.documentid_fromString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {any}
+     */
+    toJsValue() {
+        const ret = wasm.documentid_toJsValue(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.documentid_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+
+const EncryptedFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_encrypted_free(ptr >>> 0, 1));
+
+export class Encrypted {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Encrypted.prototype);
+        obj.__wbg_ptr = ptr;
+        EncryptedFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EncryptedFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_encrypted_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.encrypted_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get ciphertext() {
+        const ret = wasm.encrypted_ciphertext(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get nonce() {
+        const ret = wasm.encrypted_nonce(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get pcs_key_hash() {
+        const ret = wasm.encrypted_pcs_key_hash(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get content_ref() {
+        const ret = wasm.encrypted_content_ref(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get pred_refs() {
+        const ret = wasm.encrypted_pred_refs(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+
+const EncryptedContentWithUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_encryptedcontentwithupdate_free(ptr >>> 0, 1));
+
+export class EncryptedContentWithUpdate {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(EncryptedContentWithUpdate.prototype);
+        obj.__wbg_ptr = ptr;
+        EncryptedContentWithUpdateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EncryptedContentWithUpdateFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_encryptedcontentwithupdate_free(ptr, 0);
+    }
+    /**
+     * @returns {Encrypted}
+     */
+    encrypted_content() {
+        const ret = wasm.encryptedcontentwithupdate_encrypted_content(this.__wbg_ptr);
+        return Encrypted.__wrap(ret);
+    }
+    /**
+     * @returns {SignedCgkaOperation | undefined}
+     */
+    update_op() {
+        const ret = wasm.encryptedcontentwithupdate_update_op(this.__wbg_ptr);
+        return ret === 0 ? undefined : SignedCgkaOperation.__wrap(ret);
+    }
+}
+
+const EventFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_event_free(ptr >>> 0, 1));
+
+export class Event {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Event.prototype);
+        obj.__wbg_ptr = ptr;
+        EventFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EventFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_event_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get variant() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.event_variant(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    get isDelegated() {
+        const ret = wasm.event_isDelegated(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get isRevoked() {
+        const ret = wasm.event_isRevoked(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {SignedDelegation | undefined}
+     */
+    tryIntoSignedDelegation() {
+        const ret = wasm.event_tryIntoSignedDelegation(this.__wbg_ptr);
+        return ret === 0 ? undefined : SignedDelegation.__wrap(ret);
+    }
+    /**
+     * @returns {SignedRevocation | undefined}
+     */
+    tryIntoSignedRevocation() {
+        const ret = wasm.event_tryIntoSignedRevocation(this.__wbg_ptr);
+        return ret === 0 ? undefined : SignedRevocation.__wrap(ret);
+    }
+}
+
+const GenerateDocErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_generatedocerror_free(ptr >>> 0, 1));
+
+export class GenerateDocError {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GenerateDocError.prototype);
+        obj.__wbg_ptr = ptr;
+        GenerateDocErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GenerateDocErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_generatedocerror_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.generatedocerror_message(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const GenerateWebCryptoErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_generatewebcryptoerror_free(ptr >>> 0, 1));
+
+export class GenerateWebCryptoError {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GenerateWebCryptoError.prototype);
+        obj.__wbg_ptr = ptr;
+        GenerateWebCryptoErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GenerateWebCryptoErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_generatewebcryptoerror_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.generatewebcryptoerror_message(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const GetCiphertextErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_getciphertexterror_free(ptr >>> 0, 1));
+
+export class GetCiphertextError {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GetCiphertextErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_getciphertexterror_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.getciphertexterror_message(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const GroupFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_group_free(ptr >>> 0, 1));
+
+export class Group {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Group.prototype);
+        obj.__wbg_ptr = ptr;
+        GroupFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GroupFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_group_free(ptr, 0);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get id() {
+        const ret = wasm.group_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {GroupId}
+     */
+    get groupId() {
+        const ret = wasm.group_groupId(this.__wbg_ptr);
+        return GroupId.__wrap(ret);
+    }
+    /**
+     * @returns {Capability[]}
+     */
+    get members() {
+        const ret = wasm.group_members(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Peer}
+     */
+    toPeer() {
+        const ret = wasm.group_toPeer(this.__wbg_ptr);
+        return Peer.__wrap(ret);
+    }
+    /**
+     * @returns {Agent}
+     */
+    toAgent() {
+        const ret = wasm.group_toAgent(this.__wbg_ptr);
+        return Agent.__wrap(ret);
+    }
+    /**
+     * @returns {Membered}
+     */
+    toMembered() {
+        const ret = wasm.group_toMembered(this.__wbg_ptr);
+        return Membered.__wrap(ret);
+    }
+}
+
+const GroupIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_groupid_free(ptr >>> 0, 1));
+
+export class GroupId {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GroupId.prototype);
+        obj.__wbg_ptr = ptr;
+        GroupIdFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GroupIdFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_groupid_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.groupid_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const HistoryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_history_free(ptr >>> 0, 1));
+
+export class History {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(History.prototype);
+        obj.__wbg_ptr = ptr;
+        HistoryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HistoryFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_history_free(ptr, 0);
+    }
+    /**
+     * @returns {SignedDelegation[]}
+     */
+    delegations() {
+        const ret = wasm.history_delegations(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {SignedRevocation[]}
+     */
+    revocations() {
+        const ret = wasm.history_revocations(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {DocContentRefs[]}
+     */
+    contentRefs() {
+        const ret = wasm.history_contentRefs(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+
+const IdentifierFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_identifier_free(ptr >>> 0, 1));
+
+export class Identifier {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Identifier.prototype);
+        obj.__wbg_ptr = ptr;
+        IdentifierFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IdentifierFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_identifier_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identifier_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        IdentifierFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.identifier_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+
+const IndividualFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_individual_free(ptr >>> 0, 1));
+
+export class Individual {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Individual.prototype);
+        obj.__wbg_ptr = ptr;
+        IndividualFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IndividualFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_individual_free(ptr, 0);
+    }
+    /**
+     * @returns {Peer}
+     */
+    toPeer() {
+        const ret = wasm.individual_toPeer(this.__wbg_ptr);
+        return Peer.__wrap(ret);
+    }
+    /**
+     * @returns {Agent}
+     */
+    toAgent() {
+        const ret = wasm.individual_toAgent(this.__wbg_ptr);
+        return Agent.__wrap(ret);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get id() {
+        const ret = wasm.individual_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {IndividualId}
+     */
+    get individualId() {
+        const ret = wasm.individual_individualId(this.__wbg_ptr);
+        return IndividualId.__wrap(ret);
+    }
+    /**
+     * @param {DocumentId} doc_id
+     * @returns {ShareKey}
+     */
+    pickPrekey(doc_id) {
+        _assertClass(doc_id, DocumentId);
+        var ptr0 = doc_id.__destroy_into_raw();
+        const ret = wasm.individual_pickPrekey(this.__wbg_ptr, ptr0);
+        return ShareKey.__wrap(ret);
+    }
+}
+
+const IndividualIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_individualid_free(ptr >>> 0, 1));
+
+export class IndividualId {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(IndividualId.prototype);
+        obj.__wbg_ptr = ptr;
+        IndividualIdFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IndividualIdFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_individualid_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get bytes() {
+        const ret = wasm.individualid_bytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+
+const InvocationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_invocation_free(ptr >>> 0, 1));
+
+export class Invocation {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        InvocationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_invocation_free(ptr, 0);
+    }
+}
+
+const JsDecryptErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsdecrypterror_free(ptr >>> 0, 1));
+
+export class JsDecryptError {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsDecryptError.prototype);
+        obj.__wbg_ptr = ptr;
+        JsDecryptErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsDecryptErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsdecrypterror_free(ptr, 0);
+    }
+}
+
+const JsEncryptErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsencrypterror_free(ptr >>> 0, 1));
+
+export class JsEncryptError {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsEncryptError.prototype);
+        obj.__wbg_ptr = ptr;
+        JsEncryptErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsEncryptErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsencrypterror_free(ptr, 0);
+    }
+}
+
+const JsReceivePreKeyOpErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsreceiveprekeyoperror_free(ptr >>> 0, 1));
+
+export class JsReceivePreKeyOpError {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsReceivePreKeyOpError.prototype);
+        obj.__wbg_ptr = ptr;
+        JsReceivePreKeyOpErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsReceivePreKeyOpErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsreceiveprekeyoperror_free(ptr, 0);
+    }
+}
+
+const JsReceiveStaticEventErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsreceivestaticeventerror_free(ptr >>> 0, 1));
+
+export class JsReceiveStaticEventError {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsReceiveStaticEventErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsreceivestaticeventerror_free(ptr, 0);
+    }
+}
+
+const KeyhiveFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_keyhive_free(ptr >>> 0, 1));
+
+export class Keyhive {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Keyhive.prototype);
+        obj.__wbg_ptr = ptr;
+        KeyhiveFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        KeyhiveFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_keyhive_free(ptr, 0);
+    }
+    /**
+     * @param {Signer} signer
+     * @param {CiphertextStore} ciphertext_store
+     * @param {Function} event_handler
+     * @returns {Promise<Keyhive>}
+     */
+    static init(signer, ciphertext_store, event_handler) {
+        _assertClass(signer, Signer);
+        _assertClass(ciphertext_store, CiphertextStore);
+        var ptr0 = ciphertext_store.__destroy_into_raw();
+        const ret = wasm.keyhive_init(signer.__wbg_ptr, ptr0, event_handler);
+        return ret;
+    }
+    /**
+     * @returns {IndividualId}
+     */
+    get id() {
+        const ret = wasm.keyhive_id(this.__wbg_ptr);
+        return IndividualId.__wrap(ret);
+    }
+    /**
+     * @returns {IndividualId}
+     */
+    get whoami() {
+        const ret = wasm.keyhive_id(this.__wbg_ptr);
+        return IndividualId.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get idString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.keyhive_idString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {Peer[]} coparents
+     * @returns {Promise<Group>}
+     */
+    generateGroup(coparents) {
+        const ptr0 = passArrayJsValueToWasm0(coparents, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.keyhive_generateGroup(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {Peer[]} coparents
+     * @param {ChangeRef} initial_content_ref_head
+     * @param {ChangeRef[]} more_initial_content_refs
+     * @returns {Promise<Document>}
+     */
+    generateDocument(coparents, initial_content_ref_head, more_initial_content_refs) {
+        const ptr0 = passArrayJsValueToWasm0(coparents, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(initial_content_ref_head, ChangeRef);
+        var ptr1 = initial_content_ref_head.__destroy_into_raw();
+        const ptr2 = passArrayJsValueToWasm0(more_initial_content_refs, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.keyhive_generateDocument(this.__wbg_ptr, ptr0, len0, ptr1, ptr2, len2);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} data
+     * @returns {Promise<Signed>}
+     */
+    trySign(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.keyhive_trySign(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {Document} doc
+     * @param {ChangeRef} content_ref
+     * @param {ChangeRef[]} pred_refs
+     * @param {Uint8Array} content
+     * @returns {Promise<EncryptedContentWithUpdate>}
+     */
+    tryEncrypt(doc, content_ref, pred_refs, content) {
+        _assertClass(doc, Document);
+        var ptr0 = doc.__destroy_into_raw();
+        _assertClass(content_ref, ChangeRef);
+        var ptr1 = content_ref.__destroy_into_raw();
+        const ptr2 = passArrayJsValueToWasm0(pred_refs, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray8ToWasm0(content, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.keyhive_tryEncrypt(this.__wbg_ptr, ptr0, ptr1, ptr2, len2, ptr3, len3);
+        return ret;
+    }
+    /**
+     * @param {Document} doc
+     * @param {ChangeRef} content_ref
+     * @param {ChangeRef[]} pred_refs
+     * @param {Uint8Array} content
+     * @returns {Promise<EncryptedContentWithUpdate>}
+     */
+    tryEncryptArchive(doc, content_ref, pred_refs, content) {
+        _assertClass(doc, Document);
+        var ptr0 = doc.__destroy_into_raw();
+        _assertClass(content_ref, ChangeRef);
+        var ptr1 = content_ref.__destroy_into_raw();
+        const ptr2 = passArrayJsValueToWasm0(pred_refs, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray8ToWasm0(content, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.keyhive_tryEncryptArchive(this.__wbg_ptr, ptr0, ptr1, ptr2, len2, ptr3, len3);
+        return ret;
+    }
+    /**
+     * @param {Document} doc
+     * @param {Encrypted} encrypted
+     * @returns {Uint8Array}
+     */
+    tryDecrypt(doc, encrypted) {
+        _assertClass(doc, Document);
+        var ptr0 = doc.__destroy_into_raw();
+        _assertClass(encrypted, Encrypted);
+        var ptr1 = encrypted.__destroy_into_raw();
+        const ret = wasm.keyhive_tryDecrypt(this.__wbg_ptr, ptr0, ptr1);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v3;
+    }
+    /**
+     * @param {Agent} to_add
+     * @param {Membered} membered
+     * @param {Access} access
+     * @param {Document[]} other_relevant_docs
+     * @returns {Promise<SignedDelegation>}
+     */
+    addMember(to_add, membered, access, other_relevant_docs) {
+        _assertClass(to_add, Agent);
+        _assertClass(membered, Membered);
+        _assertClass(access, Access);
+        var ptr0 = access.__destroy_into_raw();
+        const ptr1 = passArrayJsValueToWasm0(other_relevant_docs, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.keyhive_addMember(this.__wbg_ptr, to_add.__wbg_ptr, membered.__wbg_ptr, ptr0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {Agent} to_revoke
+     * @param {boolean} retain_all_other_members
+     * @param {Membered} membered
+     * @returns {Promise<SignedRevocation[]>}
+     */
+    revokeMember(to_revoke, retain_all_other_members, membered) {
+        _assertClass(to_revoke, Agent);
+        _assertClass(membered, Membered);
+        const ret = wasm.keyhive_revokeMember(this.__wbg_ptr, to_revoke.__wbg_ptr, retain_all_other_members, membered.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Summary[]}
+     */
+    reachableDocs() {
+        const ret = wasm.keyhive_reachableDocs(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {Document} doc
+     * @returns {Promise<void>}
+     */
+    forcePcsUpdate(doc) {
+        _assertClass(doc, Document);
+        const ret = wasm.keyhive_forcePcsUpdate(this.__wbg_ptr, doc.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {ShareKey} prekey
+     * @returns {Promise<ShareKey>}
+     */
+    rotatePrekey(prekey) {
+        _assertClass(prekey, ShareKey);
+        var ptr0 = prekey.__destroy_into_raw();
+        const ret = wasm.keyhive_rotatePrekey(this.__wbg_ptr, ptr0);
+        return ret;
+    }
+    /**
+     * @returns {Promise<ShareKey>}
+     */
+    expandPrekeys() {
+        const ret = wasm.keyhive_expandPrekeys(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<ContactCard>}
+     */
+    contactCard() {
+        const ret = wasm.keyhive_contactCard(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {ContactCard} contact_card
+     * @returns {Individual}
+     */
+    receiveContactCard(contact_card) {
+        _assertClass(contact_card, ContactCard);
+        var ptr0 = contact_card.__destroy_into_raw();
+        const ret = wasm.keyhive_receiveContactCard(this.__wbg_ptr, ptr0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Individual.__wrap(ret[0]);
+    }
+    /**
+     * @param {Identifier} id
+     * @returns {Agent | undefined}
+     */
+    getAgent(id) {
+        _assertClass(id, Identifier);
+        const ret = wasm.keyhive_getAgent(this.__wbg_ptr, id.__wbg_ptr);
+        return ret === 0 ? undefined : Agent.__wrap(ret);
+    }
+    /**
+     * @param {Identifier} id
+     * @returns {Group | undefined}
+     */
+    getGroup(id) {
+        _assertClass(id, Identifier);
+        const ret = wasm.keyhive_getGroup(this.__wbg_ptr, id.__wbg_ptr);
+        return ret === 0 ? undefined : Group.__wrap(ret);
+    }
+    /**
+     * @param {DocumentId} doc_id
+     * @returns {SimpleCapability[]}
+     */
+    docMemberCapabilities(doc_id) {
+        _assertClass(doc_id, DocumentId);
+        const ret = wasm.keyhive_docMemberCapabilities(this.__wbg_ptr, doc_id.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {Identifier} id
+     * @param {DocumentId} doc_id
+     * @returns {Access | undefined}
+     */
+    accessForDoc(id, doc_id) {
+        _assertClass(id, Identifier);
+        _assertClass(doc_id, DocumentId);
+        const ret = wasm.keyhive_accessForDoc(this.__wbg_ptr, id.__wbg_ptr, doc_id.__wbg_ptr);
+        return ret === 0 ? undefined : Access.__wrap(ret);
+    }
+    /**
+     * @returns {Archive}
+     */
+    intoArchive() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.keyhive_intoArchive(ptr);
+        return Archive.__wrap(ret);
+    }
+    /**
+     * @returns {Archive}
+     */
+    toArchive() {
+        const ret = wasm.keyhive_toArchive(this.__wbg_ptr);
+        return Archive.__wrap(ret);
+    }
+}
+
+const MemberedFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_membered_free(ptr >>> 0, 1));
+
+export class Membered {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Membered.prototype);
+        obj.__wbg_ptr = ptr;
+        MemberedFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MemberedFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_membered_free(ptr, 0);
+    }
+}
+
+const PeerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_peer_free(ptr >>> 0, 1));
+
+export class Peer {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Peer.prototype);
+        obj.__wbg_ptr = ptr;
+        PeerFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof Peer)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PeerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_peer_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.peer_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isIndividual() {
+        const ret = wasm.peer_isIndividual(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isGroup() {
+        const ret = wasm.peer_isGroup(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isDocument() {
+        const ret = wasm.peer_isDocument(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+
+const RemoveCiphertextErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_removeciphertexterror_free(ptr >>> 0, 1));
+
+export class RemoveCiphertextError {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RemoveCiphertextErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_removeciphertexterror_free(ptr, 0);
+    }
+}
+
+const RevocationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_revocation_free(ptr >>> 0, 1));
+
+export class Revocation {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Revocation.prototype);
+        obj.__wbg_ptr = ptr;
+        RevocationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RevocationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_revocation_free(ptr, 0);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get subject_id() {
+        const ret = wasm.revocation_subject_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {SignedDelegation}
+     */
+    get revoked() {
+        const ret = wasm.revocation_revoked(this.__wbg_ptr);
+        return SignedDelegation.__wrap(ret);
+    }
+    /**
+     * @returns {SignedDelegation | undefined}
+     */
+    get proof() {
+        const ret = wasm.revocation_proof(this.__wbg_ptr);
+        return ret === 0 ? undefined : SignedDelegation.__wrap(ret);
+    }
+    /**
+     * @returns {History}
+     */
+    get after() {
+        const ret = wasm.revocation_after(this.__wbg_ptr);
+        return History.__wrap(ret);
+    }
+}
+
+const RevokeMemberErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_revokemembererror_free(ptr >>> 0, 1));
+
+export class RevokeMemberError {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RevokeMemberError.prototype);
+        obj.__wbg_ptr = ptr;
+        RevokeMemberErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RevokeMemberErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_revokemembererror_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.revokemembererror_message(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const SerializationErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_serializationerror_free(ptr >>> 0, 1));
+
+export class SerializationError {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SerializationError.prototype);
+        obj.__wbg_ptr = ptr;
+        SerializationErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SerializationErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_serializationerror_free(ptr, 0);
+    }
+    /**
+     * @returns {any}
+     */
+    toError() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.serializationerror_toError(ptr);
+        return ret;
+    }
+}
+
+const ShareKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sharekey_free(ptr >>> 0, 1));
+
+export class ShareKey {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ShareKey.prototype);
+        obj.__wbg_ptr = ptr;
+        ShareKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ShareKeyFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sharekey_free(ptr, 0);
+    }
+}
+
+const SignedFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signed_free(ptr >>> 0, 1));
+
+export class Signed {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Signed.prototype);
+        obj.__wbg_ptr = ptr;
+        SignedFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignedFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signed_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {Signed}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signed_fromBytes(ptr0, len0);
+        return Signed.__wrap(ret);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.signed_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {boolean}
+     */
+    verify() {
+        const ret = wasm.signed_verify(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get payload() {
+        const ret = wasm.signed_payload(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get verifyingKey() {
+        const ret = wasm.signed_verifyingKey(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get signature() {
+        const ret = wasm.signed_signature(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+
+const SignedCgkaOperationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signedcgkaoperation_free(ptr >>> 0, 1));
+
+export class SignedCgkaOperation {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SignedCgkaOperation.prototype);
+        obj.__wbg_ptr = ptr;
+        SignedCgkaOperationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignedCgkaOperationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signedcgkaoperation_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    verify() {
+        const ret = wasm.signedcgkaoperation_verify(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {CgkaOperation}
+     */
+    get delegation() {
+        const ret = wasm.signedcgkaoperation_delegation(this.__wbg_ptr);
+        return CgkaOperation.__wrap(ret);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get verifyingKey() {
+        const ret = wasm.signedcgkaoperation_verifyingKey(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get signature() {
+        const ret = wasm.signedcgkaoperation_signature(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+
+const SignedDelegationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signeddelegation_free(ptr >>> 0, 1));
+
+export class SignedDelegation {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SignedDelegation.prototype);
+        obj.__wbg_ptr = ptr;
+        SignedDelegationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignedDelegationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signeddelegation_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    verify() {
+        const ret = wasm.signeddelegation_verify(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {Delegation}
+     */
+    get delegation() {
+        const ret = wasm.signeddelegation_delegation(this.__wbg_ptr);
+        return Delegation.__wrap(ret);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get verifyingKey() {
+        const ret = wasm.signeddelegation_verifyingKey(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get signature() {
+        const ret = wasm.signeddelegation_signature(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+
+const SignedInvocationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signedinvocation_free(ptr >>> 0, 1));
+
+export class SignedInvocation {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignedInvocationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signedinvocation_free(ptr, 0);
+    }
+}
+
+const SignedRevocationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signedrevocation_free(ptr >>> 0, 1));
+
+export class SignedRevocation {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SignedRevocation.prototype);
+        obj.__wbg_ptr = ptr;
+        SignedRevocationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignedRevocationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signedrevocation_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    verify() {
+        const ret = wasm.signedrevocation_verify(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {Revocation}
+     */
+    get delegation() {
+        const ret = wasm.signedrevocation_delegation(this.__wbg_ptr);
+        return Revocation.__wrap(ret);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get verifyingKey() {
+        const ret = wasm.signedrevocation_verifyingKey(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get signature() {
+        const ret = wasm.signedrevocation_signature(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+
+const SignerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signer_free(ptr >>> 0, 1));
+
+export class Signer {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Signer.prototype);
+        obj.__wbg_ptr = ptr;
+        SignerFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signer_free(ptr, 0);
+    }
+    /**
+     * @returns {Promise<Signer>}
+     */
+    static generate() {
+        const ret = wasm.signer_generate();
+        return ret;
+    }
+    /**
+     * @returns {Signer}
+     */
+    static generateMemory() {
+        const ret = wasm.signer_generateMemory();
+        return Signer.__wrap(ret);
+    }
+    /**
+     * @returns {Promise<Signer>}
+     */
+    static generateWebCrypto() {
+        const ret = wasm.signer_generateWebCrypto();
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {Signer}
+     */
+    static memorySignerFromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signer_memorySignerFromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Signer.__wrap(ret[0]);
+    }
+    /**
+     * @param {any} keypair
+     * @returns {Promise<Signer>}
+     */
+    static webCryptoSigner(keypair) {
+        const ret = wasm.signer_webCryptoSigner(keypair);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get variant() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.signer_variant(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {Promise<Signed>}
+     */
+    trySign(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signer_trySign(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get verifyingKey() {
+        const ret = wasm.signer_verifyingKey(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Signer}
+     */
+    clone() {
+        const ret = wasm.signer_clone(this.__wbg_ptr);
+        return Signer.__wrap(ret);
+    }
+}
+
+const SigningErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signingerror_free(ptr >>> 0, 1));
+
+export class SigningError {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SigningError.prototype);
+        obj.__wbg_ptr = ptr;
+        SigningErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SigningErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signingerror_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.signingerror_message(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const SimpleCapabilityFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_simplecapability_free(ptr >>> 0, 1));
+
+export class SimpleCapability {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SimpleCapability.prototype);
+        obj.__wbg_ptr = ptr;
+        SimpleCapabilityFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SimpleCapabilityFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_simplecapability_free(ptr, 0);
+    }
+    /**
+     * @returns {Agent}
+     */
+    get who() {
+        const ret = wasm.simplecapability_who(this.__wbg_ptr);
+        return Agent.__wrap(ret);
+    }
+    /**
+     * @returns {Access}
+     */
+    get can() {
+        const ret = wasm.simplecapability_can(this.__wbg_ptr);
+        return Access.__wrap(ret);
+    }
+}
+
+const SummaryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_summary_free(ptr >>> 0, 1));
+
+export class Summary {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Summary.prototype);
+        obj.__wbg_ptr = ptr;
+        SummaryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SummaryFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_summary_free(ptr, 0);
+    }
+    /**
+     * @returns {Document}
+     */
+    get doc() {
+        const ret = wasm.summary_doc(this.__wbg_ptr);
+        return Document.__wrap(ret);
+    }
+    /**
+     * @returns {Access}
+     */
+    get access() {
+        const ret = wasm.summary_access(this.__wbg_ptr);
+        return Access.__wrap(ret);
+    }
+}
+
+const TryFromArchiveErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tryfromarchiveerror_free(ptr >>> 0, 1));
+
+export class TryFromArchiveError {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TryFromArchiveError.prototype);
+        obj.__wbg_ptr = ptr;
+        TryFromArchiveErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TryFromArchiveErrorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tryfromarchiveerror_free(ptr, 0);
+    }
+    /**
+     * @returns {any}
+     */
+    toError() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.tryfromarchiveerror_toError(ptr);
+        return ret;
+    }
+}
+
+export function __wbg_Error_1f3748b298f99708(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+export function __wbg_addmembererror_new(arg0) {
+    const ret = AddMemberError.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_call_2f8d426a20a307fe() { return handleError(function (arg0, arg1) {
+    const ret = arg0.call(arg1);
+    return ret;
+}, arguments) };
+
+export function __wbg_call_f53f0647ceb9c567() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+}, arguments) };
+
+export function __wbg_cannotparseed25519signingkey_new(arg0) {
+    const ret = CannotParseEd25519SigningKey.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_cannotparseidentifier_new(arg0) {
+    const ret = CannotParseIdentifier.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_capability_new(arg0) {
+    const ret = Capability.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_changeref_new(arg0) {
+    const ret = ChangeRef.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_changeref_unwrap(arg0) {
+    const ret = ChangeRef.__unwrap(arg0);
+    return ret;
+};
+
+export function __wbg_contactcard_new(arg0) {
+    const ret = ContactCard.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_crypto_574e78ad8b13b65f(arg0) {
+    const ret = arg0.crypto;
+    return ret;
+};
+
+export function __wbg_crypto_d27ad9f7221b1675() { return handleError(function (arg0) {
+    const ret = arg0.crypto;
+    return ret;
+}, arguments) };
+
+export function __wbg_doccontentrefs_new(arg0) {
+    const ret = DocContentRefs.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_document_new(arg0) {
+    const ret = Document.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_document_unwrap(arg0) {
+    const ret = Document.__unwrap(arg0);
+    return ret;
+};
+
+export function __wbg_encryptedcontentwithupdate_new(arg0) {
+    const ret = EncryptedContentWithUpdate.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+    }
+};
+
+export function __wbg_event_new(arg0) {
+    const ret = Event.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_exportKey_bc8845fdc79b331a() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.exportKey(getStringFromWasm0(arg1, arg2), arg3);
+    return ret;
+}, arguments) };
+
+export function __wbg_generateKey_a2091927ceee8225() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    const ret = arg0.generateKey(getStringFromWasm0(arg1, arg2), arg3 !== 0, arg4);
+    return ret;
+}, arguments) };
+
+export function __wbg_generatedocerror_new(arg0) {
+    const ret = GenerateDocError.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_generatewebcryptoerror_new(arg0) {
+    const ret = GenerateWebCryptoError.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_getRandomValues_b8f5dbd5f3995a9e() { return handleError(function (arg0, arg1) {
+    arg0.getRandomValues(arg1);
+}, arguments) };
+
+export function __wbg_getprivatekey_68c3f491137f7d42(arg0) {
+    const ret = arg0.privateKey;
+    return ret;
+};
+
+export function __wbg_getpublickey_395decee9eaded1e(arg0) {
+    const ret = arg0.publicKey;
+    return ret;
+};
+
+export function __wbg_group_new(arg0) {
+    const ret = Group.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_instanceof_Window_7f29e5c72acbfd60(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Window;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+export function __wbg_jsdecrypterror_new(arg0) {
+    const ret = JsDecryptError.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_jsencrypterror_new(arg0) {
+    const ret = JsEncryptError.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_jsreceiveprekeyoperror_new(arg0) {
+    const ret = JsReceivePreKeyOpError.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_keyhive_new(arg0) {
+    const ret = Keyhive.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_length_904c0910ed998bf3(arg0) {
+    const ret = arg0.length;
+    return ret;
+};
+
+export function __wbg_msCrypto_a61aeb35a24c1329(arg0) {
+    const ret = arg0.msCrypto;
+    return ret;
+};
+
+export function __wbg_new_8a6f238a6ece86ea() {
+    const ret = new Error();
+    return ret;
+};
+
+export function __wbg_new_9190433fb67ed635(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+};
+
+export function __wbg_new_d5e3800b120e37e1(arg0, arg1) {
+    try {
+        var state0 = {a: arg0, b: arg1};
+        var cb0 = (arg0, arg1) => {
+            const a = state0.a;
+            state0.a = 0;
+            try {
+                return __wbg_adapter_269(a, state0.b, arg0, arg1);
+            } finally {
+                state0.a = a;
+            }
+        };
+        const ret = new Promise(cb0);
+        return ret;
+    } finally {
+        state0.a = state0.b = 0;
+    }
+};
+
+export function __wbg_newnoargs_a81330f6e05d8aca(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+export function __wbg_newwithlength_ed0ee6c1edca86fc(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return ret;
+};
+
+export function __wbg_node_905d3e251edff8a2(arg0) {
+    const ret = arg0.node;
+    return ret;
+};
+
+export function __wbg_peer_unwrap(arg0) {
+    const ret = Peer.__unwrap(arg0);
+    return ret;
+};
+
+export function __wbg_process_dc0fbacc7c1c06f7(arg0) {
+    const ret = arg0.process;
+    return ret;
+};
+
+export function __wbg_prototypesetcall_c5f74efd31aea86b(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+};
+
+export function __wbg_queueMicrotask_bcc6e26d899696db(arg0) {
+    const ret = arg0.queueMicrotask;
+    return ret;
+};
+
+export function __wbg_queueMicrotask_f24a794d09c42640(arg0) {
+    queueMicrotask(arg0);
+};
+
+export function __wbg_randomFillSync_ac0988aba3254290() { return handleError(function (arg0, arg1) {
+    arg0.randomFillSync(arg1);
+}, arguments) };
+
+export function __wbg_require_60cc747a6bc5215a() { return handleError(function () {
+    const ret = module.require;
+    return ret;
+}, arguments) };
+
+export function __wbg_resolve_5775c0ef9222f556(arg0) {
+    const ret = Promise.resolve(arg0);
+    return ret;
+};
+
+export function __wbg_revokemembererror_new(arg0) {
+    const ret = RevokeMemberError.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_serializationerror_new(arg0) {
+    const ret = SerializationError.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_sharekey_new(arg0) {
+    const ret = ShareKey.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_sign_57acde3c6437bdd1() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    const ret = arg0.sign(arg1, arg2, getArrayU8FromWasm0(arg3, arg4));
+    return ret;
+}, arguments) };
+
+export function __wbg_signed_new(arg0) {
+    const ret = Signed.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_signeddelegation_new(arg0) {
+    const ret = SignedDelegation.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_signedrevocation_new(arg0) {
+    const ret = SignedRevocation.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_signer_new(arg0) {
+    const ret = Signer.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_signingerror_new(arg0) {
+    const ret = SigningError.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_simplecapability_new(arg0) {
+    const ret = SimpleCapability.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
+    const ret = arg1.stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+export function __wbg_static_accessor_GLOBAL_1f13249cc3acc96d() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+export function __wbg_static_accessor_GLOBAL_THIS_df7ae94b1e0ed6a3() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+export function __wbg_static_accessor_SELF_6265471db3b3c228() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+export function __wbg_static_accessor_WINDOW_16fb482f8ec52863() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+export function __wbg_subarray_a219824899e59712(arg0, arg1, arg2) {
+    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+    return ret;
+};
+
+export function __wbg_subtle_40dd37072861a308(arg0) {
+    const ret = arg0.subtle;
+    return ret;
+};
+
+export function __wbg_summary_new(arg0) {
+    const ret = Summary.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_then_8d2fcccde5380a03(arg0, arg1, arg2) {
+    const ret = arg0.then(arg1, arg2);
+    return ret;
+};
+
+export function __wbg_then_9cc266be2bf537b6(arg0, arg1) {
+    const ret = arg0.then(arg1);
+    return ret;
+};
+
+export function __wbg_tryfromarchiveerror_new(arg0) {
+    const ret = TryFromArchiveError.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_versions_c01dfd4722a88165(arg0) {
+    const ret = arg0.versions;
+    return ret;
+};
+
+export function __wbg_wbindgencbdrop_a85ed476c6a370b9(arg0) {
+    const obj = arg0.original;
+    if (obj.cnt-- == 1) {
+        obj.a = 0;
+        return true;
+    }
+    const ret = false;
+    return ret;
+};
+
+export function __wbg_wbindgendebugstring_bb652b1bc2061b6d(arg0, arg1) {
+    const ret = debugString(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+export function __wbg_wbindgenisfunction_ea72b9d66a0e1705(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
+};
+
+export function __wbg_wbindgenisobject_dfe064a121d87553(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+};
+
+export function __wbg_wbindgenisstring_4b74e4111ba029e6(arg0) {
+    const ret = typeof(arg0) === 'string';
+    return ret;
+};
+
+export function __wbg_wbindgenisundefined_71f08a6ade4354e7(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+};
+
+export function __wbg_wbindgenthrow_4c11a24fca429ccf(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbindgen_cast_068e29f6a3bbf711(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 387, function: Function { arguments: [Externref], shim_idx: 388, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 387, __wbg_adapter_12);
+    return ret;
+};
+
+export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+export function __wbindgen_cast_25a0a844437d0e92(arg0, arg1) {
+    var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+    wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+    // Cast intrinsic for `Vector(NamedExternref("string")) -> Externref`.
+    const ret = v0;
+    return ret;
+};
+
+export function __wbindgen_cast_ae91babfc5c19b28(arg0, arg1) {
+    var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+    wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+    // Cast intrinsic for `Vector(NamedExternref("SignedRevocation")) -> Externref`.
+    const ret = v0;
+    return ret;
+};
+
+export function __wbindgen_cast_cb9088102bce6b30(arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return ret;
+};
+
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_export_2;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+