tfhe/tfhe.js

TFHE-rs is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE.

/* @ts-self-types="./tfhe.d.ts" */
import { startWorkers } from './snippets/wasm-bindgen-rayon-38edf6e439f6d70d/src/workerHelpers.js';

export class Boolean {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        BooleanFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_boolean_free(ptr, 0);
    }
    /**
     * @param {BooleanCompressedCiphertext} compressed_ciphertext
     * @returns {BooleanCiphertext}
     */
    static decompress_ciphertext(compressed_ciphertext) {
        _assertClass(compressed_ciphertext, BooleanCompressedCiphertext);
        const ret = wasm.boolean_decompress_ciphertext(compressed_ciphertext.__wbg_ptr);
        return BooleanCiphertext.__wrap(ret);
    }
    /**
     * @param {BooleanClientKey} client_key
     * @param {BooleanCiphertext} ct
     * @returns {boolean}
     */
    static decrypt(client_key, ct) {
        _assertClass(client_key, BooleanClientKey);
        _assertClass(ct, BooleanCiphertext);
        const ret = wasm.boolean_decrypt(client_key.__wbg_ptr, ct.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @param {Uint8Array} buffer
     * @returns {BooleanCiphertext}
     */
    static deserialize_ciphertext(buffer) {
        const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_malloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.boolean_deserialize_ciphertext(ptr0, len0);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return BooleanCiphertext.__wrap(ret[0]);
    }
    /**
     * @param {Uint8Array} buffer
     * @returns {BooleanClientKey}
     */
    static deserialize_client_key(buffer) {
        const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_malloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.boolean_deserialize_client_key(ptr0, len0);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return BooleanClientKey.__wrap(ret[0]);
    }
    /**
     * @param {Uint8Array} buffer
     * @returns {BooleanCompressedCiphertext}
     */
    static deserialize_compressed_ciphertext(buffer) {
        const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_malloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.boolean_deserialize_compressed_ciphertext(ptr0, len0);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return BooleanCompressedCiphertext.__wrap(ret[0]);
    }
    /**
     * @param {Uint8Array} buffer
     * @returns {BooleanCompressedServerKey}
     */
    static deserialize_compressed_server_key(buffer) {
        const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_malloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.boolean_deserialize_compressed_server_key(ptr0, len0);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return BooleanCompressedServerKey.__wrap(ret[0]);
    }
    /**
     * @param {Uint8Array} buffer
     * @returns {BooleanPublicKey}
     */
    static deserialize_public_key(buffer) {
        const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_malloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.boolean_deserialize_public_key(ptr0, len0);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return BooleanPublicKey.__wrap(ret[0]);
    }
    /**
     * @param {BooleanClientKey} client_key
     * @param {boolean} message
     * @returns {BooleanCiphertext}
     */
    static encrypt(client_key, message) {
        _assertClass(client_key, BooleanClientKey);
        const ret = wasm.boolean_encrypt(client_key.__wbg_ptr, message);
        return BooleanCiphertext.__wrap(ret);
    }
    /**
     * @param {BooleanClientKey} client_key
     * @param {boolean} message
     * @returns {BooleanCompressedCiphertext}
     */
    static encrypt_compressed(client_key, message) {
        _assertClass(client_key, BooleanClientKey);
        const ret = wasm.boolean_encrypt_compressed(client_key.__wbg_ptr, message);
        return BooleanCompressedCiphertext.__wrap(ret);
    }
    /**
     * @param {BooleanPublicKey} public_key
     * @param {boolean} message
     * @returns {BooleanCiphertext}
     */
    static encrypt_with_public_key(public_key, message) {
        _assertClass(public_key, BooleanPublicKey);
        const ret = wasm.boolean_encrypt_with_public_key(public_key.__wbg_ptr, message);
        return BooleanCiphertext.__wrap(ret);
    }
    /**
     * @param {number} parameter_choice
     * @returns {BooleanParameters}
     */
    static get_parameters(parameter_choice) {
        const ret = wasm.boolean_get_parameters(parameter_choice);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return BooleanParameters.__wrap(ret[0]);
    }
    /**
     * @param {BooleanParameters} parameters
     * @returns {BooleanClientKey}
     */
    static new_client_key(parameters) {
        _assertClass(parameters, BooleanParameters);
        const ret = wasm.boolean_new_client_key(parameters.__wbg_ptr);
        return BooleanClientKey.__wrap(ret);
    }
    /**
     * @param {bigint} seed_high_bytes
     * @param {bigint} seed_low_bytes
     * @param {BooleanParameters} parameters
     * @returns {BooleanClientKey}
     */
    static new_client_key_from_seed_and_parameters(seed_high_bytes, seed_low_bytes, parameters) {
        _assertClass(parameters, BooleanParameters);
        const ret = wasm.boolean_new_client_key_from_seed_and_parameters(seed_high_bytes, seed_low_bytes, parameters.__wbg_ptr);
        return BooleanClientKey.__wrap(ret);
    }
    /**
     * @param {BooleanClientKey} client_key
     * @returns {BooleanCompressedServerKey}
     */
    static new_compressed_server_key(client_key) {
        _assertClass(client_key, BooleanClientKey);
        const ret = wasm.boolean_new_compressed_server_key(client_key.__wbg_ptr);
        return BooleanCompressedServerKey.__wrap(ret);
    }
    /**
     * @param {number} std_dev
     * @returns {BooleanNoiseDistribution}
     */
    static new_gaussian_from_std_dev(std_dev) {
        const ret = wasm.boolean_new_gaussian_from_std_dev(std_dev);
        return BooleanNoiseDistribution.__wrap(ret);
    }
    /**
     * @param {number} lwe_dimension
     * @param {number} glwe_dimension
     * @param {number} polynomial_size
     * @param {BooleanNoiseDistribution} lwe_noise_distribution
     * @param {BooleanNoiseDistribution} glwe_noise_distribution
     * @param {number} pbs_base_log
     * @param {number} pbs_level
     * @param {number} ks_base_log
     * @param {number} ks_level
     * @param {BooleanEncryptionKeyChoice} encryption_key_choice
     * @returns {BooleanParameters}
     */
    static new_parameters(lwe_dimension, glwe_dimension, polynomial_size, lwe_noise_distribution, glwe_noise_distribution, pbs_base_log, pbs_level, ks_base_log, ks_level, encryption_key_choice) {
        _assertClass(lwe_noise_distribution, BooleanNoiseDistribution);
        _assertClass(glwe_noise_distribution, BooleanNoiseDistribution);
        const ret = wasm.boolean_new_parameters(lwe_dimension, glwe_dimension, polynomial_size, lwe_noise_distribution.__wbg_ptr, glwe_noise_distribution.__wbg_ptr, pbs_base_log, pbs_level, ks_base_log, ks_level, encryption_key_choice);
        return BooleanParameters.__wrap(ret);
    }
    /**
     * @param {BooleanClientKey} client_key
     * @returns {BooleanPublicKey}
     */
    static new_public_key(client_key) {
        _assertClass(client_key, BooleanClientKey);
        const ret = wasm.boolean_new_public_key(client_key.__wbg_ptr);
        return BooleanPublicKey.__wrap(ret);
    }
    /**
     * @param {BooleanCiphertext} ciphertext
     * @returns {Uint8Array}
     */
    static serialize_ciphertext(ciphertext) {
        _assertClass(ciphertext, BooleanCiphertext);
        const ret = wasm.boolean_serialize_ciphertext(ciphertext.__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 {BooleanClientKey} client_key
     * @returns {Uint8Array}
     */
    static serialize_client_key(client_key) {
        _assertClass(client_key, BooleanClientKey);
        const ret = wasm.boolean_serialize_client_key(client_key.__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 {BooleanCompressedCiphertext} ciphertext
     * @returns {Uint8Array}
     */
    static serialize_compressed_ciphertext(ciphertext) {
        _assertClass(ciphertext, BooleanCompressedCiphertext);
        const ret = wasm.boolean_serialize_compressed_ciphertext(ciphertext.__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 {BooleanCompressedServerKey} server_key
     * @returns {Uint8Array}
     */
    static serialize_compressed_server_key(server_key) {
        _assertClass(server_key, BooleanCompressedServerKey);
        const ret = wasm.boolean_serialize_compressed_server_key(server_key.__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 {BooleanPublicKey} public_key
     * @returns {Uint8Array}
     */
    static serialize_public_key(public_key) {
        _assertClass(public_key, BooleanPublicKey);
        const ret = wasm.boolean_serialize_public_key(public_key.__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 {boolean} message
     * @returns {BooleanCiphertext}
     */
    static trivial_encrypt(message) {
        const ret = wasm.boolean_trivial_encrypt(message);
        return BooleanCiphertext.__wrap(ret);
    }
    /**
     * @param {number} bound_log2
     * @returns {BooleanNoiseDistribution}
     */
    static try_new_t_uniform(bound_log2) {
        const ret = wasm.boolean_try_new_t_uniform(bound_log2);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return BooleanNoiseDistribution.__wrap(ret[0]);
    }
}
if (Symbol.dispose) Boolean.prototype[Symbol.dispose] = Boolean.prototype.free;

export class BooleanCiphertext {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(BooleanCiphertext.prototype);
        obj.__wbg_ptr = ptr;
        BooleanCiphertextFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        BooleanCiphertextFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_booleanciphertext_free(ptr, 0);
    }
}
if (Symbol.dispose) BooleanCiphertext.prototype[Symbol.dispose] = BooleanCiphertext.prototype.free;

export class BooleanClientKey {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(BooleanClientKey.prototype);
        obj.__wbg_ptr = ptr;
        BooleanClientKeyFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        BooleanClientKeyFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_booleanclientkey_free(ptr, 0);
    }
}
if (Symbol.dispose) BooleanClientKey.prototype[Symbol.dispose] = BooleanClientKey.prototype.free;

export class BooleanCompressedCiphertext {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(BooleanCompressedCiphertext.prototype);
        obj.__wbg_ptr = ptr;
        BooleanCompressedCiphertextFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        BooleanCompressedCiphertextFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_booleancompressedciphertext_free(ptr, 0);
    }
}
if (Symbol.dispose) BooleanCompressedCiphertext.prototype[Symbol.dispose] = BooleanCompressedCiphertext.prototype.free;

export class BooleanCompressedServerKey {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(BooleanCompressedServerKey.prototype);
        obj.__wbg_ptr = ptr;
        BooleanCompressedServerKeyFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        BooleanCompressedServerKeyFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_booleancompressedserverkey_free(ptr, 0);
    }
}
if (Symbol.dispose) BooleanCompressedServerKey.prototype[Symbol.dispose] = BooleanCompressedServerKey.prototype.free;

/**
 * @enum {0 | 1}
 */
export const BooleanEncryptionKeyChoice = Object.freeze({
    Big: 0, "0": "Big",
    Small: 1, "1": "Small",
});

export class BooleanNoiseDistribution {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(BooleanNoiseDistribution.prototype);
        obj.__wbg_ptr = ptr;
        BooleanNoiseDistributionFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        BooleanNoiseDistributionFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_booleannoisedistribution_free(ptr, 0);
    }
}
if (Symbol.dispose) BooleanNoiseDistribution.prototype[Symbol.dispose] = BooleanNoiseDistribution.prototype.free;

/**
 * @enum {0 | 1 | 2 | 3}
 */
export const BooleanParameterSet = Object.freeze({
    Default: 0, "0": "Default",
    TfheLib: 1, "1": "TfheLib",
    DefaultKsPbs: 2, "2": "DefaultKsPbs",
    TfheLibKsPbs: 3, "3": "TfheLibKsPbs",
});

export class BooleanParameters {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(BooleanParameters.prototype);
        obj.__wbg_ptr = ptr;
        BooleanParametersFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        BooleanParametersFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_booleanparameters_free(ptr, 0);
    }
}
if (Symbol.dispose) BooleanParameters.prototype[Symbol.dispose] = BooleanParameters.prototype.free;

export class BooleanPublicKey {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(BooleanPublicKey.prototype);
        obj.__wbg_ptr = ptr;
        BooleanPublicKeyFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        BooleanPublicKeyFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_booleanpublickey_free(ptr, 0);
    }
}
if (Symbol.dispose) BooleanPublicKey.prototype[Symbol.dispose] = BooleanPublicKey.prototype.free;

export class CompactCiphertextList {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(CompactCiphertextList.prototype);
        obj.__wbg_ptr = ptr;
        CompactCiphertextListFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        CompactCiphertextListFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_compactciphertextlist_free(ptr, 0);
    }
    /**
     * @param {TfheCompactPublicKey} public_key
     * @returns {CompactCiphertextListBuilder}
     */
    static builder(public_key) {
        _assertClass(public_key, TfheCompactPublicKey);
        const ret = wasm.compactciphertextlist_builder(public_key.__wbg_ptr);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return CompactCiphertextListBuilder.__wrap(ret[0]);
    }
    /**
     * @param {Uint8Array} buffer
     * @returns {CompactCiphertextList}
     */
    static deserialize(buffer) {
        const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_malloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.compactciphertextlist_deserialize(ptr0, len0);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return CompactCiphertextList.__wrap(ret[0]);
    }
    /**
     * @returns {CompactCiphertextListExpander}
     */
    expand() {
        const ret = wasm.compactciphertextlist_expand(this.__wbg_ptr);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return CompactCiphertextListExpander.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheTypes | undefined}
     */
    get_kind_of(index) {
        const ret = wasm.compactciphertextlist_get_kind_of(this.__wbg_ptr, index);
        return ret === 84 ? undefined : ret;
    }
    /**
     * @returns {boolean}
     */
    is_empty() {
        const ret = wasm.compactciphertextlist_is_empty(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {number}
     */
    len() {
        const ret = wasm.compactciphertextlist_len(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @param {Uint8Array} buffer
     * @param {bigint} serialized_size_limit
     * @returns {CompactCiphertextList}
     */
    static safe_deserialize(buffer, serialized_size_limit) {
        const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_malloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.compactciphertextlist_safe_deserialize(ptr0, len0, serialized_size_limit);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return CompactCiphertextList.__wrap(ret[0]);
    }
    /**
     * @param {bigint} serialized_size_limit
     * @returns {Uint8Array}
     */
    safe_serialize(serialized_size_limit) {
        const ret = wasm.compactciphertextlist_safe_serialize(this.__wbg_ptr, serialized_size_limit);
        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;
    }
    /**
     * @returns {Uint8Array}
     */
    serialize() {
        const ret = wasm.compactciphertextlist_serialize(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;
    }
}
if (Symbol.dispose) CompactCiphertextList.prototype[Symbol.dispose] = CompactCiphertextList.prototype.free;

export class CompactCiphertextListBuilder {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(CompactCiphertextListBuilder.prototype);
        obj.__wbg_ptr = ptr;
        CompactCiphertextListBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        CompactCiphertextListBuilderFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_compactciphertextlistbuilder_free(ptr, 0);
    }
    /**
     * @returns {CompactCiphertextList}
     */
    build() {
        const ret = wasm.compactciphertextlistbuilder_build(this.__wbg_ptr);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return CompactCiphertextList.__wrap(ret[0]);
    }
    /**
     * @returns {CompactCiphertextList}
     */
    build_packed() {
        const ret = wasm.compactciphertextlistbuilder_build_packed(this.__wbg_ptr);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return CompactCiphertextList.__wrap(ret[0]);
    }
    /**
     * @param {CompactPkeCrs} crs
     * @param {Uint8Array} metadata
     * @param {ZkComputeLoad} compute_load
     * @returns {ProvenCompactCiphertextList}
     */
    build_with_proof_packed(crs, metadata, compute_load) {
        _assertClass(crs, CompactPkeCrs);
        const ptr0 = passArray8ToWasm0(metadata, wasm.__wbindgen_malloc);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.compactciphertextlistbuilder_build_with_proof_packed(this.__wbg_ptr, crs.__wbg_ptr, ptr0, len0, compute_load);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return ProvenCompactCiphertextList.__wrap(ret[0]);
    }
    /**
     * @param {boolean} value
     */
    push_boolean(value) {
        const ret = wasm.compactciphertextlistbuilder_push_boolean(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_i10(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i10(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i1024(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i1024(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i104(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i104(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i112(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i112(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_i12(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i12(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i120(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i120(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i128(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i128(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i136(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i136(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_i14(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i14(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i144(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i144(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i152(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i152(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_i16(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i16(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i160(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i160(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i168(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i168(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i176(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i176(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i184(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i184(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i192(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i192(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_i2(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i2(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i200(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i200(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i2048(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i2048(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i208(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i208(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i216(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i216(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i224(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i224(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i232(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i232(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_i24(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i24(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i240(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i240(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i248(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i248(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i256(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i256(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_i32(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i32(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_i4(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i4(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {bigint} value
     */
    push_i40(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i40(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {bigint} value
     */
    push_i48(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i48(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i512(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i512(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {bigint} value
     */
    push_i56(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i56(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_i6(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i6(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {bigint} value
     */
    push_i64(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i64(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i72(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i72(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_i8(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i8(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i80(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i80(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i88(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i88(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_i96(value) {
        const ret = wasm.compactciphertextlistbuilder_push_i96(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_u10(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u10(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u1024(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u1024(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u104(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u104(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u112(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u112(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_u12(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u12(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u120(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u120(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u128(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u128(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u136(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u136(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_u14(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u14(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u144(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u144(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u152(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u152(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_u16(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u16(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u160(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u160(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u168(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u168(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u176(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u176(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u184(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u184(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u192(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u192(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_u2(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u2(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u200(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u200(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u2048(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u2048(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u208(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u208(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u216(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u216(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u224(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u224(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u232(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u232(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_u24(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u24(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u240(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u240(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u248(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u248(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u256(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u256(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_u32(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u32(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_u4(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u4(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {bigint} value
     */
    push_u40(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u40(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {bigint} value
     */
    push_u48(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u48(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u512(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u512(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {bigint} value
     */
    push_u56(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u56(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_u6(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u6(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {bigint} value
     */
    push_u64(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u64(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u72(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u72(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {number} value
     */
    push_u8(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u8(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u80(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u80(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u88(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u88(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
    /**
     * @param {any} value
     */
    push_u96(value) {
        const ret = wasm.compactciphertextlistbuilder_push_u96(this.__wbg_ptr, value);
        if (ret[1]) {
            throw takeFromExternrefTable0(ret[0]);
        }
    }
}
if (Symbol.dispose) CompactCiphertextListBuilder.prototype[Symbol.dispose] = CompactCiphertextListBuilder.prototype.free;

export class CompactCiphertextListExpander {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(CompactCiphertextListExpander.prototype);
        obj.__wbg_ptr = ptr;
        CompactCiphertextListExpanderFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        CompactCiphertextListExpanderFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_compactciphertextlistexpander_free(ptr, 0);
    }
    /**
     * @param {number} index
     * @returns {FheBool}
     */
    get_bool(index) {
        const ret = wasm.compactciphertextlistexpander_get_bool(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheBool.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt10}
     */
    get_int10(index) {
        const ret = wasm.compactciphertextlistexpander_get_int10(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt10.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt1024}
     */
    get_int1024(index) {
        const ret = wasm.compactciphertextlistexpander_get_int1024(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt1024.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt104}
     */
    get_int104(index) {
        const ret = wasm.compactciphertextlistexpander_get_int104(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt104.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt112}
     */
    get_int112(index) {
        const ret = wasm.compactciphertextlistexpander_get_int112(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt112.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt12}
     */
    get_int12(index) {
        const ret = wasm.compactciphertextlistexpander_get_int12(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt12.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt120}
     */
    get_int120(index) {
        const ret = wasm.compactciphertextlistexpander_get_int120(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt120.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt128}
     */
    get_int128(index) {
        const ret = wasm.compactciphertextlistexpander_get_int128(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt128.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt136}
     */
    get_int136(index) {
        const ret = wasm.compactciphertextlistexpander_get_int136(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt136.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt14}
     */
    get_int14(index) {
        const ret = wasm.compactciphertextlistexpander_get_int14(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt14.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt144}
     */
    get_int144(index) {
        const ret = wasm.compactciphertextlistexpander_get_int144(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt144.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt152}
     */
    get_int152(index) {
        const ret = wasm.compactciphertextlistexpander_get_int152(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt152.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt16}
     */
    get_int16(index) {
        const ret = wasm.compactciphertextlistexpander_get_int16(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt16.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt160}
     */
    get_int160(index) {
        const ret = wasm.compactciphertextlistexpander_get_int160(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt160.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt168}
     */
    get_int168(index) {
        const ret = wasm.compactciphertextlistexpander_get_int168(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt168.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt176}
     */
    get_int176(index) {
        const ret = wasm.compactciphertextlistexpander_get_int176(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt176.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt184}
     */
    get_int184(index) {
        const ret = wasm.compactciphertextlistexpander_get_int184(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt184.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt192}
     */
    get_int192(index) {
        const ret = wasm.compactciphertextlistexpander_get_int192(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt192.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt2}
     */
    get_int2(index) {
        const ret = wasm.compactciphertextlistexpander_get_int2(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt2.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt200}
     */
    get_int200(index) {
        const ret = wasm.compactciphertextlistexpander_get_int200(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt200.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt2048}
     */
    get_int2048(index) {
        const ret = wasm.compactciphertextlistexpander_get_int2048(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt2048.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt208}
     */
    get_int208(index) {
        const ret = wasm.compactciphertextlistexpander_get_int208(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheInt208.__wrap(ret[0]);
    }
    /**
     * @param {number} index
     * @returns {FheInt216}
     */
    get_int216(index) {
        const ret = wasm.compactciphertextlistexpander_get_int216(this.__wbg_ptr, index);
        if (ret[2]) {
            throw takeFromExternrefTable0(ret[1]);
        }
        return FheI