/* tslint:disable */
/* eslint-disable */

/**
 * An attribute which should not be identifiable.
 */
export class Attribute {
    free(): void;
    [Symbol.dispose](): void;
    static fromBytes(bytes: Uint8Array): Attribute | undefined;
    static fromBytesPadded(data: Uint8Array): Attribute | undefined;
    static fromHash(v: Uint8Array): Attribute;
    static fromHex(hex: string): Attribute | undefined;
    static fromLizard(data: Uint8Array): Attribute | undefined;
    static fromStringPadded(text: string): Attribute | undefined;
    constructor(x: GroupElement);
    static random(): Attribute;
    toBytes(): Uint8Array;
    toBytesPadded(): Uint8Array | undefined;
    toHex(): string;
    toLizard(): Uint8Array | undefined;
    toPoint(): GroupElement;
    toStringPadded(): string | undefined;
}

/**
 * Attribute global key pair.
 */
export class AttributeGlobalKeyPair {
    free(): void;
    [Symbol.dispose](): void;
    constructor(_public: AttributeGlobalPublicKey, secret: AttributeGlobalSecretKey);
    readonly public: AttributeGlobalPublicKey;
    readonly secret: AttributeGlobalSecretKey;
}

/**
 * An attribute global public key from which attribute session keys are derived.
 */
export class AttributeGlobalPublicKey {
    free(): void;
    [Symbol.dispose](): void;
    static fromBytes(bytes: Uint8Array): AttributeGlobalPublicKey | undefined;
    static fromHex(hex: string): AttributeGlobalPublicKey | undefined;
    constructor(x: GroupElement);
    toBytes(): Uint8Array;
    toHex(): string;
    0: GroupElement;
}

/**
 * An attribute global secret key from which attribute session keys are derived.
 */
export class AttributeGlobalSecretKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    0: ScalarNonZero;
}

/**
 * A factor used to rekey attributes between sessions.
 */
export class AttributeRekeyFactor {
    free(): void;
    [Symbol.dispose](): void;
    constructor(scalar: ScalarNonZero);
    scalar(): ScalarNonZero;
}

export class AttributeRekeyInfo {
    free(): void;
    [Symbol.dispose](): void;
    constructor(session_from: EncryptionContext, session_to: EncryptionContext, encryption_secret: EncryptionSecret);
    reverse(): AttributeRekeyInfo;
}

/**
 * Attribute session key pair.
 */
export class AttributeSessionKeyPair {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    readonly public: AttributeSessionPublicKey;
    readonly secret: AttributeSessionSecretKey;
}

/**
 * An attribute session key share.
 */
export class AttributeSessionKeyShare {
    free(): void;
    [Symbol.dispose](): void;
    static fromBytes(bytes: Uint8Array): AttributeSessionKeyShare | undefined;
    static fromHex(hex: string): AttributeSessionKeyShare | undefined;
    constructor(x: ScalarNonZero);
    toBytes(): Uint8Array;
    toHex(): string;
}

/**
 * Attribute session keys containing both public and secret keys.
 */
export class AttributeSessionKeys {
    free(): void;
    [Symbol.dispose](): void;
    constructor(_public: AttributeSessionPublicKey, secret: AttributeSessionSecretKey);
    readonly public: AttributeSessionPublicKey;
    readonly secret: AttributeSessionSecretKey;
}

/**
 * An attribute session public key used to encrypt attributes against.
 */
export class AttributeSessionPublicKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    0: GroupElement;
}

/**
 * An attribute session secret key used to decrypt attributes with.
 */
export class AttributeSessionSecretKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    0: ScalarNonZero;
}

/**
 * A blinded attribute global secret key.
 */
export class BlindedAttributeGlobalSecretKey {
    free(): void;
    [Symbol.dispose](): void;
    static fromBytes(bytes: Uint8Array): BlindedAttributeGlobalSecretKey | undefined;
    static fromHex(hex: string): BlindedAttributeGlobalSecretKey | undefined;
    constructor(x: ScalarNonZero);
    toBytes(): Uint8Array;
    toHex(): string;
}

/**
 * A pair of blinded global secret keys.
 */
export class BlindedGlobalKeys {
    free(): void;
    [Symbol.dispose](): void;
    constructor(pseudonym: BlindedPseudonymGlobalSecretKey, attribute: BlindedAttributeGlobalSecretKey);
    readonly attribute: BlindedAttributeGlobalSecretKey;
    readonly pseudonym: BlindedPseudonymGlobalSecretKey;
}

/**
 * A blinded pseudonym global secret key.
 */
export class BlindedPseudonymGlobalSecretKey {
    free(): void;
    [Symbol.dispose](): void;
    static fromBytes(bytes: Uint8Array): BlindedPseudonymGlobalSecretKey | undefined;
    static fromHex(hex: string): BlindedPseudonymGlobalSecretKey | undefined;
    constructor(x: ScalarNonZero);
    toBytes(): Uint8Array;
    toHex(): string;
}

/**
 * A blinding factor.
 */
export class BlindingFactor {
    free(): void;
    [Symbol.dispose](): void;
    clone(): BlindingFactor;
    static fromBytes(bytes: Uint8Array): BlindingFactor | undefined;
    static fromHex(hex: string): BlindingFactor | undefined;
    constructor(x: ScalarNonZero);
    static random(): BlindingFactor;
    toBytes(): Uint8Array;
    toHex(): string;
}

/**
 * A PEP client.
 */
export class Client {
    free(): void;
    [Symbol.dispose](): void;
    decryptData(encrypted: EncryptedAttribute): Attribute;
    /**
     * Decrypt a batch of encrypted attributes.
     */
    decryptDataBatch(encrypted: EncryptedAttribute[]): Attribute[];
    /**
     * Decrypt an encrypted PEPJSONValue using session keys.
     */
    decryptJSON(encrypted: EncryptedPEPJSONValue): PEPJSONValue;
    /**
     * Decrypt a batch of encrypted PEPJSONValues using session keys.
     */
    decryptJSONBatch(encrypted: EncryptedPEPJSONValue[]): PEPJSONValue[];
    decryptLongData(encrypted: LongEncryptedAttribute): LongAttribute;
    /**
     * Decrypt a batch of long encrypted attributes.
     */
    decryptLongDataBatch(encrypted: LongEncryptedAttribute[]): LongAttribute[];
    decryptLongPseudonym(encrypted: LongEncryptedPseudonym): LongPseudonym;
    /**
     * Decrypt a batch of long encrypted pseudonyms.
     */
    decryptLongPseudonymBatch(encrypted: LongEncryptedPseudonym[]): LongPseudonym[];
    /**
     * Decrypt an encrypted LongRecord using session keys.
     */
    decryptLongRecord(encrypted: LongRecordEncrypted): LongRecord;
    decryptPseudonym(encrypted: EncryptedPseudonym): Pseudonym;
    /**
     * Decrypt a batch of encrypted pseudonyms.
     */
    decryptPseudonymBatch(encrypted: EncryptedPseudonym[]): Pseudonym[];
    /**
     * Decrypt an encrypted Record using session keys.
     */
    decryptRecord(encrypted: RecordEncrypted): Record;
    dump(): SessionKeys;
    encryptData(message: Attribute): EncryptedAttribute;
    /**
     * Encrypt a batch of attributes.
     */
    encryptDataBatch(messages: Attribute[]): EncryptedAttribute[];
    /**
     * Encrypt a PEPJSONValue using session keys.
     */
    encryptJSON(value: PEPJSONValue): EncryptedPEPJSONValue;
    /**
     * Encrypt a PEPJSONValue using session keys.
     */
    encryptJSONBatch(values: PEPJSONValue[]): EncryptedPEPJSONValue[];
    encryptLongData(message: LongAttribute): LongEncryptedAttribute;
    /**
     * Encrypt a batch of long attributes.
     */
    encryptLongDataBatch(messages: LongAttribute[]): LongEncryptedAttribute[];
    encryptLongPseudonym(message: LongPseudonym): LongEncryptedPseudonym;
    /**
     * Encrypt a batch of long pseudonyms.
     */
    encryptLongPseudonymBatch(messages: LongPseudonym[]): LongEncryptedPseudonym[];
    /**
     * Encrypt a LongRecord using session keys.
     */
    encryptLongRecord(record: LongRecord): LongRecordEncrypted;
    encryptPseudonym(message: Pseudonym): EncryptedPseudonym;
    /**
     * Encrypt a batch of pseudonyms.
     */
    encryptPseudonymBatch(messages: Pseudonym[]): EncryptedPseudonym[];
    /**
     * Encrypt a Record using session keys.
     */
    encryptRecord(record: Record): RecordEncrypted;
    constructor(blinded_global_keys: BlindedGlobalKeys, session_key_shares: SessionKeyShares[]);
    static restore(keys: SessionKeys): Client;
    updateAttributeSessionSecretKey(old_key_share: AttributeSessionKeyShare, new_key_share: AttributeSessionKeyShare): void;
    updatePseudonymSessionSecretKey(old_key_share: PseudonymSessionKeyShare, new_key_share: PseudonymSessionKeyShare): void;
    updateSessionSecretKeys(old_key_shares: SessionKeyShares, new_key_shares: SessionKeyShares): void;
}

/**
 * A distributed PEP transcryptor system with blinding factor support.
 */
export class DistributedTranscryptor {
    free(): void;
    [Symbol.dispose](): void;
    attributeRekeyInfo(session_from: EncryptionContext, session_to: EncryptionContext): AttributeRekeyInfo;
    attributeSessionKeyShare(session: EncryptionContext): AttributeSessionKeyShare;
    constructor(pseudonymisation_secret: string, rekeying_secret: string, blinding_factor: BlindingFactor);
    pseudonymRekeyInfo(session_from: EncryptionContext, session_to: EncryptionContext): PseudonymRekeyFactor;
    pseudonymSessionKeyShare(session: EncryptionContext): PseudonymSessionKeyShare;
    pseudonymizationInfo(domain_from: PseudonymizationDomain, domain_to: PseudonymizationDomain, session_from: EncryptionContext, session_to: EncryptionContext): PseudonymizationInfo;
    pseudonymize(encrypted: EncryptedPseudonym, pseudo_info: PseudonymizationInfo): EncryptedPseudonym;
    pseudonymizeBatch(encrypted: EncryptedPseudonym[], pseudonymization_info: PseudonymizationInfo): EncryptedPseudonym[];
    /**
     * Pseudonymize a long encrypted pseudonym from one domain/session to another.
     */
    pseudonymizeLong(encrypted: LongEncryptedPseudonym, pseudonymization_info: PseudonymizationInfo): LongEncryptedPseudonym;
    /**
     * Pseudonymize a batch of long encrypted pseudonyms from one domain/session to another.
     */
    pseudonymizeLongBatch(encrypted: LongEncryptedPseudonym[], pseudonymization_info: PseudonymizationInfo): LongEncryptedPseudonym[];
    rekey(encrypted: EncryptedAttribute, rekey_info: AttributeRekeyInfo): EncryptedAttribute;
    rekeyBatch(encrypted: EncryptedAttribute[], rekey_info: AttributeRekeyInfo): EncryptedAttribute[];
    /**
     * Rekey a long encrypted attribute from one session to another.
     */
    rekeyLong(encrypted: LongEncryptedAttribute, rekey_info: AttributeRekeyInfo): LongEncryptedAttribute;
    /**
     * Rekey a batch of long encrypted attributes from one session to another.
     */
    rekeyLongBatch(encrypted: LongEncryptedAttribute[], rekey_info: AttributeRekeyInfo): LongEncryptedAttribute[];
    sessionKeyShares(session: EncryptionContext): SessionKeyShares;
    /**
     * Transcrypt an EncryptedPEPJSONValue from one context to another.
     *
     * # Arguments
     *
     * * `encrypted` - The EncryptedPEPJSONValue to transcrypt
     * * `transcryption_info` - The transcryption information
     *
     * # Returns
     *
     * A transcrypted EncryptedPEPJSONValue
     */
    transcryptJSON(encrypted: EncryptedPEPJSONValue, transcryption_info: TranscryptionInfo): EncryptedPEPJSONValue;
    /**
     * Transcrypt a batch of EncryptedPEPJSONValues and shuffle their order.
     *
     * # Arguments
     *
     * * `values` - Array of EncryptedPEPJSONValue objects
     * * `transcryption_info` - The transcryption information
     *
     * # Returns
     *
     * A shuffled array of transcrypted EncryptedPEPJSONValue objects
     */
    transcryptJSONBatch(values: EncryptedPEPJSONValue[], transcryption_info: TranscryptionInfo): EncryptedPEPJSONValue[];
    /**
     * Transcrypt a LongEncryptedRecord from one context to another.
     */
    transcryptLongRecord(encrypted: LongRecordEncrypted, transcryption_info: TranscryptionInfo): LongRecordEncrypted;
    /**
     * Transcrypt a batch of LongEncryptedRecords and shuffle their order.
     */
    transcryptLongRecordBatch(records: LongRecordEncrypted[], transcryption_info: TranscryptionInfo): LongRecordEncrypted[];
    /**
     * Transcrypt an EncryptedRecord from one context to another.
     */
    transcryptRecord(encrypted: RecordEncrypted, transcryption_info: TranscryptionInfo): RecordEncrypted;
    /**
     * Transcrypt a batch of EncryptedRecords and shuffle their order.
     */
    transcryptRecordBatch(records: RecordEncrypted[], transcryption_info: TranscryptionInfo): RecordEncrypted[];
    transcryptionInfo(domain_from: PseudonymizationDomain, domain_to: PseudonymizationDomain, session_from: EncryptionContext, session_to: EncryptionContext): TranscryptionInfo;
}

/**
 * An ElGamal ciphertext.
 */
export class ElGamal {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Decodes an ElGamal ciphertext from a base64 string.
     */
    static fromBase64(s: string): ElGamal | undefined;
    /**
     * Decodes an ElGamal ciphertext from a byte array.
     */
    static fromBytes(v: Uint8Array): ElGamal | undefined;
    /**
     * Encodes the ElGamal ciphertext as a base64 string.
     */
    toBase64(): string;
    /**
     * Encodes the ElGamal ciphertext as a byte array.
     */
    toBytes(): Uint8Array;
}

/**
 * An encrypted attribute.
 */
export class EncryptedAttribute {
    free(): void;
    [Symbol.dispose](): void;
    static fromBase64(s: string): EncryptedAttribute | undefined;
    static fromBytes(v: Uint8Array): EncryptedAttribute | undefined;
    constructor(x: ElGamal);
    toBase64(): string;
    toBytes(): Uint8Array;
}

/**
 * An encrypted PEP JSON value.
 *
 * This wraps JSON values where primitive types are encrypted as PEP types.
 */
export class EncryptedPEPJSONValue {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Deserialize from JSON string.
     *
     * # Arguments
     *
     * * `json_str` - A JSON string
     *
     * # Returns
     *
     * An EncryptedPEPJSONValue
     */
    static fromJSON(json_str: string): EncryptedPEPJSONValue;
    /**
     * Get the structure/shape of this EncryptedPEPJSONValue.
     *
     * # Returns
     *
     * A JSONStructure describing the shape
     */
    structure(): JSONStructure;
    /**
     * Serialize to JSON string.
     *
     * # Returns
     *
     * A JSON string representation
     */
    toJSON(): string;
    /**
     * Transcrypt this EncryptedPEPJSONValue from one context to another.
     *
     * # Arguments
     *
     * * `from_domain` - Source pseudonymization domain
     * * `to_domain` - Target pseudonymization domain
     * * `from_session` - Source encryption session (optional)
     * * `to_session` - Target encryption session (optional)
     * * `pseudonymization_secret` - Pseudonymization secret
     * * `encryption_secret` - Encryption secret
     *
     * # Returns
     *
     * A transcrypted EncryptedPEPJSONValue
     */
    transcrypt(from_domain: PseudonymizationDomain, to_domain: PseudonymizationDomain, from_session: EncryptionContext, to_session: EncryptionContext, pseudonymization_secret: PseudonymizationSecret, encryption_secret: EncryptionSecret): EncryptedPEPJSONValue;
}

/**
 * An encrypted pseudonym.
 */
export class EncryptedPseudonym {
    free(): void;
    [Symbol.dispose](): void;
    static fromBase64(s: string): EncryptedPseudonym | undefined;
    static fromBytes(v: Uint8Array): EncryptedPseudonym | undefined;
    constructor(x: ElGamal);
    toBase64(): string;
    toBytes(): Uint8Array;
}

export class EncryptionContext {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Create a global encryption context.
     */
    static global(): EncryptionContext;
    /**
     * Create a specific encryption context from a string identifier.
     */
    constructor(payload: string);
}

/**
 * Encryption secret used to derive rekey factors from an [`EncryptionContext`].
 */
export class EncryptionSecret {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Create a new encryption secret from bytes (static method).
     */
    static from(secret: Uint8Array): EncryptionSecret;
    /**
     * Create a new encryption secret from bytes.
     */
    constructor(secret: Uint8Array);
}

/**
 * Combined global key pairs for both pseudonyms and attributes.
 */
export class GlobalKeyPairs {
    free(): void;
    [Symbol.dispose](): void;
    constructor(_public: GlobalPublicKeys, secret: GlobalSecretKeys);
    readonly public: GlobalPublicKeys;
    readonly secret: GlobalSecretKeys;
}

/**
 * Combined global public keys for both pseudonyms and attributes.
 */
export class GlobalPublicKeys {
    free(): void;
    [Symbol.dispose](): void;
    constructor(pseudonym: PseudonymGlobalPublicKey, attribute: AttributeGlobalPublicKey);
    readonly attribute: AttributeGlobalPublicKey;
    readonly pseudonym: PseudonymGlobalPublicKey;
}

/**
 * Combined global secret keys for both pseudonyms and attributes.
 */
export class GlobalSecretKeys {
    free(): void;
    [Symbol.dispose](): void;
    constructor(pseudonym: PseudonymGlobalSecretKey, attribute: AttributeGlobalSecretKey);
    readonly attribute: AttributeGlobalSecretKey;
    readonly pseudonym: PseudonymGlobalSecretKey;
}

/**
 * Element on a group. Can not be converted to a scalar. Supports addition and subtraction. Multiplication by a scalar is supported.
 * We use ristretto points to discard unsafe points and safely use the group operations in higher level protocols without any other cryptographic assumptions.
 */
export class GroupElement {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Returns the generator of the group.
     */
    static G(): GroupElement;
    /**
     * Adds two group elements.
     */
    add(other: GroupElement): GroupElement;
    /**
     * Decodes a group element from a 32-byte array.
     */
    static fromBytes(bytes: Uint8Array): GroupElement | undefined;
    /**
     * Decodes a group element from a 64-byte hash.
     */
    static fromHash(v: Uint8Array): GroupElement;
    /**
     * Decodes a group element from a hexadecimal string of 64 characters.
     */
    static fromHex(hex: string): GroupElement | undefined;
    /**
     * Returns the generator of the group.
     */
    static generator(): GroupElement;
    /**
     * Returns the identity element of the group.
     */
    static identity(): GroupElement;
    /**
     * Multiplies a group element by a scalar.
     */
    mul(other: ScalarNonZero): GroupElement;
    /**
     * Generates a random group element.
     */
    static random(): GroupElement;
    /**
     * Subtracts two group elements.
     */
    sub(other: GroupElement): GroupElement;
    /**
     * Encodes the group element as a 32-byte array.
     */
    toBytes(): Uint8Array;
    /**
     * Encodes the group element as a hexadecimal string of 64 characters.
     */
    toHex(): string;
}

/**
 * A JSON structure descriptor that describes the shape of an EncryptedPEPJSONValue.
 */
export class JSONStructure {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Compare two structures for equality.
     */
    equals(other: JSONStructure): boolean;
    /**
     * Serialize to JSON string.
     *
     * # Returns
     *
     * A JSON string representation
     */
    toJSON(): string;
    /**
     * Convert to a human-readable string.
     */
    toString(): string;
}

/**
 * A collection of attributes that together represent a larger data value using PKCS#7 padding.
 */
export class LongAttribute {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Clone this object.
     */
    clone(): LongAttribute;
    /**
     * Encodes an arbitrary-length byte array into a `LongAttribute` using PKCS#7 padding.
     */
    static fromBytesPadded(data: Uint8Array): LongAttribute;
    /**
     * Encodes an arbitrary-length string into a `LongAttribute` using PKCS#7 padding.
     */
    static fromStringPadded(text: string): LongAttribute;
    /**
     * Create from a vector of attributes.
     */
    constructor(attributes: Attribute[]);
    /**
     * Pads this LongAttribute to a target number of blocks for batch operations.
     *
     * This is useful for batch operations where all attributes must have the same structure.
     * The padding blocks are automatically detected and skipped during decoding.
     *
     * # Arguments
     *
     * * `targetBlocks` - The desired number of blocks (must be >= current block count)
     *
     * # Returns
     *
     * A new LongAttribute padded to the target number of blocks
     *
     * # Errors
     *
     * Throws an error if the current number of blocks exceeds the target
     */
    padTo(target_blocks: number): LongAttribute;
    /**
     * Decodes the `LongAttribute` back to the original byte array.
     */
    toBytesPadded(): Uint8Array;
    /**
     * Decodes the `LongAttribute` back to the original string.
     */
    toStringPadded(): string;
    /**
     * Get the underlying attributes.
     */
    readonly attributes: Attribute[];
    /**
     * Get the number of attribute blocks.
     */
    readonly length: number;
}

/**
 * A collection of encrypted attributes that can be serialized as a pipe-delimited string.
 */
export class LongEncryptedAttribute {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Clone this object.
     */
    clone(): LongEncryptedAttribute;
    /**
     * Deserializes from a pipe-delimited base64 string.
     */
    static deserialize(s: string): LongEncryptedAttribute;
    /**
     * Create from a vector of encrypted attributes.
     */
    constructor(encrypted_attributes: EncryptedAttribute[]);
    /**
     * Serializes to a pipe-delimited base64 string.
     */
    serialize(): string;
    /**
     * Get the underlying encrypted attributes.
     */
    readonly encryptedAttributes: EncryptedAttribute[];
    /**
     * Get the number of encrypted attribute blocks.
     */
    readonly length: number;
}

/**
 * A collection of encrypted pseudonyms that can be serialized as a pipe-delimited string.
 */
export class LongEncryptedPseudonym {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Clone this object.
     */
    clone(): LongEncryptedPseudonym;
    /**
     * Deserializes from a pipe-delimited base64 string.
     */
    static deserialize(s: string): LongEncryptedPseudonym;
    /**
     * Create from a vector of encrypted pseudonyms.
     */
    constructor(encrypted_pseudonyms: EncryptedPseudonym[]);
    /**
     * Serializes to a pipe-delimited base64 string.
     */
    serialize(): string;
    /**
     * Get the underlying encrypted pseudonyms.
     */
    readonly encryptedPseudonyms: EncryptedPseudonym[];
    /**
     * Get the number of encrypted pseudonym blocks.
     */
    readonly length: number;
}

/**
 * A pair of long encrypted pseudonyms and attributes for batch transcryption.
 */
export class LongEncryptedRecord {
    free(): void;
    [Symbol.dispose](): void;
    constructor(pseudonyms: LongEncryptedPseudonym[], attributes: LongEncryptedAttribute[]);
    readonly attributes: LongEncryptedAttribute[];
    readonly pseudonyms: LongEncryptedPseudonym[];
}

/**
 * A collection of pseudonyms that together represent a larger pseudonym value using PKCS#7 padding.
 */
export class LongPseudonym {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Clone this object.
     */
    clone(): LongPseudonym;
    /**
     * Encodes an arbitrary-length byte array into a `LongPseudonym` using PKCS#7 padding.
     */
    static fromBytesPadded(data: Uint8Array): LongPseudonym;
    /**
     * Encodes an arbitrary-length string into a `LongPseudonym` using PKCS#7 padding.
     */
    static fromStringPadded(text: string): LongPseudonym;
    /**
     * Create from a vector of pseudonyms.
     */
    constructor(pseudonyms: Pseudonym[]);
    /**
     * Pads this LongPseudonym to a target number of blocks for batch unlinkability.
     *
     * In batch transcryption, all values must have identical structure to prevent
     * linkability attacks. This method adds external padding blocks to normalize
     * different-sized pseudonyms to the same structure.
     *
     * # Arguments
     *
     * * `targetBlocks` - The desired number of blocks (must be >= current block count)
     *
     * # Returns
     *
     * A new LongPseudonym padded to the target number of blocks
     *
     * # Errors
     *
     * Throws an error if the current number of blocks exceeds the target
     */
    padTo(target_blocks: number): LongPseudonym;
    /**
     * Decodes the `LongPseudonym` back to the original byte array.
     */
    toBytesPadded(): Uint8Array;
    /**
     * Decodes the `LongPseudonym` back to the original string.
     */
    toStringPadded(): string;
    /**
     * Get the number of pseudonym blocks.
     */
    readonly length: number;
    /**
     * Get the underlying pseudonyms.
     */
    readonly pseudonyms: Pseudonym[];
}

/**
 * A long record containing multiple long pseudonyms and attributes for a single entity.
 */
export class LongRecord {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Create a new LongRecord with the given long pseudonyms and attributes.
     */
    constructor(pseudonyms: LongPseudonym[], attributes: LongAttribute[]);
    /**
     * Pads this LongRecord to match a target structure by adding external padding blocks.
     *
     * This method adds external padding blocks (separate from PKCS#7 padding) to
     * each pseudonym and attribute to ensure all records have the same structure.
     * This is necessary for batch transcryption where all values must have identical
     * structure to prevent linkability attacks.
     *
     * # Arguments
     *
     * * `structure` - The target structure specifying the number of blocks for each field
     *
     * # Returns
     *
     * A padded LongRecord with padding blocks added where necessary
     *
     * # Errors
     *
     * Throws an error if the number of pseudonyms/attributes doesn't match the structure
     * or if any field exceeds its target size
     */
    padTo(structure: LongRecordStructure): LongRecord;
    /**
     * Get the structure of this LongRecord.
     *
     * # Returns
     *
     * A LongRecordStructure describing the number of blocks in each pseudonym and attribute
     */
    structure(): LongRecordStructure;
    /**
     * Get the long attributes in this record.
     */
    readonly attributes: LongAttribute[];
    /**
     * Get the long pseudonyms in this record.
     */
    readonly pseudonyms: LongPseudonym[];
}

/**
 * An encrypted long record containing multiple encrypted long pseudonyms and attributes.
 * This is the encrypted version of a LongRecord that can be decrypted back.
 */
export class LongRecordEncrypted {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Create a new encrypted long record.
     */
    constructor(pseudonyms: LongEncryptedPseudonym[], attributes: LongEncryptedAttribute[]);
    /**
     * Get the encrypted long attributes in this record.
     */
    readonly attributes: LongEncryptedAttribute[];
    /**
     * Get the encrypted long pseudonyms in this record.
     */
    readonly pseudonyms: LongEncryptedPseudonym[];
}

/**
 * Structure descriptor for LongRecords - describes the shape including block counts.
 */
export class LongRecordStructure {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Create a new LongRecordStructure with block counts for pseudonyms and attributes.
     *
     * # Arguments
     *
     * * `pseudonymBlocks` - Array of block counts for each pseudonym
     * * `attributeBlocks` - Array of block counts for each attribute
     */
    constructor(pseudonym_blocks: Uint32Array, attribute_blocks: Uint32Array);
    /**
     * Get the block counts for attributes.
     */
    readonly attributeBlocks: Uint32Array;
    /**
     * Get the block counts for pseudonyms.
     */
    readonly pseudonymBlocks: Uint32Array;
}

/**
 * An offline PEP client.
 */
export class OfflinePEPClient {
    free(): void;
    [Symbol.dispose](): void;
    encryptData(message: Attribute): EncryptedAttribute;
    /**
     * Encrypt a batch of attributes with global keys.
     */
    encryptDataBatch(messages: Attribute[]): EncryptedAttribute[];
    /**
     * Encrypt a PEPJSONValue using global public keys (offline mode).
     */
    encryptJSON(value: PEPJSONValue): EncryptedPEPJSONValue;
    /**
     * Encrypt a batch of PEPJSONValues with global keys.
     */
    encryptJSONBatch(values: PEPJSONValue[]): EncryptedPEPJSONValue[];
    encryptLongData(message: LongAttribute): LongEncryptedAttribute;
    /**
     * Encrypt a batch of long attributes with global keys.
     */
    encryptLongDataBatch(messages: LongAttribute[]): LongEncryptedAttribute[];
    encryptLongPseudonym(message: LongPseudonym): LongEncryptedPseudonym;
    /**
     * Encrypt a batch of long pseudonyms with global keys.
     */
    encryptLongPseudonymBatch(messages: LongPseudonym[]): LongEncryptedPseudonym[];
    /**
     * Encrypt a LongRecord using global public keys (offline mode).
     */
    encryptLongRecord(record: LongRecord): LongRecordEncrypted;
    encryptPseudonym(message: Pseudonym): EncryptedPseudonym;
    /**
     * Encrypt a batch of pseudonyms with global keys.
     */
    encryptPseudonymBatch(messages: Pseudonym[]): EncryptedPseudonym[];
    /**
     * Encrypt a Record using global public keys (offline mode).
     */
    encryptRecord(record: Record): RecordEncrypted;
    constructor(global_keys: GlobalPublicKeys);
}

/**
 * Builder for constructing PEPJSONValue objects with mixed attribute and pseudonym fields.
 */
export class PEPJSONBuilder {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Add a field as a regular attribute.
     *
     * # Arguments
     *
     * * `key` - Field name
     * * `value` - Field value (any JSON-serializable JavaScript value)
     *
     * # Returns
     *
     * Self (for chaining)
     */
    attribute(key: string, value: any): PEPJSONBuilder;
    /**
     * Build the final PEPJSONValue object.
     *
     * # Returns
     *
     * A PEPJSONValue
     */
    build(): PEPJSONValue;
    /**
     * Create a builder from a JavaScript object, marking specified fields as pseudonyms.
     *
     * # Arguments
     *
     * * `value` - A JavaScript object (will be converted to JSON)
     * * `pseudonyms` - An array of field names that should be treated as pseudonyms
     *
     * # Returns
     *
     * A PEPJSONBuilder
     */
    static fromJson(value: any, pseudonyms: string[]): PEPJSONBuilder;
    /**
     * Create a new builder.
     */
    constructor();
    /**
     * Add a string field as a pseudonym.
     *
     * # Arguments
     *
     * * `key` - Field name
     * * `value` - String value
     *
     * # Returns
     *
     * Self (for chaining)
     */
    pseudonym(key: string, value: string): PEPJSONBuilder;
}

/**
 * A PEP JSON value that can be encrypted.
 *
 * This wraps JSON values where primitive types are stored as unencrypted PEP types.
 */
export class PEPJSONValue {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Create a PEPJSONValue from a regular JavaScript value.
     *
     * # Arguments
     *
     * * `value` - A JSON-serializable JavaScript value
     *
     * # Returns
     *
     * A PEPJSONValue
     */
    static fromValue(value: any): PEPJSONValue;
    /**
     * Pads this PEPJSONValue to match a target structure by adding external padding blocks.
     *
     * This method adds external padding blocks (separate from PKCS#7 padding) to
     * LongString and LongPseudonym variants to ensure all instances have the same
     * number of blocks when encrypted. This is necessary for batch transcryption where
     * all values must have identical structure.
     *
     * # Arguments
     *
     * * `structure` - The target structure specifying the number of blocks for each field
     *
     * # Returns
     *
     * A padded PEPJSONValue with padding blocks added where necessary
     *
     * # Errors
     *
     * Throws an error if the current structure doesn't match the target structure type
     * or if the current size exceeds the target size
     */
    padTo(structure: JSONStructure): PEPJSONValue;
    /**
     * Get the structure/shape of this PEPJSONValue.
     *
     * # Returns
     *
     * A JSONStructure describing the shape
     */
    structure(): JSONStructure;
    /**
     * Convert this PEPJSONValue to a regular JavaScript value.
     *
     * # Returns
     *
     * A JavaScript value (object, array, string, number, boolean, or null)
     */
    toJson(): any;
}

/**
 * A pseudonym that can be used to identify a user.
 */
export class Pseudonym {
    free(): void;
    [Symbol.dispose](): void;
    static fromBytes(bytes: Uint8Array): Pseudonym | undefined;
    static fromBytesPadded(data: Uint8Array): Pseudonym | undefined;
    static fromHash(v: Uint8Array): Pseudonym;
    static fromHex(hex: string): Pseudonym | undefined;
    static fromLizard(data: Uint8Array): Pseudonym | undefined;
    static fromStringPadded(text: string): Pseudonym | undefined;
    constructor(x: GroupElement);
    static random(): Pseudonym;
    toBytes(): Uint8Array;
    toBytesPadded(): Uint8Array | undefined;
    toHex(): string;
    toLizard(): Uint8Array | undefined;
    toPoint(): GroupElement;
    toStringPadded(): string | undefined;
}

/**
 * Pseudonym global key pair.
 */
export class PseudonymGlobalKeyPair {
    free(): void;
    [Symbol.dispose](): void;
    constructor(_public: PseudonymGlobalPublicKey, secret: PseudonymGlobalSecretKey);
    readonly public: PseudonymGlobalPublicKey;
    readonly secret: PseudonymGlobalSecretKey;
}

/**
 * A pseudonym global public key from which pseudonym session keys are derived.
 */
export class PseudonymGlobalPublicKey {
    free(): void;
    [Symbol.dispose](): void;
    static fromBytes(bytes: Uint8Array): PseudonymGlobalPublicKey | undefined;
    static fromHex(hex: string): PseudonymGlobalPublicKey | undefined;
    constructor(x: GroupElement);
    toBytes(): Uint8Array;
    toHex(): string;
    0: GroupElement;
}

/**
 * A pseudonym global secret key from which pseudonym session keys are derived.
 */
export class PseudonymGlobalSecretKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    0: ScalarNonZero;
}

/**
 * Factors for pseudonymization containing reshuffle and rekey factors.
 */
export class PseudonymRSKFactors {
    free(): void;
    [Symbol.dispose](): void;
    constructor(s: ReshuffleFactor, k: PseudonymRekeyFactor);
    k: PseudonymRekeyFactor;
    s: ReshuffleFactor;
}

/**
 * A factor used to rekey pseudonyms between sessions.
 */
export class PseudonymRekeyFactor {
    free(): void;
    [Symbol.dispose](): void;
    constructor(scalar: ScalarNonZero);
    scalar(): ScalarNonZero;
}

/**
 * Pseudonym session key pair.
 */
export class PseudonymSessionKeyPair {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    readonly public: PseudonymSessionPublicKey;
    readonly secret: PseudonymSessionSecretKey;
}

/**
 * A pseudonym session key share.
 */
export class PseudonymSessionKeyShare {
    free(): void;
    [Symbol.dispose](): void;
    static fromBytes(bytes: Uint8Array): PseudonymSessionKeyShare | undefined;
    static fromHex(hex: string): PseudonymSessionKeyShare | undefined;
    constructor(x: ScalarNonZero);
    toBytes(): Uint8Array;
    toHex(): string;
}

/**
 * Session keys for encrypting and decrypting data.
 * Pseudonym session keys containing both public and secret keys.
 */
export class PseudonymSessionKeys {
    free(): void;
    [Symbol.dispose](): void;
    constructor(_public: PseudonymSessionPublicKey, secret: PseudonymSessionSecretKey);
    readonly public: PseudonymSessionPublicKey;
    readonly secret: PseudonymSessionSecretKey;
}

/**
 * A pseudonym session public key used to encrypt pseudonyms against.
 */
export class PseudonymSessionPublicKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    0: GroupElement;
}

/**
 * A pseudonym session secret key used to decrypt pseudonyms with.
 */
export class PseudonymSessionSecretKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    0: ScalarNonZero;
}

export class PseudonymizationDomain {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Create a specific pseudonymization domain from a string identifier.
     */
    constructor(payload: string);
}

export class PseudonymizationInfo {
    free(): void;
    [Symbol.dispose](): void;
    constructor(domain_from: PseudonymizationDomain, domain_to: PseudonymizationDomain, session_from: EncryptionContext, session_to: EncryptionContext, pseudonymization_secret: PseudonymizationSecret, encryption_secret: EncryptionSecret);
    reverse(): PseudonymizationInfo;
    readonly k: PseudonymRekeyFactor;
}

/**
 * Pseudonymization secret used to derive a [`ReshuffleFactor`] from a [`PseudonymizationDomain`].
 *
 * [`ReshuffleFactor`]: crate::factors::ReshuffleFactor
 * [`PseudonymizationDomain`]: crate::factors::contexts::PseudonymizationDomain
 */
export class PseudonymizationSecret {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Create a new pseudonymization secret from bytes (static method).
     */
    static from(secret: Uint8Array): PseudonymizationSecret;
    /**
     * Create a new pseudonymization secret from bytes.
     */
    constructor(secret: Uint8Array);
}

/**
 * A record containing multiple pseudonyms and attributes for a single entity.
 */
export class Record {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Create a new Record with the given pseudonyms and attributes.
     */
    constructor(pseudonyms: Pseudonym[], attributes: Attribute[]);
    /**
     * Get the attributes in this record.
     */
    readonly attributes: Attribute[];
    /**
     * Get the pseudonyms in this record.
     */
    readonly pseudonyms: Pseudonym[];
}

/**
 * An encrypted record containing multiple encrypted pseudonyms and attributes.
 * This is the encrypted version of a Record that can be decrypted back.
 */
export class RecordEncrypted {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Create a new encrypted record.
     */
    constructor(pseudonyms: EncryptedPseudonym[], attributes: EncryptedAttribute[]);
    /**
     * Get the encrypted attributes in this record.
     */
    readonly attributes: EncryptedAttribute[];
    /**
     * Get the encrypted pseudonyms in this record.
     */
    readonly pseudonyms: EncryptedPseudonym[];
}

/**
 * A factor used to rerandomize an ElGamal ciphertext.
 */
export class RerandomizeFactor {
    free(): void;
    [Symbol.dispose](): void;
    constructor(scalar: ScalarNonZero);
    scalar(): ScalarNonZero;
}

/**
 * A factor used to reshuffle an ElGamal ciphertext.
 */
export class ReshuffleFactor {
    free(): void;
    [Symbol.dispose](): void;
    constructor(scalar: ScalarNonZero);
    scalar(): ScalarNonZero;
}

/**
 * Scalar that can be zero. Supports addition and subtraction, but not multiplication or inversion.
 */
export class ScalarCanBeZero {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Adds two scalars.
     */
    add(other: ScalarCanBeZero): ScalarCanBeZero;
    /**
     * Decodes a scalar from a 32-byte array.
     */
    static fromBytes(bytes: Uint8Array): ScalarCanBeZero | undefined;
    /**
     * Decodes a scalar from a hexadecimal string of 64 characters.
     */
    static fromHex(hex: string): ScalarCanBeZero | undefined;
    /**
     * Checks if the scalar is zero.
     */
    isZero(): boolean;
    /**
     * Returns scalar one.
     */
    static one(): ScalarCanBeZero;
    /**
     * Generates a random scalar (that can be zero, but is extremely unlikely to be).
     */
    static random(): ScalarCanBeZero;
    /**
     * Subtracts two scalars.
     */
    sub(other: ScalarCanBeZero): ScalarCanBeZero;
    /**
     * Encodes the scalar as a 32-byte array.
     */
    toBytes(): Uint8Array;
    /**
     * Encodes the scalar as a hexadecimal string of 64 characters.
     */
    toHex(): string;
    /**
     * Tries to convert the scalar to a scalar that can not be zero.
     */
    toNonZero(): ScalarNonZero | undefined;
    /**
     * Returns scalar zero.
     */
    static zero(): ScalarCanBeZero;
}

/**
 * Non-zero scalar. Supports addition, subtraction, multiplication, and inversion. Can be converted to a scalar that can be zero.
 */
export class ScalarNonZero {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Decodes a scalar from a 32-byte array.
     */
    static fromBytes(bytes: Uint8Array): ScalarNonZero | undefined;
    /**
     * Decodes a scalar from a 64-byte hash.
     */
    static fromHash(v: Uint8Array): ScalarNonZero;
    /**
     * Decodes a scalar from a hexadecimal string of 64 characters.
     */
    static fromHex(hex: string): ScalarNonZero | undefined;
    /**
     * Inverts the scalar.
     */
    invert(): ScalarNonZero;
    /**
     * Multiplies two scalars.
     */
    mul(other: ScalarNonZero): ScalarNonZero;
    /**
     * Returns scalar one.
     */
    static one(): ScalarNonZero;
    /**
     * Generates a random non-zero scalar.
     */
    static random(): ScalarNonZero;
    /**
     * Encodes the scalar as a 32-byte array.
     */
    toBytes(): Uint8Array;
    /**
     * Converts the scalar to a scalar that can be zero.
     */
    toCanBeZero(): ScalarCanBeZero;
    /**
     * Encodes the scalar as a hexadecimal string of 64 characters.
     */
    toHex(): string;
}

/**
 * A pair of session key shares.
 */
export class SessionKeyShares {
    free(): void;
    [Symbol.dispose](): void;
    constructor(pseudonym: PseudonymSessionKeyShare, attribute: AttributeSessionKeyShare);
    readonly attribute: AttributeSessionKeyShare;
    readonly pseudonym: PseudonymSessionKeyShare;
}

/**
 * Session keys for both pseudonyms and attributes.
 * Contains both pseudonym and attribute session keys (public and secret).
 */
export class SessionKeys {
    free(): void;
    [Symbol.dispose](): void;
    constructor(pseudonym: PseudonymSessionKeys, attribute: AttributeSessionKeys);
    readonly attribute: AttributeSessionKeys;
    readonly pseudonym: PseudonymSessionKeys;
}

export class TranscryptionInfo {
    free(): void;
    [Symbol.dispose](): void;
    constructor(domain_from: PseudonymizationDomain, domain_to: PseudonymizationDomain, session_from: EncryptionContext, session_to: EncryptionContext, pseudonymization_secret: PseudonymizationSecret, encryption_secret: EncryptionSecret);
    reverse(): TranscryptionInfo;
    readonly attribute: AttributeRekeyInfo;
    readonly pseudonym: PseudonymizationInfo;
}

/**
 * A PEP transcryptor system.
 */
export class Transcryptor {
    free(): void;
    [Symbol.dispose](): void;
    attributeRekeyInfo(session_from: EncryptionContext, session_to: EncryptionContext): AttributeRekeyInfo;
    constructor(pseudonymisation_secret: string, rekeying_secret: string);
    pseudonymRekeyInfo(session_from: EncryptionContext, session_to: EncryptionContext): PseudonymRekeyFactor;
    pseudonymizationInfo(domain_from: PseudonymizationDomain, domain_to: PseudonymizationDomain, session_from: EncryptionContext, session_to: EncryptionContext): PseudonymizationInfo;
    pseudonymize(encrypted: EncryptedPseudonym, pseudo_info: PseudonymizationInfo): EncryptedPseudonym;
    pseudonymizeBatch(encrypted: EncryptedPseudonym[], pseudonymization_info: PseudonymizationInfo): EncryptedPseudonym[];
    /**
     * Pseudonymize a long encrypted pseudonym from one domain/session to another.
     */
    pseudonymizeLong(encrypted: LongEncryptedPseudonym, pseudonymization_info: PseudonymizationInfo): LongEncryptedPseudonym;
    /**
     * Pseudonymize a batch of long encrypted pseudonyms from one domain/session to another.
     */
    pseudonymizeLongBatch(encrypted: LongEncryptedPseudonym[], pseudonymization_info: PseudonymizationInfo): LongEncryptedPseudonym[];
    rekey(encrypted: EncryptedAttribute, rekey_info: AttributeRekeyInfo): EncryptedAttribute;
    rekeyBatch(encrypted: EncryptedAttribute[], rekey_info: AttributeRekeyInfo): EncryptedAttribute[];
    /**
     * Rekey a long encrypted attribute from one session to another.
     */
    rekeyLong(encrypted: LongEncryptedAttribute, rekey_info: AttributeRekeyInfo): LongEncryptedAttribute;
    /**
     * Rekey a batch of long encrypted attributes from one session to another.
     */
    rekeyLongBatch(encrypted: LongEncryptedAttribute[], rekey_info: AttributeRekeyInfo): LongEncryptedAttribute[];
    /**
     * Transcrypt an EncryptedPEPJSONValue from one context to another.
     */
    transcryptJSON(encrypted: EncryptedPEPJSONValue, transcryption_info: TranscryptionInfo): EncryptedPEPJSONValue;
    /**
     * Transcrypt a batch of EncryptedPEPJSONValues and shuffle their order.
     */
    transcryptJSONBatch(values: EncryptedPEPJSONValue[], transcryption_info: TranscryptionInfo): EncryptedPEPJSONValue[];
    /**
     * Transcrypt a LongEncryptedRecord from one context to another.
     */
    transcryptLongRecord(encrypted: LongRecordEncrypted, transcryption_info: TranscryptionInfo): LongRecordEncrypted;
    /**
     * Transcrypt a batch of LongEncryptedRecords and shuffle their order.
     */
    transcryptLongRecordBatch(records: LongRecordEncrypted[], transcryption_info: TranscryptionInfo): LongRecordEncrypted[];
    /**
     * Transcrypt an EncryptedRecord from one context to another.
     */
    transcryptRecord(encrypted: RecordEncrypted, transcryption_info: TranscryptionInfo): RecordEncrypted;
    /**
     * Transcrypt a batch of EncryptedRecords and shuffle their order.
     */
    transcryptRecordBatch(records: RecordEncrypted[], transcryption_info: TranscryptionInfo): RecordEncrypted[];
    transcryptionInfo(domain_from: PseudonymizationDomain, domain_to: PseudonymizationDomain, session_from: EncryptionContext, session_to: EncryptionContext): TranscryptionInfo;
}

/**
 * Encodes a byte array (up to 15 bytes) into an `Attribute` using PKCS#7 padding.
 */
export function attributeFromBytesPadded(data: Uint8Array): Attribute | undefined;

/**
 * Encodes a string (up to 15 bytes) into an `Attribute` using PKCS#7 padding.
 */
export function attributeFromStringPadded(text: string): Attribute | undefined;

/**
 * Decodes an `Attribute` back to the original byte array.
 */
export function attributeToBytesPadded(attribute: Attribute): Uint8Array | undefined;

/**
 * Decodes an `Attribute` back to the original string.
 */
export function attributeToStringPadded(attribute: Attribute): string | undefined;

/**
 * Convert a boolean to a single byte (0x00 for false, 0x01 for true).
 */
export function boolToByte(b: boolean): number;

/**
 * Convert a byte to a boolean. Returns an error if the byte is neither 0x00 nor 0x01.
 */
export function byteToBool(byte: number): boolean;

/**
 * Convert bytes to a JSON number (9 bytes: 1 byte type tag + 8 bytes data).
 */
export function bytesToNumber(bytes: Uint8Array): number;

/**
 * Decrypts an ElGamal ciphertext using the provided secret key and returns the group element.
 */
export function decrypt(encrypted: ElGamal, y: ScalarNonZero): GroupElement;

/**
 * Decrypt an encrypted attribute using a session secret key.
 */
export function decryptAttribute(v: EncryptedAttribute, secret_key: AttributeSessionSecretKey): Attribute;

/**
 * Batch decrypt encrypted attributes using a session secret key.
 */
export function decryptAttributeBatch(encrypted: EncryptedAttribute[], key: AttributeSessionSecretKey): Attribute[];

/**
 * Decrypt an encrypted PEPJSONValue using session keys.
 */
export function decryptJSON(encrypted: EncryptedPEPJSONValue, keys: SessionKeys): PEPJSONValue;

/**
 * Decrypt an EncryptedPEPJSONValue using session keys.
 *
 * # Arguments
 *
 * * `encrypted` - EncryptedPEPJSONValue to decrypt
 * * `session_keys` - Session keys containing public and secret keys for both pseudonyms and attributes
 *
 * # Returns
 *
 * A PEPJSONValue
 */
export function decryptJson(encrypted: EncryptedPEPJSONValue, session_keys: SessionKeys): PEPJSONValue;

/**
 * Decrypt a batch of EncryptedPEPJSONValues using session keys.
 *
 * # Arguments
 *
 * * `encrypted` - Array of EncryptedPEPJSONValue objects to decrypt
 * * `session_keys` - Session keys containing public and secret keys for both pseudonyms and
 *
 * # Returns
 * An array of PEPJSONValue objects
 * # Errors
 * Returns an error if any value fails to decrypt
 */
export function decryptJsonBatch(encrypted: EncryptedPEPJSONValue[], session_keys: SessionKeys): PEPJSONValue[];

/**
 * Decrypt an encrypted long attribute using a session secret key.
 */
export function decryptLongAttribute(v: LongEncryptedAttribute, secret_key: AttributeSessionSecretKey): LongAttribute;

/**
 * Batch decrypt encrypted long attributes using a session secret key.
 */
export function decryptLongAttributeBatch(encrypted: LongEncryptedAttribute[], key: AttributeSessionSecretKey): LongAttribute[];

/**
 * Decrypt an encrypted long pseudonym using a session secret key.
 */
export function decryptLongPseudonym(v: LongEncryptedPseudonym, secret_key: PseudonymSessionSecretKey): LongPseudonym;

/**
 * Batch decrypt encrypted long pseudonyms using a session secret key.
 */
export function decryptLongPseudonymBatch(encrypted: LongEncryptedPseudonym[], key: PseudonymSessionSecretKey): LongPseudonym[];

/**
 * Decrypt an encrypted LongRecord using session keys.
 */
export function decryptLongRecord(encrypted: LongRecordEncrypted, keys: SessionKeys): LongRecord;

/**
 * Decrypt an encrypted pseudonym using a session secret key.
 */
export function decryptPseudonym(v: EncryptedPseudonym, secret_key: PseudonymSessionSecretKey): Pseudonym;

/**
 * Batch decrypt encrypted pseudonyms using a session secret key.
 */
export function decryptPseudonymBatch(encrypted: EncryptedPseudonym[], key: PseudonymSessionSecretKey): Pseudonym[];

/**
 * Decrypt an encrypted Record using session keys.
 */
export function decryptRecord(encrypted: RecordEncrypted, keys: SessionKeys): Record;

/**
 * Encrypts a message (group element) using the ElGamal encryption scheme.
 */
export function encrypt(gm: GroupElement, gy: GroupElement): ElGamal;

/**
 * Encrypt an attribute using a session public key.
 */
export function encryptAttribute(m: Attribute, public_key: AttributeSessionPublicKey): EncryptedAttribute;

/**
 * Batch encrypt attributes using a session public key.
 */
export function encryptAttributeBatch(messages: Attribute[], key: AttributeSessionPublicKey): EncryptedAttribute[];

/**
 * Encrypt an attribute using a global public key (offline encryption).
 */
export function encryptAttributeGlobal(m: Attribute, public_key: AttributeGlobalPublicKey): EncryptedAttribute;

/**
 * Encrypt a PEPJSONValue using session keys.
 */
export function encryptJSON(json: PEPJSONValue, keys: SessionKeys): EncryptedPEPJSONValue;

/**
 * Encrypt a PEPJSONValue using session keys.
 *
 * # Arguments
 *
 * * `value` - PEPJSONValue to encrypt
 * * `session_keys` - Session keys containing public and secret keys for both pseudonyms and attributes
 *
 * # Returns
 *
 * An EncryptedPEPJSONValue
 */
export function encryptJson(value: PEPJSONValue, session_keys: SessionKeys): EncryptedPEPJSONValue;

/**
 * Batch encrypt a list of PEPJSONValues using session keys.
 * All values must have the same structure, and the resulting encrypted values will be padded to match the maximum block counts for that structure.
 *
 * # Arguments
 * * `values` - Array of PEPJSONValue objects to encrypt
 * * `session_keys` - Session keys containing public and secret keys for both pseudonyms and
 *
 * # Returns
 * An array of EncryptedPEPJSONValue objects, all with the same structure and padded to match the maximum block counts for that structure
 */
export function encryptJsonBatch(values: PEPJSONValue[], session_keys: SessionKeys): EncryptedPEPJSONValue[];

/**
 * Encrypt a long attribute using a session public key.
 */
export function encryptLongAttribute(m: LongAttribute, public_key: AttributeSessionPublicKey): LongEncryptedAttribute;

/**
 * Batch encrypt long attributes using a session public key.
 */
export function encryptLongAttributeBatch(messages: LongAttribute[], key: AttributeSessionPublicKey): LongEncryptedAttribute[];

/**
 * Encrypt a long attribute using a global public key (offline encryption).
 */
export function encryptLongAttributeGlobal(m: LongAttribute, public_key: AttributeGlobalPublicKey): LongEncryptedAttribute;

/**
 * Encrypt a long pseudonym using a session public key.
 */
export function encryptLongPseudonym(m: LongPseudonym, public_key: PseudonymSessionPublicKey): LongEncryptedPseudonym;

/**
 * Batch encrypt long pseudonyms using a session public key.
 */
export function encryptLongPseudonymBatch(messages: LongPseudonym[], key: PseudonymSessionPublicKey): LongEncryptedPseudonym[];

/**
 * Encrypt a long pseudonym using a global public key (offline encryption).
 */
export function encryptLongPseudonymGlobal(m: LongPseudonym, public_key: PseudonymGlobalPublicKey): LongEncryptedPseudonym;

/**
 * Encrypt a LongRecord using session keys.
 */
export function encryptLongRecord(record: LongRecord, keys: SessionKeys): LongRecordEncrypted;

/**
 * Encrypt a pseudonym using a session public key.
 */
export function encryptPseudonym(m: Pseudonym, public_key: PseudonymSessionPublicKey): EncryptedPseudonym;

/**
 * Batch encrypt pseudonyms using a session public key.
 */
export function encryptPseudonymBatch(messages: Pseudonym[], key: PseudonymSessionPublicKey): EncryptedPseudonym[];

/**
 * Encrypt a pseudonym using a global public key (offline encryption).
 */
export function encryptPseudonymGlobal(m: Pseudonym, public_key: PseudonymGlobalPublicKey): EncryptedPseudonym;

/**
 * Encrypt a Record using session keys.
 */
export function encryptRecord(record: Record, keys: SessionKeys): RecordEncrypted;

/**
 * Generate a new attribute global key pair.
 */
export function makeAttributeGlobalKeys(): AttributeGlobalKeyPair;

/**
 * Derive an attribute rekey factor from a secret and a context.
 */
export function makeAttributeRekeyFactor(secret: EncryptionSecret, context: string): AttributeRekeyFactor;

/**
 * Combines attribute session key shares.
 */
export function makeAttributeSessionKey(blinded_global_key: BlindedAttributeGlobalSecretKey, shares: AttributeSessionKeyShare[]): AttributeSessionKeyPair;

/**
 * Creates an attribute session key share.
 */
export function makeAttributeSessionKeyShare(rekey_factor: ScalarNonZero, blinding_factor: BlindingFactor): AttributeSessionKeyShare;

/**
 * Generate attribute session keys from a global secret key, session and secret.
 */
export function makeAttributeSessionKeys(global: AttributeGlobalSecretKey, session: EncryptionContext, secret: EncryptionSecret): AttributeSessionKeyPair;

/**
 * Creates a blinded attribute global secret key.
 */
export function makeBlindedAttributeGlobalSecretKey(global_secret_key: AttributeGlobalSecretKey, blinding_factors: BlindingFactor[]): BlindedAttributeGlobalSecretKey | undefined;

/**
 * Create blinded global keys.
 */
export function makeBlindedGlobalKeys(pseudonym_global_secret_key: PseudonymGlobalSecretKey, attribute_global_secret_key: AttributeGlobalSecretKey, blinding_factors: BlindingFactor[]): BlindedGlobalKeys | undefined;

/**
 * Creates a blinded pseudonym global secret key.
 */
export function makeBlindedPseudonymGlobalSecretKey(global_secret_key: PseudonymGlobalSecretKey, blinding_factors: BlindingFactor[]): BlindedPseudonymGlobalSecretKey | undefined;

/**
 * Generates distributed attribute global keys.
 */
export function makeDistributedAttributeGlobalKeys(n: number): any[];

/**
 * Setup a distributed system with global keys.
 */
export function makeDistributedGlobalKeys(n: number): any[];

/**
 * Generates distributed pseudonym global keys.
 */
export function makeDistributedPseudonymGlobalKeys(n: number): any[];

/**
 * Generate both pseudonym and attribute global key pairs at once.
 */
export function makeGlobalKeys(): GlobalKeyPairs;

/**
 * Generate a new pseudonym global key pair.
 */
export function makePseudonymGlobalKeys(): PseudonymGlobalKeyPair;

/**
 * Derive a pseudonym rekey factor from a secret and a context.
 */
export function makePseudonymRekeyFactor(secret: EncryptionSecret, context: string): PseudonymRekeyFactor;

/**
 * Combines pseudonym session key shares.
 */
export function makePseudonymSessionKey(blinded_global_key: BlindedPseudonymGlobalSecretKey, shares: PseudonymSessionKeyShare[]): PseudonymSessionKeyPair;

/**
 * Creates a pseudonym session key share.
 */
export function makePseudonymSessionKeyShare(rekey_factor: ScalarNonZero, blinding_factor: BlindingFactor): PseudonymSessionKeyShare;

/**
 * Generate pseudonym session keys from a global secret key, session and secret.
 */
export function makePseudonymSessionKeys(global: PseudonymGlobalSecretKey, session: EncryptionContext, secret: EncryptionSecret): PseudonymSessionKeyPair;

/**
 * Derive a pseudonymisation factor from a secret and a domain.
 */
export function makePseudonymisationFactor(secret: PseudonymizationSecret, domain: string): ReshuffleFactor;

/**
 * Creates session key shares.
 */
export function makeSessionKeyShares(pseudonym_rekey_factor: ScalarNonZero, attribute_rekey_factor: ScalarNonZero, blinding_factor: BlindingFactor): SessionKeyShares;

/**
 * Generate session keys for both pseudonyms and attributes.
 */
export function makeSessionKeys(global: GlobalSecretKeys, session: EncryptionContext, secret: EncryptionSecret): SessionKeys;

/**
 * Combines session key shares.
 */
export function makeSessionKeysDistributed(blinded_global_keys: BlindedGlobalKeys, shares: SessionKeyShares[]): SessionKeys;

/**
 * Convert a JSON number to bytes (9 bytes: 1 byte type tag + 8 bytes data).
 */
export function numberToBytes(n: number): Uint8Array;

/**
 * Encodes a byte array (up to 15 bytes) into a `Pseudonym` using PKCS#7 padding.
 */
export function pseudonymFromBytesPadded(data: Uint8Array): Pseudonym | undefined;

/**
 * Encodes a string (up to 15 bytes) into a `Pseudonym` using PKCS#7 padding.
 */
export function pseudonymFromStringPadded(text: string): Pseudonym | undefined;

/**
 * Decodes a `Pseudonym` back to the original byte array.
 */
export function pseudonymToBytesPadded(pseudonym: Pseudonym): Uint8Array | undefined;

/**
 * Decodes a `Pseudonym` back to the original string.
 */
export function pseudonymToStringPadded(pseudonym: Pseudonym): string | undefined;

/**
 * Pseudonymize an encrypted pseudonym from one domain/session to another.
 */
export function pseudonymize(encrypted: EncryptedPseudonym, pseudonymization_info: PseudonymizationInfo): EncryptedPseudonym;

/**
 * Batch pseudonymize encrypted pseudonyms.
 */
export function pseudonymizeBatch(encrypted: EncryptedPseudonym[], info: PseudonymizationInfo): EncryptedPseudonym[];

/**
 * Pseudonymize a long encrypted pseudonym from one domain/session to another.
 */
export function pseudonymizeLong(encrypted: LongEncryptedPseudonym, pseudonymization_info: PseudonymizationInfo): LongEncryptedPseudonym;

/**
 * Batch pseudonymize encrypted long pseudonyms.
 */
export function pseudonymizeLongBatch(encrypted: LongEncryptedPseudonym[], info: PseudonymizationInfo): LongEncryptedPseudonym[];

/**
 * Make a message encrypted under one key decryptable under another key.
 * If the original message was encrypted under key `Y`, the new message will be encrypted under key
 * `k * Y` such that users with secret key `k * y` can decrypt it.
 */
export function rekey(v: ElGamal, k: ScalarNonZero): ElGamal;

/**
 * A transitive and reversible n-PEP extension of [`rekey`], rekeying from one key to
 * another.
 */
export function rekey2(v: ElGamal, k_from: ScalarNonZero, k_to: ScalarNonZero): ElGamal;

/**
 * Rekey an encrypted attribute from one session to another.
 */
export function rekeyAttribute(encrypted: EncryptedAttribute, rekey_info: AttributeRekeyInfo): EncryptedAttribute;

/**
 * Batch rekey encrypted attributes.
 */
export function rekeyAttributeBatch(encrypted: EncryptedAttribute[], info: AttributeRekeyInfo): EncryptedAttribute[];

/**
 * Rekey a long encrypted attribute from one session to another.
 */
export function rekeyLongAttribute(encrypted: LongEncryptedAttribute, rekey_info: AttributeRekeyInfo): LongEncryptedAttribute;

/**
 * Batch rekey encrypted long attributes.
 */
export function rekeyLongAttributeBatch(encrypted: LongEncryptedAttribute[], info: AttributeRekeyInfo): LongEncryptedAttribute[];

/**
 * Rekey a long encrypted pseudonym from one session to another.
 */
export function rekeyLongPseudonym(encrypted: LongEncryptedPseudonym, rekey_info: PseudonymRekeyFactor): LongEncryptedPseudonym;

/**
 * Batch rekeying of long encrypted pseudonyms.
 * The order of the pseudonyms is randomly shuffled to avoid linking them.
 */
export function rekeyLongPseudonymBatch(encrypted: LongEncryptedPseudonym[], rekey_info: PseudonymRekeyFactor): LongEncryptedPseudonym[];

/**
 * Rekey an encrypted pseudonym from one session to another.
 */
export function rekeyPseudonym(encrypted: EncryptedPseudonym, rekey_info: PseudonymRekeyFactor): EncryptedPseudonym;

/**
 * Change the representation of a ciphertext without changing the contents.
 * Used to make multiple unlinkable copies of the same ciphertext (when disclosing a single
 * stored message multiple times).
 * Requires the public key `gy` that was used to encrypt the message to be provided.
 */
export function rerandomize(v: ElGamal, public_key: GroupElement, r: ScalarNonZero): ElGamal;

/**
 * Rerandomize an encrypted attribute.
 */
export function rerandomizeEncryptedAttribute(v: EncryptedAttribute, public_key: AttributeSessionPublicKey): EncryptedAttribute;

/**
 * Rerandomize an encrypted attribute using a known factor.
 */
export function rerandomizeEncryptedAttributeKnown(v: EncryptedAttribute, public_key: AttributeSessionPublicKey, r: ScalarNonZero): EncryptedAttribute;

/**
 * Rerandomize an encrypted pseudonym.
 */
export function rerandomizeEncryptedPseudonym(v: EncryptedPseudonym, public_key: PseudonymSessionPublicKey): EncryptedPseudonym;

/**
 * Rerandomize an encrypted pseudonym using a known factor.
 */
export function rerandomizeEncryptedPseudonymKnown(v: EncryptedPseudonym, public_key: PseudonymSessionPublicKey, r: ScalarNonZero): EncryptedPseudonym;

/**
 * Rerandomize a long encrypted attribute.
 */
export function rerandomizeLongEncryptedAttribute(v: LongEncryptedAttribute, public_key: AttributeSessionPublicKey): LongEncryptedAttribute;

/**
 * Rerandomize a long encrypted attribute using a known factor.
 */
export function rerandomizeLongEncryptedAttributeKnown(v: LongEncryptedAttribute, public_key: AttributeSessionPublicKey, r: ScalarNonZero): LongEncryptedAttribute;

/**
 * Rerandomize a long encrypted pseudonym.
 */
export function rerandomizeLongEncryptedPseudonym(v: LongEncryptedPseudonym, public_key: PseudonymSessionPublicKey): LongEncryptedPseudonym;

/**
 * Rerandomize a long encrypted pseudonym using a known factor.
 */
export function rerandomizeLongEncryptedPseudonymKnown(v: LongEncryptedPseudonym, public_key: PseudonymSessionPublicKey, r: ScalarNonZero): LongEncryptedPseudonym;

/**
 * Change the contents of a ciphertext with factor `s`, i.e. message `M` becomes `s * M`.
 * Can be used to blindly and pseudo-randomly pseudonymize identifiers.
 */
export function reshuffle(v: ElGamal, s: ScalarNonZero): ElGamal;

/**
 * A transitive and reversible n-PEP extension of [`reshuffle`], reshuffling from one pseudonym to
 * another.
 */
export function reshuffle2(v: ElGamal, n_from: ScalarNonZero, n_to: ScalarNonZero): ElGamal;

/**
 * Combination of [`rerandomize`], [`reshuffle`] and [`rekey`] (more efficient and secure than
 * applying them separately).
 * Requires the public key `gy` that was used to encrypt the message to be provided.
 */
export function rrsk(v: ElGamal, public_key: GroupElement, r: ScalarNonZero, s: ScalarNonZero, k: ScalarNonZero): ElGamal;

/**
 * A transitive and reversible n-PEP extension of [`rrsk`].
 * Requires the public key `gy` that was used to encrypt the message to be provided.
 */
export function rrsk2(v: ElGamal, public_key: GroupElement, r: ScalarNonZero, s_from: ScalarNonZero, s_to: ScalarNonZero, k_from: ScalarNonZero, k_to: ScalarNonZero): ElGamal;

/**
 * Combination of  [`reshuffle`] and [`rekey`] (more efficient and secure than applying them
 * separately).
 */
export function rsk(v: ElGamal, s: ScalarNonZero, k: ScalarNonZero): ElGamal;

/**
 * A transitive and reversible n-PEP extension of [`rsk`].
 */
export function rsk2(v: ElGamal, s_from: ScalarNonZero, s_to: ScalarNonZero, k_from: ScalarNonZero, k_to: ScalarNonZero): ElGamal;

/**
 * Transcrypt an encrypted attribute from one session to another.
 */
export function transcryptAttribute(encrypted: EncryptedAttribute, transcryption_info: TranscryptionInfo): EncryptedAttribute;

/**
 * Batch transcrypt encrypted attributes.
 */
export function transcryptAttributeBatch(encrypted: EncryptedAttribute[], info: TranscryptionInfo): EncryptedAttribute[];

/**
 * Transcrypt an encrypted PEPJSONValue from one context to another.
 */
export function transcryptJSON(encrypted: EncryptedPEPJSONValue, transcryption_info: TranscryptionInfo): EncryptedPEPJSONValue;

/**
 * Batch transcrypt encrypted JSON values.
 */
export function transcryptJSONBatch(encrypted: EncryptedPEPJSONValue[], info: TranscryptionInfo): EncryptedPEPJSONValue[];

/**
 * Transcrypt a batch of EncryptedPEPJSONValues using a TranscryptionInfo object.
 *
 * # Arguments
 *
 * * `values` - Array of EncryptedPEPJSONValue objects
 * * `transcryption_info` - TranscryptionInfo containing all transcryption parameters
 *
 * # Returns
 *
 * A shuffled array of transcrypted EncryptedPEPJSONValue objects
 *
 * # Errors
 *
 * Returns an error if the values don't all have the same structure
 */
export function transcryptJsonBatch(values: EncryptedPEPJSONValue[], transcryption_info: TranscryptionInfo): EncryptedPEPJSONValue[];

/**
 * Batch transcryption of long encrypted data.
 * Each item contains a list of long encrypted pseudonyms and a list of long encrypted attributes.
 * The order of the items is randomly shuffled to avoid linking them.
 *
 * # Errors
 *
 * Throws an error if the encrypted data do not all have the same structure.
 */
export function transcryptLongBatch(encrypted: LongEncryptedRecord[], transcryption_info: TranscryptionInfo): LongEncryptedRecord[];

/**
 * Transcrypt an encrypted LongRecord from one context to another.
 */
export function transcryptLongRecord(encrypted: LongRecordEncrypted, transcryption_info: TranscryptionInfo): LongRecordEncrypted;

/**
 * Batch transcrypt encrypted long records.
 */
export function transcryptLongRecordBatch(encrypted: LongRecordEncrypted[], info: TranscryptionInfo): LongRecordEncrypted[];

/**
 * Transcrypt an encrypted pseudonym from one domain/session to another.
 */
export function transcryptPseudonym(encrypted: EncryptedPseudonym, transcryption_info: TranscryptionInfo): EncryptedPseudonym;

/**
 * Batch transcrypt encrypted pseudonyms.
 */
export function transcryptPseudonymBatch(encrypted: EncryptedPseudonym[], info: TranscryptionInfo): EncryptedPseudonym[];

/**
 * Transcrypt an encrypted Record from one context to another.
 */
export function transcryptRecord(encrypted: RecordEncrypted, transcryption_info: TranscryptionInfo): RecordEncrypted;

/**
 * Batch transcrypt encrypted records.
 */
export function transcryptRecordBatch(encrypted: RecordEncrypted[], info: TranscryptionInfo): RecordEncrypted[];

/**
 * Unifies multiple JSON structures by taking the maximum block count for each field.
 *
 * This function is useful for batch operations where you need to normalize multiple
 * values to have the same structure. It recursively unifies nested structures,
 * taking the maximum block count for strings and pseudonyms.
 *
 * # Arguments
 *
 * * `structures` - An array of JSONStructure objects to unify
 *
 * # Returns
 *
 * A unified JSONStructure where string and pseudonym fields have maximum block counts
 *
 * # Errors
 *
 * Returns an error if the structures are incompatible (different types, array lengths, or object fields)
 */
export function unifyStructures(structures: JSONStructure[]): JSONStructure;

/**
 * Updates an attribute session key.
 */
export function updateAttributeSessionKey(session_secret_key: AttributeSessionSecretKey, old_share: AttributeSessionKeyShare, new_share: AttributeSessionKeyShare): AttributeSessionKeyPair;

/**
 * Updates a pseudonym session key.
 */
export function updatePseudonymSessionKey(session_secret_key: PseudonymSessionSecretKey, old_share: PseudonymSessionKeyShare, new_share: PseudonymSessionKeyShare): PseudonymSessionKeyPair;

/**
 * Updates session keys.
 */
export function updateSessionKeys(session_keys: SessionKeys, old_shares: SessionKeyShares, new_shares: SessionKeyShares): SessionKeys;

export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;

export interface InitOutput {
    readonly memory: WebAssembly.Memory;
    readonly __wbg_client_free: (a: number, b: number) => void;
    readonly client_decryptData: (a: number, b: number) => number;
    readonly client_decryptDataBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly client_decryptJSON: (a: number, b: number) => number;
    readonly client_decryptJSONBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly client_decryptLongData: (a: number, b: number) => number;
    readonly client_decryptLongDataBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly client_decryptLongPseudonym: (a: number, b: number) => number;
    readonly client_decryptLongPseudonymBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly client_decryptLongRecord: (a: number, b: number) => number;
    readonly client_decryptPseudonym: (a: number, b: number) => number;
    readonly client_decryptPseudonymBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly client_decryptRecord: (a: number, b: number) => number;
    readonly client_dump: (a: number) => number;
    readonly client_encryptData: (a: number, b: number) => number;
    readonly client_encryptDataBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly client_encryptJSON: (a: number, b: number) => number;
    readonly client_encryptJSONBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly client_encryptLongData: (a: number, b: number) => number;
    readonly client_encryptLongDataBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly client_encryptLongPseudonym: (a: number, b: number) => number;
    readonly client_encryptLongPseudonymBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly client_encryptLongRecord: (a: number, b: number) => number;
    readonly client_encryptPseudonym: (a: number, b: number) => number;
    readonly client_encryptPseudonymBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly client_encryptRecord: (a: number, b: number) => number;
    readonly client_new: (a: number, b: number, c: number) => number;
    readonly client_restore: (a: number) => number;
    readonly client_updateAttributeSessionSecretKey: (a: number, b: number, c: number) => void;
    readonly client_updatePseudonymSessionSecretKey: (a: number, b: number, c: number) => void;
    readonly client_updateSessionSecretKeys: (a: number, b: number, c: number) => void;
    readonly decryptAttribute: (a: number, b: number) => number;
    readonly decryptJSON: (a: number, b: number) => number;
    readonly decryptLongAttribute: (a: number, b: number) => number;
    readonly decryptLongPseudonym: (a: number, b: number) => number;
    readonly decryptLongRecord: (a: number, b: number) => number;
    readonly decryptPseudonym: (a: number, b: number) => number;
    readonly decryptRecord: (a: number, b: number) => number;
    readonly encryptAttribute: (a: number, b: number) => number;
    readonly encryptAttributeGlobal: (a: number, b: number) => number;
    readonly encryptJSON: (a: number, b: number) => number;
    readonly encryptLongAttribute: (a: number, b: number) => number;
    readonly encryptLongAttributeGlobal: (a: number, b: number) => number;
    readonly encryptLongPseudonym: (a: number, b: number) => number;
    readonly encryptLongPseudonymGlobal: (a: number, b: number) => number;
    readonly encryptLongRecord: (a: number, b: number) => number;
    readonly encryptPseudonym: (a: number, b: number) => number;
    readonly encryptPseudonymGlobal: (a: number, b: number) => number;
    readonly encryptRecord: (a: number, b: number) => number;
    readonly makeBlindedAttributeGlobalSecretKey: (a: number, b: number, c: number) => number;
    readonly makeBlindedPseudonymGlobalSecretKey: (a: number, b: number, c: number) => number;
    readonly makeDistributedAttributeGlobalKeys: (a: number) => [number, number];
    readonly makeDistributedGlobalKeys: (a: number) => [number, number];
    readonly makeDistributedPseudonymGlobalKeys: (a: number) => [number, number];
    readonly transcryptJSON: (a: number, b: number) => number;
    readonly transcryptLongRecord: (a: number, b: number) => number;
    readonly transcryptRecord: (a: number, b: number) => number;
    readonly __wbg_attributerekeyinfo_free: (a: number, b: number) => void;
    readonly __wbg_elgamal_free: (a: number, b: number) => void;
    readonly __wbg_encryptedpepjsonvalue_free: (a: number, b: number) => void;
    readonly __wbg_encryptioncontext_free: (a: number, b: number) => void;
    readonly __wbg_encryptionsecret_free: (a: number, b: number) => void;
    readonly __wbg_jsonstructure_free: (a: number, b: number) => void;
    readonly __wbg_pepjsonbuilder_free: (a: number, b: number) => void;
    readonly __wbg_pepjsonvalue_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymizationdomain_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymizationinfo_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymizationsecret_free: (a: number, b: number) => void;
    readonly __wbg_transcryptioninfo_free: (a: number, b: number) => void;
    readonly attributerekeyinfo_new: (a: number, b: number, c: number) => number;
    readonly attributerekeyinfo_reverse: (a: number) => number;
    readonly boolToByte: (a: number) => number;
    readonly byteToBool: (a: number) => [number, number, number];
    readonly bytesToNumber: (a: number, b: number) => [number, number, number];
    readonly decrypt: (a: number, b: number) => number;
    readonly decryptJson: (a: number, b: number) => [number, number, number];
    readonly decryptJsonBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly elgamal_fromBase64: (a: number, b: number) => number;
    readonly elgamal_fromBytes: (a: number, b: number) => number;
    readonly elgamal_toBase64: (a: number) => [number, number];
    readonly elgamal_toBytes: (a: number) => [number, number];
    readonly encrypt: (a: number, b: number) => number;
    readonly encryptJson: (a: number, b: number) => number;
    readonly encryptJsonBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly encryptedpepjsonvalue_fromJSON: (a: number, b: number) => [number, number, number];
    readonly encryptedpepjsonvalue_structure: (a: number) => number;
    readonly encryptedpepjsonvalue_toJSON: (a: number) => [number, number, number, number];
    readonly encryptedpepjsonvalue_transcrypt: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
    readonly encryptioncontext_global: () => number;
    readonly encryptioncontext_new: (a: number, b: number) => number;
    readonly encryptionsecret_from: (a: number, b: number) => number;
    readonly jsonstructure_equals: (a: number, b: number) => number;
    readonly jsonstructure_toJSON: (a: number) => [number, number, number, number];
    readonly jsonstructure_toString: (a: number) => [number, number];
    readonly makeAttributeRekeyFactor: (a: number, b: number, c: number) => number;
    readonly makePseudonymRekeyFactor: (a: number, b: number, c: number) => number;
    readonly makePseudonymisationFactor: (a: number, b: number, c: number) => number;
    readonly numberToBytes: (a: number) => [number, number];
    readonly pepjsonbuilder_attribute: (a: number, b: number, c: number, d: any) => [number, number, number];
    readonly pepjsonbuilder_build: (a: number) => number;
    readonly pepjsonbuilder_fromJson: (a: any, b: number, c: number) => [number, number, number];
    readonly pepjsonbuilder_new: () => number;
    readonly pepjsonbuilder_pseudonym: (a: number, b: number, c: number, d: number, e: number) => number;
    readonly pepjsonvalue_fromValue: (a: any) => [number, number, number];
    readonly pepjsonvalue_padTo: (a: number, b: number) => [number, number, number];
    readonly pepjsonvalue_structure: (a: number) => number;
    readonly pepjsonvalue_toJson: (a: number) => [number, number, number];
    readonly pseudonymizationinfo_k: (a: number) => number;
    readonly pseudonymizationinfo_new: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
    readonly pseudonymizationinfo_reverse: (a: number) => number;
    readonly transcryptJsonBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly transcryptioninfo_attribute: (a: number) => number;
    readonly transcryptioninfo_new: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
    readonly transcryptioninfo_pseudonym: (a: number) => number;
    readonly transcryptioninfo_reverse: (a: number) => number;
    readonly unifyStructures: (a: number, b: number) => [number, number, number];
    readonly pseudonymizationdomain_new: (a: number, b: number) => number;
    readonly encryptionsecret_new: (a: number, b: number) => number;
    readonly pseudonymizationsecret_from: (a: number, b: number) => number;
    readonly pseudonymizationsecret_new: (a: number, b: number) => number;
    readonly __wbg_blindedattributeglobalsecretkey_free: (a: number, b: number) => void;
    readonly __wbg_blindedglobalkeys_free: (a: number, b: number) => void;
    readonly __wbg_blindedpseudonymglobalsecretkey_free: (a: number, b: number) => void;
    readonly __wbg_blindingfactor_free: (a: number, b: number) => void;
    readonly blindedattributeglobalsecretkey_fromBytes: (a: number, b: number) => number;
    readonly blindedattributeglobalsecretkey_fromHex: (a: number, b: number) => number;
    readonly blindedattributeglobalsecretkey_new: (a: number) => number;
    readonly blindedattributeglobalsecretkey_toBytes: (a: number) => [number, number];
    readonly blindedattributeglobalsecretkey_toHex: (a: number) => [number, number];
    readonly blindedglobalkeys_attribute: (a: number) => number;
    readonly blindedglobalkeys_new: (a: number, b: number) => number;
    readonly blindedglobalkeys_pseudonym: (a: number) => number;
    readonly blindedpseudonymglobalsecretkey_toBytes: (a: number) => [number, number];
    readonly blindingfactor_random: () => number;
    readonly blindingfactor_toBytes: (a: number) => [number, number];
    readonly makeBlindedGlobalKeys: (a: number, b: number, c: number, d: number) => number;
    readonly blindedpseudonymglobalsecretkey_toHex: (a: number) => [number, number];
    readonly blindingfactor_toHex: (a: number) => [number, number];
    readonly blindedpseudonymglobalsecretkey_fromHex: (a: number, b: number) => number;
    readonly blindingfactor_fromHex: (a: number, b: number) => number;
    readonly blindingfactor_clone: (a: number) => number;
    readonly blindedpseudonymglobalsecretkey_new: (a: number) => number;
    readonly blindingfactor_new: (a: number) => number;
    readonly blindedpseudonymglobalsecretkey_fromBytes: (a: number, b: number) => number;
    readonly blindingfactor_fromBytes: (a: number, b: number) => number;
    readonly __wbg_groupelement_free: (a: number, b: number) => void;
    readonly __wbg_longrecord_free: (a: number, b: number) => void;
    readonly __wbg_longrecordencrypted_free: (a: number, b: number) => void;
    readonly __wbg_longrecordstructure_free: (a: number, b: number) => void;
    readonly __wbg_record_free: (a: number, b: number) => void;
    readonly __wbg_recordencrypted_free: (a: number, b: number) => void;
    readonly attributeFromBytesPadded: (a: number, b: number) => number;
    readonly attributeFromStringPadded: (a: number, b: number) => number;
    readonly attributeToBytesPadded: (a: number) => [number, number];
    readonly attributeToStringPadded: (a: number) => [number, number];
    readonly groupelement_G: () => number;
    readonly groupelement_add: (a: number, b: number) => number;
    readonly groupelement_fromBytes: (a: number, b: number) => number;
    readonly groupelement_fromHash: (a: number, b: number) => number;
    readonly groupelement_fromHex: (a: number, b: number) => number;
    readonly groupelement_identity: () => number;
    readonly groupelement_mul: (a: number, b: number) => number;
    readonly groupelement_random: () => number;
    readonly groupelement_sub: (a: number, b: number) => number;
    readonly groupelement_toBytes: (a: number) => [number, number];
    readonly groupelement_toHex: (a: number) => [number, number];
    readonly longrecord_attributes: (a: number) => [number, number];
    readonly longrecord_new: (a: number, b: number, c: number, d: number) => number;
    readonly longrecord_padTo: (a: number, b: number) => [number, number, number];
    readonly longrecord_pseudonyms: (a: number) => [number, number];
    readonly longrecord_structure: (a: number) => number;
    readonly longrecordencrypted_attributes: (a: number) => [number, number];
    readonly longrecordencrypted_new: (a: number, b: number, c: number, d: number) => number;
    readonly longrecordencrypted_pseudonyms: (a: number) => [number, number];
    readonly longrecordstructure_attributeBlocks: (a: number) => [number, number];
    readonly longrecordstructure_new: (a: number, b: number, c: number, d: number) => number;
    readonly longrecordstructure_pseudonymBlocks: (a: number) => [number, number];
    readonly pseudonymToBytesPadded: (a: number) => [number, number];
    readonly pseudonymToStringPadded: (a: number) => [number, number];
    readonly record_attributes: (a: number) => [number, number];
    readonly record_new: (a: number, b: number, c: number, d: number) => number;
    readonly record_pseudonyms: (a: number) => [number, number];
    readonly recordencrypted_attributes: (a: number) => [number, number];
    readonly recordencrypted_new: (a: number, b: number, c: number, d: number) => number;
    readonly recordencrypted_pseudonyms: (a: number) => [number, number];
    readonly pseudonymFromStringPadded: (a: number, b: number) => number;
    readonly groupelement_generator: () => number;
    readonly pseudonymFromBytesPadded: (a: number, b: number) => number;
    readonly __wbg_longattribute_free: (a: number, b: number) => void;
    readonly __wbg_longencryptedattribute_free: (a: number, b: number) => void;
    readonly __wbg_longencryptedpseudonym_free: (a: number, b: number) => void;
    readonly __wbg_longencryptedrecord_free: (a: number, b: number) => void;
    readonly __wbg_longpseudonym_free: (a: number, b: number) => void;
    readonly decryptAttributeBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly decryptLongAttributeBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly decryptLongPseudonymBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly decryptPseudonymBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly encryptAttributeBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly encryptLongAttributeBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly encryptLongPseudonymBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly encryptPseudonymBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly longattribute_attributes: (a: number) => [number, number];
    readonly longattribute_clone: (a: number) => number;
    readonly longattribute_fromBytesPadded: (a: number, b: number) => number;
    readonly longattribute_fromStringPadded: (a: number, b: number) => number;
    readonly longattribute_length: (a: number) => number;
    readonly longattribute_new: (a: number, b: number) => number;
    readonly longattribute_padTo: (a: number, b: number) => [number, number, number];
    readonly longattribute_toBytesPadded: (a: number) => [number, number, number, number];
    readonly longattribute_toStringPadded: (a: number) => [number, number, number, number];
    readonly longencryptedattribute_clone: (a: number) => number;
    readonly longencryptedattribute_deserialize: (a: number, b: number) => [number, number, number];
    readonly longencryptedattribute_encryptedAttributes: (a: number) => [number, number];
    readonly longencryptedattribute_length: (a: number) => number;
    readonly longencryptedattribute_new: (a: number, b: number) => number;
    readonly longencryptedattribute_serialize: (a: number) => [number, number];
    readonly longencryptedpseudonym_clone: (a: number) => number;
    readonly longencryptedpseudonym_deserialize: (a: number, b: number) => [number, number, number];
    readonly longencryptedpseudonym_encryptedPseudonyms: (a: number) => [number, number];
    readonly longencryptedpseudonym_new: (a: number, b: number) => number;
    readonly longencryptedpseudonym_serialize: (a: number) => [number, number];
    readonly longencryptedrecord_attributes: (a: number) => [number, number];
    readonly longencryptedrecord_new: (a: number, b: number, c: number, d: number) => number;
    readonly longencryptedrecord_pseudonyms: (a: number) => [number, number];
    readonly longpseudonym_clone: (a: number) => number;
    readonly longpseudonym_fromBytesPadded: (a: number, b: number) => number;
    readonly longpseudonym_fromStringPadded: (a: number, b: number) => number;
    readonly longpseudonym_new: (a: number, b: number) => number;
    readonly longpseudonym_padTo: (a: number, b: number) => [number, number, number];
    readonly longpseudonym_pseudonyms: (a: number) => [number, number];
    readonly longpseudonym_toBytesPadded: (a: number) => [number, number, number, number];
    readonly longpseudonym_toStringPadded: (a: number) => [number, number, number, number];
    readonly rekeyLongPseudonymBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly transcryptLongBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly longencryptedpseudonym_length: (a: number) => number;
    readonly longpseudonym_length: (a: number) => number;
    readonly __wbg_attributeglobalkeypair_free: (a: number, b: number) => void;
    readonly __wbg_attributeglobalpublickey_free: (a: number, b: number) => void;
    readonly __wbg_attributeglobalsecretkey_free: (a: number, b: number) => void;
    readonly __wbg_attributesessionkeypair_free: (a: number, b: number) => void;
    readonly __wbg_attributesessionkeys_free: (a: number, b: number) => void;
    readonly __wbg_attributesessionkeyshare_free: (a: number, b: number) => void;
    readonly __wbg_attributesessionpublickey_free: (a: number, b: number) => void;
    readonly __wbg_attributesessionsecretkey_free: (a: number, b: number) => void;
    readonly __wbg_get_attributeglobalpublickey_0: (a: number) => number;
    readonly __wbg_get_attributeglobalsecretkey_0: (a: number) => number;
    readonly __wbg_globalkeypairs_free: (a: number, b: number) => void;
    readonly __wbg_globalpublickeys_free: (a: number, b: number) => void;
    readonly __wbg_globalsecretkeys_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymglobalkeypair_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymglobalpublickey_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymglobalsecretkey_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymsessionkeypair_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymsessionkeys_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymsessionkeyshare_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymsessionpublickey_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymsessionsecretkey_free: (a: number, b: number) => void;
    readonly __wbg_sessionkeys_free: (a: number, b: number) => void;
    readonly __wbg_sessionkeyshares_free: (a: number, b: number) => void;
    readonly __wbg_set_attributeglobalpublickey_0: (a: number, b: number) => void;
    readonly __wbg_set_attributeglobalsecretkey_0: (a: number, b: number) => void;
    readonly attributeglobalkeypair_new: (a: number, b: number) => number;
    readonly attributeglobalkeypair_public: (a: number) => number;
    readonly attributeglobalkeypair_secret: (a: number) => number;
    readonly attributeglobalpublickey_fromBytes: (a: number, b: number) => number;
    readonly attributeglobalpublickey_fromHex: (a: number, b: number) => number;
    readonly attributeglobalpublickey_new: (a: number) => number;
    readonly attributeglobalpublickey_toBytes: (a: number) => [number, number];
    readonly attributeglobalpublickey_toHex: (a: number) => [number, number];
    readonly attributesessionkeyshare_fromBytes: (a: number, b: number) => number;
    readonly attributesessionkeyshare_fromHex: (a: number, b: number) => number;
    readonly attributesessionkeyshare_new: (a: number) => number;
    readonly attributesessionkeyshare_toBytes: (a: number) => [number, number];
    readonly attributesessionkeyshare_toHex: (a: number) => [number, number];
    readonly globalkeypairs_new: (a: number, b: number) => number;
    readonly globalkeypairs_public: (a: number) => number;
    readonly globalkeypairs_secret: (a: number) => number;
    readonly globalpublickeys_attribute: (a: number) => number;
    readonly globalpublickeys_new: (a: number, b: number) => number;
    readonly globalsecretkeys_attribute: (a: number) => number;
    readonly globalsecretkeys_new: (a: number, b: number) => number;
    readonly globalsecretkeys_pseudonym: (a: number) => number;
    readonly makeAttributeGlobalKeys: () => number;
    readonly makeAttributeSessionKey: (a: number, b: number, c: number) => number;
    readonly makeAttributeSessionKeyShare: (a: number, b: number) => number;
    readonly makeAttributeSessionKeys: (a: number, b: number, c: number) => number;
    readonly makeGlobalKeys: () => number;
    readonly makePseudonymSessionKey: (a: number, b: number, c: number) => number;
    readonly makePseudonymSessionKeys: (a: number, b: number, c: number) => number;
    readonly makeSessionKeyShares: (a: number, b: number, c: number) => number;
    readonly makeSessionKeys: (a: number, b: number, c: number) => number;
    readonly makeSessionKeysDistributed: (a: number, b: number, c: number) => number;
    readonly pseudonymglobalpublickey_toBytes: (a: number) => [number, number];
    readonly pseudonymglobalpublickey_toHex: (a: number) => [number, number];
    readonly pseudonymsessionkeyshare_toBytes: (a: number) => [number, number];
    readonly rekey: (a: number, b: number) => number;
    readonly rekey2: (a: number, b: number, c: number) => number;
    readonly rerandomize: (a: number, b: number, c: number) => number;
    readonly reshuffle: (a: number, b: number) => number;
    readonly reshuffle2: (a: number, b: number, c: number) => number;
    readonly rrsk: (a: number, b: number, c: number, d: number, e: number) => number;
    readonly rrsk2: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
    readonly rsk: (a: number, b: number, c: number) => number;
    readonly rsk2: (a: number, b: number, c: number, d: number, e: number) => number;
    readonly sessionkeys_attribute: (a: number) => number;
    readonly sessionkeys_new: (a: number, b: number) => number;
    readonly sessionkeys_pseudonym: (a: number) => number;
    readonly sessionkeyshares_new: (a: number, b: number) => number;
    readonly updateAttributeSessionKey: (a: number, b: number, c: number) => number;
    readonly updatePseudonymSessionKey: (a: number, b: number, c: number) => number;
    readonly updateSessionKeys: (a: number, b: number, c: number) => number;
    readonly attributesessionkeys_new: (a: number, b: number) => number;
    readonly pseudonymglobalkeypair_new: (a: number, b: number) => number;
    readonly pseudonymsessionkeys_new: (a: number, b: number) => number;
    readonly __wbg_get_attributesessionpublickey_0: (a: number) => number;
    readonly __wbg_get_attributesessionsecretkey_0: (a: number) => number;
    readonly __wbg_get_pseudonymglobalpublickey_0: (a: number) => number;
    readonly __wbg_get_pseudonymglobalsecretkey_0: (a: number) => number;
    readonly __wbg_get_pseudonymsessionpublickey_0: (a: number) => number;
    readonly __wbg_get_pseudonymsessionsecretkey_0: (a: number) => number;
    readonly makePseudonymGlobalKeys: () => number;
    readonly pseudonymsessionkeyshare_toHex: (a: number) => [number, number];
    readonly makePseudonymSessionKeyShare: (a: number, b: number) => number;
    readonly pseudonymsessionkeyshare_fromHex: (a: number, b: number) => number;
    readonly attributesessionkeypair_public: (a: number) => number;
    readonly attributesessionkeypair_secret: (a: number) => number;
    readonly attributesessionkeys_public: (a: number) => number;
    readonly attributesessionkeys_secret: (a: number) => number;
    readonly globalpublickeys_pseudonym: (a: number) => number;
    readonly pseudonymglobalkeypair_public: (a: number) => number;
    readonly pseudonymglobalkeypair_secret: (a: number) => number;
    readonly pseudonymsessionkeypair_public: (a: number) => number;
    readonly pseudonymsessionkeypair_secret: (a: number) => number;
    readonly pseudonymsessionkeys_public: (a: number) => number;
    readonly pseudonymsessionkeys_secret: (a: number) => number;
    readonly sessionkeyshares_attribute: (a: number) => number;
    readonly sessionkeyshares_pseudonym: (a: number) => number;
    readonly __wbg_set_attributesessionpublickey_0: (a: number, b: number) => void;
    readonly __wbg_set_attributesessionsecretkey_0: (a: number, b: number) => void;
    readonly __wbg_set_pseudonymglobalpublickey_0: (a: number, b: number) => void;
    readonly __wbg_set_pseudonymglobalsecretkey_0: (a: number, b: number) => void;
    readonly __wbg_set_pseudonymsessionpublickey_0: (a: number, b: number) => void;
    readonly __wbg_set_pseudonymsessionsecretkey_0: (a: number, b: number) => void;
    readonly pseudonymglobalpublickey_fromBytes: (a: number, b: number) => number;
    readonly pseudonymglobalpublickey_fromHex: (a: number, b: number) => number;
    readonly pseudonymglobalpublickey_new: (a: number) => number;
    readonly pseudonymsessionkeyshare_new: (a: number) => number;
    readonly pseudonymsessionkeyshare_fromBytes: (a: number, b: number) => number;
    readonly __wbg_attributerekeyfactor_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymrekeyfactor_free: (a: number, b: number) => void;
    readonly __wbg_pseudonymrskfactors_free: (a: number, b: number) => void;
    readonly __wbg_rerandomizefactor_free: (a: number, b: number) => void;
    readonly __wbg_reshufflefactor_free: (a: number, b: number) => void;
    readonly __wbg_scalarcanbezero_free: (a: number, b: number) => void;
    readonly __wbg_scalarnonzero_free: (a: number, b: number) => void;
    readonly __wbg_transcryptor_free: (a: number, b: number) => void;
    readonly attributerekeyfactor_new: (a: number) => number;
    readonly pseudonymize: (a: number, b: number) => number;
    readonly pseudonymizeBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly pseudonymizeLong: (a: number, b: number) => number;
    readonly pseudonymizeLongBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly pseudonymrskfactors_k: (a: number) => number;
    readonly pseudonymrskfactors_new: (a: number, b: number) => number;
    readonly pseudonymrskfactors_set_k: (a: number, b: number) => void;
    readonly pseudonymrskfactors_set_s: (a: number, b: number) => void;
    readonly rekeyAttribute: (a: number, b: number) => number;
    readonly rekeyAttributeBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly rekeyLongAttribute: (a: number, b: number) => number;
    readonly rekeyLongAttributeBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly rekeyLongPseudonym: (a: number, b: number) => number;
    readonly rekeyPseudonym: (a: number, b: number) => number;
    readonly rerandomizeEncryptedAttribute: (a: number, b: number) => number;
    readonly rerandomizeEncryptedAttributeKnown: (a: number, b: number, c: number) => number;
    readonly rerandomizeEncryptedPseudonym: (a: number, b: number) => number;
    readonly rerandomizeEncryptedPseudonymKnown: (a: number, b: number, c: number) => number;
    readonly rerandomizeLongEncryptedAttribute: (a: number, b: number) => number;
    readonly rerandomizeLongEncryptedAttributeKnown: (a: number, b: number, c: number) => number;
    readonly rerandomizeLongEncryptedPseudonym: (a: number, b: number) => number;
    readonly rerandomizeLongEncryptedPseudonymKnown: (a: number, b: number, c: number) => number;
    readonly scalarcanbezero_add: (a: number, b: number) => number;
    readonly scalarcanbezero_fromBytes: (a: number, b: number) => number;
    readonly scalarcanbezero_fromHex: (a: number, b: number) => number;
    readonly scalarcanbezero_isZero: (a: number) => number;
    readonly scalarcanbezero_one: () => number;
    readonly scalarcanbezero_random: () => number;
    readonly scalarcanbezero_sub: (a: number, b: number) => number;
    readonly scalarcanbezero_toBytes: (a: number) => [number, number];
    readonly scalarcanbezero_toHex: (a: number) => [number, number];
    readonly scalarcanbezero_toNonZero: (a: number) => number;
    readonly scalarcanbezero_zero: () => number;
    readonly scalarnonzero_fromBytes: (a: number, b: number) => number;
    readonly scalarnonzero_fromHash: (a: number, b: number) => number;
    readonly scalarnonzero_fromHex: (a: number, b: number) => number;
    readonly scalarnonzero_invert: (a: number) => number;
    readonly scalarnonzero_mul: (a: number, b: number) => number;
    readonly scalarnonzero_random: () => number;
    readonly scalarnonzero_toBytes: (a: number) => [number, number];
    readonly scalarnonzero_toCanBeZero: (a: number) => number;
    readonly scalarnonzero_toHex: (a: number) => [number, number];
    readonly transcryptAttribute: (a: number, b: number) => number;
    readonly transcryptAttributeBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly transcryptJSONBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly transcryptLongRecordBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly transcryptPseudonym: (a: number, b: number) => number;
    readonly transcryptPseudonymBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly transcryptRecordBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly transcryptor_attributeRekeyInfo: (a: number, b: number, c: number) => number;
    readonly transcryptor_new: (a: number, b: number, c: number, d: number) => number;
    readonly transcryptor_pseudonymRekeyInfo: (a: number, b: number, c: number) => number;
    readonly transcryptor_pseudonymizationInfo: (a: number, b: number, c: number, d: number, e: number) => number;
    readonly transcryptor_pseudonymize: (a: number, b: number, c: number) => number;
    readonly transcryptor_pseudonymizeBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly transcryptor_pseudonymizeLong: (a: number, b: number, c: number) => number;
    readonly transcryptor_pseudonymizeLongBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly transcryptor_rekey: (a: number, b: number, c: number) => number;
    readonly transcryptor_rekeyBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly transcryptor_rekeyLong: (a: number, b: number, c: number) => number;
    readonly transcryptor_rekeyLongBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly transcryptor_transcryptJSON: (a: number, b: number, c: number) => number;
    readonly transcryptor_transcryptJSONBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly transcryptor_transcryptLongRecord: (a: number, b: number, c: number) => number;
    readonly transcryptor_transcryptLongRecordBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly transcryptor_transcryptRecord: (a: number, b: number, c: number) => number;
    readonly transcryptor_transcryptRecordBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly transcryptor_transcryptionInfo: (a: number, b: number, c: number, d: number, e: number) => number;
    readonly attributerekeyfactor_scalar: (a: number) => number;
    readonly pseudonymrekeyfactor_new: (a: number) => number;
    readonly pseudonymrekeyfactor_scalar: (a: number) => number;
    readonly pseudonymrskfactors_s: (a: number) => number;
    readonly rerandomizefactor_new: (a: number) => number;
    readonly rerandomizefactor_scalar: (a: number) => number;
    readonly reshufflefactor_new: (a: number) => number;
    readonly reshufflefactor_scalar: (a: number) => number;
    readonly scalarnonzero_one: () => number;
    readonly __wbg_attribute_free: (a: number, b: number) => void;
    readonly __wbg_distributedtranscryptor_free: (a: number, b: number) => void;
    readonly __wbg_encryptedattribute_free: (a: number, b: number) => void;
    readonly __wbg_encryptedpseudonym_free: (a: number, b: number) => void;
    readonly __wbg_offlinepepclient_free: (a: number, b: number) => void;
    readonly __wbg_pseudonym_free: (a: number, b: number) => void;
    readonly attribute_fromBytes: (a: number, b: number) => number;
    readonly attribute_fromBytesPadded: (a: number, b: number) => number;
    readonly attribute_fromHash: (a: number, b: number) => number;
    readonly attribute_fromHex: (a: number, b: number) => number;
    readonly attribute_fromLizard: (a: number, b: number) => number;
    readonly attribute_fromStringPadded: (a: number, b: number) => number;
    readonly attribute_new: (a: number) => number;
    readonly attribute_random: () => number;
    readonly attribute_toBytes: (a: number) => [number, number];
    readonly attribute_toBytesPadded: (a: number) => [number, number];
    readonly attribute_toHex: (a: number) => [number, number];
    readonly attribute_toLizard: (a: number) => [number, number];
    readonly attribute_toPoint: (a: number) => number;
    readonly attribute_toStringPadded: (a: number) => [number, number];
    readonly distributedtranscryptor_attributeRekeyInfo: (a: number, b: number, c: number) => number;
    readonly distributedtranscryptor_attributeSessionKeyShare: (a: number, b: number) => number;
    readonly distributedtranscryptor_new: (a: number, b: number, c: number, d: number, e: number) => number;
    readonly distributedtranscryptor_pseudonymRekeyInfo: (a: number, b: number, c: number) => number;
    readonly distributedtranscryptor_pseudonymSessionKeyShare: (a: number, b: number) => number;
    readonly distributedtranscryptor_pseudonymizationInfo: (a: number, b: number, c: number, d: number, e: number) => number;
    readonly distributedtranscryptor_pseudonymize: (a: number, b: number, c: number) => number;
    readonly distributedtranscryptor_pseudonymizeBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly distributedtranscryptor_pseudonymizeLong: (a: number, b: number, c: number) => number;
    readonly distributedtranscryptor_pseudonymizeLongBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly distributedtranscryptor_rekey: (a: number, b: number, c: number) => number;
    readonly distributedtranscryptor_rekeyBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly distributedtranscryptor_rekeyLong: (a: number, b: number, c: number) => number;
    readonly distributedtranscryptor_rekeyLongBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly distributedtranscryptor_sessionKeyShares: (a: number, b: number) => number;
    readonly distributedtranscryptor_transcryptJSON: (a: number, b: number, c: number) => number;
    readonly distributedtranscryptor_transcryptJSONBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly distributedtranscryptor_transcryptLongRecord: (a: number, b: number, c: number) => number;
    readonly distributedtranscryptor_transcryptLongRecordBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly distributedtranscryptor_transcryptRecord: (a: number, b: number, c: number) => number;
    readonly distributedtranscryptor_transcryptRecordBatch: (a: number, b: number, c: number, d: number) => [number, number, number, number];
    readonly distributedtranscryptor_transcryptionInfo: (a: number, b: number, c: number, d: number, e: number) => number;
    readonly encryptedattribute_fromBase64: (a: number, b: number) => number;
    readonly encryptedattribute_fromBytes: (a: number, b: number) => number;
    readonly encryptedattribute_new: (a: number) => number;
    readonly encryptedattribute_toBase64: (a: number) => [number, number];
    readonly encryptedattribute_toBytes: (a: number) => [number, number];
    readonly encryptedpseudonym_toBase64: (a: number) => [number, number];
    readonly encryptedpseudonym_toBytes: (a: number) => [number, number];
    readonly offlinepepclient_encryptData: (a: number, b: number) => number;
    readonly offlinepepclient_encryptDataBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly offlinepepclient_encryptJSON: (a: number, b: number) => number;
    readonly offlinepepclient_encryptJSONBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly offlinepepclient_encryptLongData: (a: number, b: number) => number;
    readonly offlinepepclient_encryptLongDataBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly offlinepepclient_encryptLongPseudonym: (a: number, b: number) => number;
    readonly offlinepepclient_encryptLongPseudonymBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly offlinepepclient_encryptLongRecord: (a: number, b: number) => number;
    readonly offlinepepclient_encryptPseudonym: (a: number, b: number) => number;
    readonly offlinepepclient_encryptPseudonymBatch: (a: number, b: number, c: number) => [number, number, number, number];
    readonly offlinepepclient_encryptRecord: (a: number, b: number) => number;
    readonly offlinepepclient_new: (a: number) => number;
    readonly pseudonym_fromBytesPadded: (a: number, b: number) => number;
    readonly pseudonym_fromHash: (a: number, b: number) => number;
    readonly pseudonym_fromStringPadded: (a: number, b: number) => number;
    readonly pseudonym_toBytes: (a: number) => [number, number];
    readonly pseudonym_toBytesPadded: (a: number) => [number, number];
    readonly pseudonym_toHex: (a: number) => [number, number];
    readonly pseudonym_toLizard: (a: number) => [number, number];
    readonly pseudonym_toStringPadded: (a: number) => [number, number];
    readonly encryptedpseudonym_fromBytes: (a: number, b: number) => number;
    readonly pseudonym_fromLizard: (a: number, b: number) => number;
    readonly pseudonym_toPoint: (a: number) => number;
    readonly pseudonym_fromBytes: (a: number, b: number) => number;
    readonly encryptedpseudonym_fromBase64: (a: number, b: number) => number;
    readonly pseudonym_fromHex: (a: number, b: number) => number;
    readonly encryptedpseudonym_new: (a: number) => number;
    readonly pseudonym_new: (a: number) => number;
    readonly pseudonym_random: () => number;
    readonly __wbindgen_malloc: (a: number, b: number) => number;
    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
    readonly __wbindgen_exn_store: (a: number) => void;
    readonly __externref_table_alloc: () => number;
    readonly __wbindgen_externrefs: WebAssembly.Table;
    readonly __externref_drop_slice: (a: number, b: number) => void;
    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
    readonly __externref_table_dealloc: (a: number) => void;
    readonly __wbindgen_start: () => void;
}

export type SyncInitInput = BufferSource | WebAssembly.Module;

/**
 * Instantiates the given `module`, which can either be bytes or
 * a precompiled `WebAssembly.Module`.
 *
 * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
 *
 * @returns {InitOutput}
 */
export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;

/**
 * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
 * for everything else, calls `WebAssembly.instantiate` directly.
 *
 * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
 *
 * @returns {Promise<InitOutput>}
 */
export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;