jscofhe/dist/jscofhe.node.d.cts

Implements js library for CoFHE

import BigNumber from 'bignumber.js';

/**
 * Interface for a cryptographic system
 * @template SecretKey - The type of the secret key
 * @template SecretKeyShare - The type of the secret key share
 * @template PublicKey - The type of the public key
 * @template PlainText - The type of the plaintext
 * @template CipherText - The type of the ciphertext
 * @template PartialDecryptionResult - The type of the partial decryption result
 * @interface ICryptoSystem
 * @description This interface defines the methods and properties that a cryptographic system should implement.
 * It includes methods for encryption, decryption, serialization, and deserialization of keys and ciphertexts.
 * It also includes methods for converting between plaintext and ciphertext, and for combining partial decryptions.
 */
interface ICryptoSystem<SecretKey, SecretKeyShare, PublicKey, PlainText, CipherText, PartialDecryptionResult> {
    /**
     * Generates a secret key
     * @returns A secret key
     */
    keygen(): SecretKey;
    /**
     * Generates a public key from a secret key
     * @param secret_key A secret key to be used for generating the public key
     * @returns A public key
     */
    keygen(secret_key: SecretKey): PublicKey;
    /**
     * Generates secret key shares from a secret key for threshold setting
     * @param secret_key A secret key to be used for generating the secret key shares
     * @param threshold The threshold for the secret key shares
     * @param total The total number of parties
     * @returns An array of arrays of secret key shares for each party for each threshold combination
     */
    keygen(secret_key: SecretKey, threshold: number, total: number): SecretKeyShare[][];
    /**
     * Converts normal float number to a plaintext object
     * @param value  A number to be converted to a plaintext
     * @returns A plaintext object
     * @throws TypeError if the value is not a number
     * @throws RangeError if the value is not in the range of the plaintext
     */
    make_plaintext: (value: bigint) => PlainText;
    /**
     *
     * Converts a plaintext object to a normal BigNumber
     * @param plaintext A plaintext object to be converted to a number
     * @returns A BigNumber object representing the plaintext value
     * @throws TypeError if the plaintext is not a correct plaintext object
     */
    get_plaintext_value: (plaintext: PlainText) => BigNumber;
    /**
     * Encrypts a plaintext object using the public key
     * @param pk A public key to be used for encryption
     * @param plaintext A plaintext object to be encrypted
     * @returns A ciphertext object
     * @throws TypeError if the plaintext is not a correct plaintext object or/and the public key is not a correct public key object
     */
    encrypt: (pk: PublicKey, pt: PlainText) => CipherText;
    /**
     * Combine partial decryptions to get the final plaintext
     * @param ciphertext A ciphertext object to be decrypted
     * @param partial_decryptions An array of partial decryptions to be combined
     * @returns A plaintext object
     * @throws TypeError if the ciphertext is not a correct ciphertext object or/and the partial decryptions are not correct partial decryption objects
     * @throws CoFHEValueError if the partial decryptions are not correct partial decryption objects
     */
    combine_partial_decryption_results: (ciphertext: CipherText, partial_decryptions: PartialDecryptionResult[]) => PlainText;
    /**
     * Deserializes a secret key from a byte array
     * @param serialized_secret_key A byte array to be deserialized
     * @returns A secret key object
     * @throws TypeError if the byte array is not a correct byte array
     * @throws CoFHEValueError if the byte array is not a correct byte array
     */
    deserialize_public_key: (serialized_pub_key: Uint8Array) => PublicKey;
    /**
     * Serializes a ciphertext to a byte array
     * @param ciphertext A ciphertext object to be serialized
     * @returns A byte array
     * @throws TypeError if the ciphertext is not a correct ciphertext object
     */
    serialize_ciphertext: (ciphertext: CipherText) => Uint8Array;
    /**
     * Deserializes a ciphertext from a byte array
     * @param serialized_ciphertext A byte array to be deserialized
     * @returns A ciphertext object
     * @throws TypeError if the byte array is not a correct byte array
     */
    deserialize_ciphertext: (serialized_ciphertext: Uint8Array) => CipherText;
    /**
     * Serializes a partial decryption result to a byte array
     * @param partial_decryption_result A partial decryption result to be serialized
     * @returns A byte array
     * @throws TypeError if the partial decryption result is not a correct partial decryption result object
     */
    serialize_partial_decryption_result: (partial_decryption_result: PartialDecryptionResult) => Uint8Array;
    /**
     * Deserializes a partial decryption result from a byte array
     * @param serialized_partial_decryption_result A byte array to be deserialized
     * @throws TypeError if the byte array is not a correct byte array
     * @throws CoFHEValueError if the byte array is not a correct byte array
     */
    deserialize_partial_decryption_result: (serialized_partial_decryption_result: Uint8Array) => PartialDecryptionResult;
}

declare class QFI {
    private a_m;
    private b_m;
    private c_m;
    constructor(a: bigint, b: bigint, c: bigint);
    clone(): QFI;
    a(): bigint;
    b(): bigint;
    c(): bigint;
    /**
     * Calculates the discriminant of the form
     */
    discriminant(): bigint;
    /**
     * Checks if the form is the neutral element of the class group
     */
    is_one(): boolean;
    /**
     * Makes the form negative
     */
    neg(): void;
    /**
     * Returns ax^2 + bxy + cy^2
     * @param x
     * @param y
     */
    eval(x: bigint, y: bigint): bigint;
    lift(l: bigint): void;
    lift_2exp(k: number): void;
    to_maximal_order(l: bigint, deltaK: bigint, with_reduction?: boolean): void;
    to_maximal_order_2exp(k: number, deltaK: bigint, with_reduction?: boolean): void;
    kernel_representative(l: bigint, deltaK: bigint): bigint;
    kernel_representative_2exp(k: number, deltaK: bigint): bigint;
    set_c_from_disc(disc: bigint): void;
    normalize(): void;
    rho(): void;
    reduction(): void;
    prime_to(l: bigint): void;
    prime_to_2exp(): void;
    static nucomp(f1: QFI, f2: QFI, L: bigint, negf2: boolean): QFI;
    static nudupl(f: QFI, L: bigint): QFI;
    static nupow(f: QFI, n: bigint, L: bigint): QFI;
    static nupow_2_forms(f0: QFI, n0: bigint, f1: QFI, n1: bigint, L: bigint): QFI;
    static nupow_2_forms_2exp(f: QFI, n: bigint, d: number, e: number, fe: QFI, fd: QFI, fed: QFI, L: bigint): QFI;
}
declare class ClassGroup {
    kronecker(l: bigint): void;
    private disc_m;
    private default_nucomp_bound_m;
    private class_number_bound_m;
    constructor(disc_in: bigint, class_number_bound?: bigint);
    disc(): bigint;
    default_nucomp_bound(): bigint;
    one(): QFI;
    primeform(l: bigint): QFI;
    class_number_bound(): bigint;
    private calc_class_number_bound;
    nucomp(f1: QFI, f2: QFI): QFI;
    nucompinv(f1: QFI, f2: QFI): QFI;
    nudupl(f: QFI): QFI;
    nudupl_niter(f: QFI, niter: number): QFI;
    nupow(f: QFI, n: bigint): QFI;
    nupow_2_forms(f0: QFI, n0: bigint, f1: QFI, n1: bigint): QFI;
    nupow_2_forms_2exp(f: QFI, n: bigint, d: number, e: number, fe: QFI, fd: QFI, fed: QFI): QFI;
}

declare class RandGen {
    random_bigint(n: bigint): bigint;
    random_bigint_2exp(n: number): bigint;
    random_bytes(n: number): Uint8Array;
    random_bool(): boolean;
    random_prime(nbits_: number): bigint;
    private static get_bytes;
}

declare class CLHSM2kSecretKey {
    private sk_m;
    constructor(sk: bigint);
    get sk(): bigint;
    static create_new(cs: CLHSM2k, randgen: RandGen): CLHSM2kSecretKey;
}
declare class CLHSM2kPublicKey {
    private pk_m;
    private d_m;
    private e_m;
    private pk_e_precomp_m;
    private pk_d_precomp_m;
    private pk_de_precomp_m;
    constructor(pk: QFI, cs: CLHSM2k);
    get pk(): QFI;
    exponentiation(cs: CLHSM2k, n: bigint): QFI;
    static create_new(cs: CLHSM2k, sk: CLHSM2kSecretKey): CLHSM2kPublicKey;
}
declare class CLHSM2kCleartext {
    private m_m;
    constructor(m: bigint);
    get m(): bigint;
    static create_new(m: bigint): CLHSM2kCleartext;
    static decrypt(cs: CLHSM2k, sk: CLHSM2kSecretKey, ct: CLHSM2kCiphertext): CLHSM2kCleartext;
}
declare class CLHSM2kCiphertext {
    private c1_m;
    private c2_m;
    constructor(c1: QFI, c2: QFI);
    get c1(): QFI;
    get c2(): QFI;
    static create_new(cs: CLHSM2k, pk: CLHSM2kPublicKey, m: CLHSM2kCleartext, r: bigint): CLHSM2kCiphertext;
    static add_ciphertexts(cs: CLHSM2k, pk: CLHSM2kPublicKey, ct1: CLHSM2kCiphertext, ct2: CLHSM2kCiphertext, r: bigint): CLHSM2kCiphertext;
    static scal_ciphertexts(cs: CLHSM2k, pk: CLHSM2kPublicKey, pt: CLHSM2kCleartext, ct: CLHSM2kCiphertext, r: bigint): CLHSM2kCiphertext;
}
type CLHSM2kSecretKeyShare = bigint;
type CLHSM2kPartialDecryptionResult = QFI;
declare class CLHSM2k {
    private randgen;
    private large_message_variant_used_m;
    private n_m;
    private k_m;
    private m_m;
    private cl_delta_k_m;
    private cl_delta_m;
    private h_m;
    private distance_m;
    private exponent_bound_m;
    private d_m;
    private e_m;
    private h_e_precomp_m;
    private h_d_precomp_m;
    private h_de_precomp_m;
    constructor(n: bigint, k: number, cl_delta_k_class_number_bound?: bigint);
    static create(sec_bits: number, k: number): CLHSM2k;
    get large_message_variant_used(): boolean;
    get n(): bigint;
    get k(): number;
    get m(): bigint;
    get delta_k(): bigint;
    get delta(): bigint;
    get cl_delta_k(): ClassGroup;
    get cl_delta(): ClassGroup;
    get cl_g(): ClassGroup;
    get h(): QFI;
    get secretkey_bound(): bigint;
    get cleartext_bound(): bigint;
    get encrypt_randomness_bound(): bigint;
    get lambda_distance(): bigint;
    power_of_h(n: bigint): QFI;
    power_of_f(m: bigint): QFI;
    dlog_in_F(fm: QFI): bigint;
    from_Cl_DeltaK_to_Cl_Delta(f: QFI): QFI;
    keygen(): CLHSM2kSecretKey;
    keygen(sk: CLHSM2kSecretKey): CLHSM2kPublicKey;
    keygen(sk: CLHSM2kSecretKey, t: number, n: number): CLHSM2kSecretKeyShare[][];
    create_cleartext(m: bigint): CLHSM2kCleartext;
    encrypt(pk: CLHSM2kPublicKey, m: CLHSM2kCleartext, r?: bigint): CLHSM2kCiphertext;
    decrypt(sk: CLHSM2kSecretKey, ct: CLHSM2kCiphertext): CLHSM2kCleartext;
    partial_decryption(ski: CLHSM2kSecretKeyShare, ct: CLHSM2kCiphertext): CLHSM2kPartialDecryptionResult;
    combine_partial_decryption_results(ct: CLHSM2kCiphertext, ds: CLHSM2kPartialDecryptionResult[]): CLHSM2kCleartext;
    add_ciphertexts(pk: CLHSM2kPublicKey, ca: CLHSM2kCiphertext, cb: CLHSM2kCiphertext): CLHSM2kCiphertext;
    scal_ciphertexts(pk: CLHSM2kPublicKey, pt: CLHSM2kCleartext, ct: CLHSM2kCiphertext): CLHSM2kCiphertext;
    private static random_n;
    private compute_delta_k;
    private compute_delta;
    private raise_to_power_m;
    private F_kerphi_square;
    private F_kerphi_div;
}

declare class CPUCryptoSystem implements ICryptoSystem<CLHSM2kSecretKey, CLHSM2kSecretKeyShare, CLHSM2kPublicKey, CLHSM2kCleartext, CLHSM2kCiphertext, CLHSM2kPartialDecryptionResult> {
    private k_m;
    private clhsm2k;
    constructor(sec_bits: number, k: number, clhsm2k?: CLHSM2k);
    static create_from_n(n: bigint, k: number, cl_delta_k_class_number?: bigint): CPUCryptoSystem;
    keygen(secret_key?: CLHSM2kSecretKey, t?: number, n?: number): CLHSM2kSecretKey & CLHSM2kPublicKey & bigint[][];
    make_plaintext(value: bigint): CLHSM2kCleartext;
    get_plaintext_value(plaintext: CLHSM2kCleartext): BigNumber;
    encrypt(pk: CLHSM2kPublicKey, pt: CLHSM2kCleartext): CLHSM2kCiphertext;
    combine_partial_decryption_results(ciphertext: CLHSM2kCiphertext, partial_decryptions: CLHSM2kPartialDecryptionResult[]): CLHSM2kCleartext;
    deserialize_public_key(serialized_pub_key: Uint8Array): CLHSM2kPublicKey;
    serialize_partial_decryption_result(partial_decryption_result: CLHSM2kPartialDecryptionResult): Uint8Array;
    deserialize_partial_decryption_result(serialized_partial_decryption_result: Uint8Array): CLHSM2kPartialDecryptionResult;
    serialize_ciphertext(ciphertext: CLHSM2kCiphertext): Uint8Array;
    deserialize_ciphertext(serialized_ciphertext: Uint8Array): CLHSM2kCiphertext;
    serialize_qfi_binary(qfi: QFI): Uint8Array;
    private deserialize_qfi_binary;
}

declare function fetch_class_bound_from_addon_service(url: string): Promise<bigint>;

interface Reencryptor<CipherText, PlainText, PartialDecryptionResult, PKCSecretKey, PKCPublicKey> {
    reencrypt: (partial_decryption_result: PartialDecryptionResult, pkc_public_key: PKCPublicKey) => Promise<Uint8Array>;
    decrypt: (reencrypted_partial_decryption_results: Uint8Array[], ct: CipherText, reencryption_private_key: PKCSecretKey) => Promise<PlainText>;
    generate_reencryption_key_pair(): Promise<{
        public_key: PKCPublicKey;
        secret_key: PKCSecretKey;
    }>;
    serialize_reencryption_private_key: (sk: PKCSecretKey) => Promise<Uint8Array>;
    serialize_reencryption_public_key: (pk: PKCPublicKey) => Promise<Uint8Array>;
    deserialize_reencryption_private_key: (serialized_reencryption_private_key: Uint8Array) => Promise<PKCSecretKey>;
    deserialize_reencryption_public_key: (serialized_reencryption_public_key: Uint8Array) => Promise<PKCPublicKey>;
    concatenate_reencrypted_partial_decryption_results: (reencrypted_partial_decryption_results: Uint8Array[]) => Promise<Uint8Array>;
    split_reencrypted_partial_decryption_results: (reencrypted_partial_decryption_results: Uint8Array) => Promise<Uint8Array[]>;
}

declare enum ComputeOperationType {
    UNARY = 0,
    BINARY = 1,
    TERNARY = 2
}
declare enum ComputeOperation {
    DECRYPT = 0,
    REENCRYPT = 1,
    ADD = 2,
    SUBTRACT = 3,
    MULTIPLY = 4,
    DIVIDE = 5,
    LT = 6,
    GT = 7,
    EQ = 8,
    NEQ = 9,
    LTEQ = 10,
    GTEQ = 11
}
declare enum DataType {
    SINGLE = 0,
    TENSOR = 1,
    TENSOR_ID = 2
}
declare enum DataEncryptionType {
    PLAINTEXT = 0,
    CIPHERTEXT = 1
}
declare class ComputeOperationOperand {
    data_type: DataType;
    encryption_type: DataEncryptionType;
    data: Uint8Array;
    constructor(data_type: DataType, encryption_type: DataEncryptionType, data: Uint8Array);
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): ComputeOperationOperand;
    static from_string(str: Uint8Array, num_operands: number): ComputeOperationOperand[];
}
declare class ComputeOperationInstance {
    operation_type: ComputeOperationType;
    operation: ComputeOperation;
    operands: ComputeOperationOperand[];
    constructor(operation_type: ComputeOperationType, operation: ComputeOperation, operands: ComputeOperationOperand[]);
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): ComputeOperationInstance;
}
declare class ComputeRequest {
    operation: ComputeOperationInstance;
    constructor(operation: ComputeOperationInstance);
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): ComputeRequest;
}
declare enum ComputeResponseStatus {
    SUCCESS = 0,
    ERROR = 1
}
declare class ComputeResponse {
    status: ComputeResponseStatus;
    data: Uint8Array;
    constructor(status: ComputeResponseStatus, data: Uint8Array);
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): ComputeResponse;
}

declare enum NodeType {
    SETUP_NODE = 0,
    CoFHE_NODE = 1,
    COMPUTE_NODE = 2,
    CLIENT_NODE = 3
}
interface NodeDetails {
    ip: string;
    port: string;
    type: NodeType;
}
declare enum ReencryptorType {
    RSA = 0
}
interface ReencryptorDetails {
    type: ReencryptorType;
    key_size: number;
}
declare enum CryptoSystemType {
    CoFHE_CPU = 0
}
interface CryptoSystemDetails {
    type: CryptoSystemType;
    public_key: Uint8Array;
    security_level: number;
    k: number;
    threshold: number;
    total_nodes: number;
    N: string;
}
declare class NetworkDetails {
    private self_node_m;
    private nodes_m;
    private cryptosystem_details_m;
    private secret_key_shares_m;
    private reencryption_details_m;
    constructor(self_node_m: NodeDetails, nodes_m: NodeDetails[], cryptosystem_details_m: CryptoSystemDetails, secret_key_shares_m: Uint8Array[], reencryption_details_m: ReencryptorDetails);
    get self_node(): NodeDetails;
    get nodes(): NodeDetails[];
    get cryptosystem_details(): CryptoSystemDetails;
    get secret_key_shares(): Uint8Array[];
    get reencryption_details(): ReencryptorDetails;
    to_json(): object;
    to_string(): string;
    static from_string(json_dump: string): NetworkDetails;
}

interface Computer {
    usable: boolean;
    connect(): Promise<void>;
    compute(req: ComputeRequest): Promise<ComputeResponse>;
    fetch_network_details(): Promise<NetworkDetails>;
}
declare class ClientNode<SecretKey, SecretKeyShare, PublicKey, PlainText, CipherText, PartialDecryptionResult, PKCSecretKey, PKCPublicKey> {
    private cryptosystem_m;
    private reencryptor_m;
    private network_encryption_key_m;
    private computer_m;
    constructor(cryptosystem: ICryptoSystem<SecretKey, SecretKeyShare, PublicKey, PlainText, CipherText, PartialDecryptionResult>, reencryptor: Reencryptor<CipherText, PlainText, PartialDecryptionResult, PKCSecretKey, PKCPublicKey>, network_encryption_key: PublicKey, computer: Computer | null);
    get cryptosystem(): ICryptoSystem<SecretKey, SecretKeyShare, PublicKey, PlainText, CipherText, PartialDecryptionResult>;
    get reencryptor(): Reencryptor<CipherText, PlainText, PartialDecryptionResult, PKCSecretKey, PKCPublicKey>;
    get network_encryption_key(): PublicKey;
    compute(req: ComputeRequest): Promise<ComputeResponse>;
}

declare class NodeJsTCPComputer implements Computer {
    private setup_node_address;
    private setup_node_port;
    private compute_node_address;
    private compute_node_port;
    private compute_client;
    private keep_alive;
    private usable_m;
    constructor(setup_node_address: string, setup_node_port: number, keep_alive?: boolean);
    get usable(): boolean;
    connect(): Promise<void>;
    compute(req_: ComputeRequest): Promise<ComputeResponse>;
    fetch_network_details(): Promise<NetworkDetails>;
}

declare enum ProtocolVersion {
    V1 = 0
}
declare enum ServiceType {
    COMPUTE_REQUEST = 0,
    COFHE_REQUEST = 1,
    SETUP_REQUEST = 2
}
declare enum ResponseStatus {
    OK = 0,
    ERROR = 1
}
declare class ResponseHeader {
    private ver_m;
    private type_m;
    private status_m;
    private data_size_m;
    constructor(ver_m: ProtocolVersion, type_m: ServiceType, status_m: ResponseStatus, data_size_m: bigint);
    get protocol_version(): ProtocolVersion;
    get type(): ServiceType;
    get status(): ResponseStatus;
    get data_size(): bigint;
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): ResponseHeader;
}
declare class Response {
    private header_m;
    private data_m;
    constructor(header_m: ResponseHeader, data_m: Uint8Array);
    get header(): ResponseHeader;
    get protocol_version(): ProtocolVersion;
    get type(): ServiceType;
    get status(): ResponseStatus;
    get data_size(): bigint;
    get data(): Uint8Array;
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): Response;
}
declare class RequestHeader {
    private ver_m;
    private type_m;
    private data_size_m;
    constructor(ver_m: ProtocolVersion, type_m: ServiceType, data_size_m: bigint);
    get protocol_version(): ProtocolVersion;
    get type(): ServiceType;
    get data_size(): bigint;
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): RequestHeader;
}
declare class Request {
    private header_m;
    private data_m;
    constructor(header_m: RequestHeader, data_m: Uint8Array);
    get header(): RequestHeader;
    get protocol_version(): ProtocolVersion;
    get type(): ServiceType;
    get data_size(): bigint;
    get data(): Uint8Array;
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): Request;
}

declare enum NetworkDetailsResponseStatus {
    OK = 0,
    ERROR = 1
}
declare class NetworkDetailsResponseHeader {
    private status_m;
    private data_size_m;
    constructor(status_m: NetworkDetailsResponseStatus, data_size_m: bigint);
    get status(): NetworkDetailsResponseStatus;
    get data_size(): bigint;
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): NetworkDetailsResponseHeader;
}
declare class NetworkDetailsResponse {
    private header_m;
    private data_m;
    constructor(header_m: NetworkDetailsResponseHeader, data_m: Uint8Array);
    get header(): NetworkDetailsResponseHeader;
    get status(): NetworkDetailsResponseStatus;
    get data_size(): bigint;
    get data(): Uint8Array;
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): NetworkDetailsResponse;
}
declare enum NetworkDetailsRequestType {
    GET = 0,
    SET = 1
}
declare class NetworkDetailsRequestHeader {
    private type_m;
    private data_size_m;
    constructor(type_m: NetworkDetailsRequestType, data_size_m: bigint);
    get type(): NetworkDetailsRequestType;
    get data_size(): bigint;
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): NetworkDetailsRequestHeader;
}
declare class NetworkDetailsRequest {
    private header_m;
    private data_m;
    constructor(header_m: NetworkDetailsRequestHeader, data_m: Uint8Array);
    get header(): NetworkDetailsRequestHeader;
    get type(): NetworkDetailsRequestType;
    get data_size(): bigint;
    get data(): Uint8Array;
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): NetworkDetailsRequest;
}
declare enum SetupResponseStatus {
    OK = 0,
    ERROR = 1
}
declare class SetupResponseHeader {
    private status_m;
    private data_size_m;
    constructor(status_m: SetupResponseStatus, data_size_m: bigint);
    get status(): SetupResponseStatus;
    get data_size(): bigint;
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): SetupResponseHeader;
}
declare class SetupResponse {
    private header_m;
    private data_m;
    constructor(header_m: SetupResponseHeader, data_m: Uint8Array);
    get header(): SetupResponseHeader;
    get status(): SetupResponseStatus;
    get data_size(): bigint;
    get data(): Uint8Array;
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): SetupResponse;
}
declare enum SetupRequestType {
    BEAVERS_TRIPLET_REQUEST = 0,
    COMPARISION_PAIR_REQUEST = 1,
    JOIN_AS_NODE_REQUEST = 2,
    NETWORK_DETAILS_REQUEST = 3
}
declare class SetupRequestHeader {
    private type_m;
    private data_size_m;
    constructor(type_m: SetupRequestType, data_size_m: bigint);
    get type(): SetupRequestType;
    get data_size(): bigint;
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): SetupRequestHeader;
}
declare class SetupRequest {
    private header_m;
    private data_m;
    constructor(header_m: SetupRequestHeader, data_m: Uint8Array);
    get header(): SetupRequestHeader;
    get type(): SetupRequestType;
    get data_size(): bigint;
    get data(): Uint8Array;
    to_string(): Uint8Array;
    static from_string(str: Uint8Array): SetupRequest;
}

declare class HTTPRelayComputer implements Computer {
    private url;
    constructor(url: string);
    get usable(): boolean;
    connect(): Promise<void>;
    compute(req_: ComputeRequest): Promise<ComputeResponse>;
    fetch_network_details(): Promise<NetworkDetails>;
}

type RSAEncryptorPublicKey = CryptoKey;
type RSAEncryptorPrivateKey = CryptoKey;

declare class CPUCryptoSystemRSAReencryptorClientNode extends ClientNode<CLHSM2kSecretKey, CLHSM2kSecretKeyShare, CLHSM2kPublicKey, CLHSM2kCleartext, CLHSM2kCiphertext, CLHSM2kPartialDecryptionResult, RSAEncryptorPrivateKey, RSAEncryptorPublicKey> {
    constructor(security_level: number, k: number, N: string, reencryptor_key_size: number, computer: Computer | null, network_encryption_key: Uint8Array, cl_delta_k_class_number?: bigint);
}
declare function make_cpu_crypto_system_rsa_reencryptor_client_node(computer: Computer, cl_delta_k_class_number?: bigint): Promise<CPUCryptoSystemRSAReencryptorClientNode>;

export { CLHSM2k, CLHSM2kCiphertext, CLHSM2kCleartext, CLHSM2kPublicKey, CLHSM2kSecretKey, CPUCryptoSystem, CPUCryptoSystemRSAReencryptorClientNode, ComputeOperation, ComputeOperationInstance, ComputeOperationOperand, ComputeOperationType, ComputeRequest, ComputeResponse, ComputeResponseStatus, DataEncryptionType, DataType, HTTPRelayComputer, NetworkDetails, NetworkDetailsRequest, NetworkDetailsRequestHeader, NetworkDetailsRequestType, NetworkDetailsResponse, NetworkDetailsResponseStatus, NodeJsTCPComputer, NodeType, ProtocolVersion, ReencryptorType, Request, Response, ResponseHeader, ResponseStatus, ServiceType, SetupRequest, SetupRequestHeader, SetupRequestType, SetupResponse, SetupResponseStatus, fetch_class_bound_from_addon_service, make_cpu_crypto_system_rsa_reencryptor_client_node };
export type { CryptoSystemDetails, ICryptoSystem, ReencryptorDetails };