ts-mls 1.0.1

package/dist/ts-mls.d.ts

@@ -0,0 +1,781 @@
+declare type Add = {
+    keyPackage: KeyPackage;
+};
+
+declare type AeadAlgorithm = "AES128GCM" | "CHACHA20POLY1305" | "AES256GCM";
+
+declare interface AuthenticationService {
+    validateCredential(credential: Credential_2, signaturePublicKey: Uint8Array): Promise<boolean>;
+}
+
+export declare function branchGroup(state: ClientState, keyPackage: KeyPackage, privateKeyPackage: PrivateKeyPackage, memberKeyPackages: KeyPackage[], newGroupId: Uint8Array, cs: CiphersuiteImpl): Promise<CreateCommitResult>;
+
+export declare function bytesToBase64(bytes: Uint8Array): string;
+
+export declare type Capabilities = {
+    versions: ProtocolVersionName[];
+    ciphersuites: CiphersuiteName[];
+    extensions: number[];
+    proposals: number[];
+    credentials: CredentialTypeName[];
+};
+
+declare type Ciphersuite = {
+    hash: HashAlgorithm;
+    hpke: HpkeAlgorithm;
+    signature: SignatureAlgorithm;
+    name: CiphersuiteName;
+};
+
+declare type CiphersuiteImpl = {
+    hash: Hash;
+    hpke: Hpke;
+    signature: Signature;
+    kdf: Kdf;
+    rng: Rng;
+    name: CiphersuiteName;
+};
+
+export declare type CiphersuiteName = keyof typeof ciphersuites;
+
+export declare const ciphersuites: {
+    readonly MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519: 1;
+    readonly MLS_128_DHKEMP256_AES128GCM_SHA256_P256: 2;
+    readonly MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519: 3;
+    readonly MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448: 4;
+    readonly MLS_256_DHKEMP521_AES256GCM_SHA512_P521: 5;
+    readonly MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448: 6;
+    readonly MLS_256_DHKEMP384_AES256GCM_SHA384_P384: 7;
+    readonly MLS_128_MLKEM512_AES128GCM_SHA256_Ed25519: 77;
+    readonly MLS_128_MLKEM512_CHACHA20POLY1305_SHA256_Ed25519: 78;
+    readonly MLS_256_MLKEM768_AES256GCM_SHA384_Ed25519: 79;
+    readonly MLS_256_MLKEM768_CHACHA20POLY1305_SHA384_Ed25519: 80;
+    readonly MLS_256_MLKEM1024_AES256GCM_SHA512_Ed25519: 81;
+    readonly MLS_256_MLKEM1024_CHACHA20POLY1305_SHA512_Ed25519: 82;
+    readonly MLS_256_XWING_AES256GCM_SHA512_Ed25519: 83;
+    readonly MLS_256_XWING_CHACHA20POLY1305_SHA512_Ed25519: 84;
+    readonly MLS_256_MLKEM1024_AES256GCM_SHA512_MLDSA87: 85;
+    readonly MLS_256_MLKEM1024_CHACHA20POLY1305_SHA512_MLDSA87: 86;
+    readonly MLS_256_XWING_AES256GCM_SHA512_MLDSA87: 87;
+    readonly MLS_256_XWING_CHACHA20POLY1305_SHA512_MLDSA87: 88;
+};
+
+declare type ClientConfig = {
+    keyRetentionConfig: KeyRetentionConfig;
+    lifetimeConfig: LifetimeConfig;
+    keyPackageEqualityConfig: KeyPackageEqualityConfig;
+    paddingConfig: PaddingConfig;
+    authService: AuthenticationService;
+};
+
+declare type ClientState = {
+    groupContext: GroupContext;
+    keySchedule: KeySchedule;
+    secretTree: SecretTree;
+    ratchetTree: RatchetTree;
+    privatePath: PrivateKeyPath;
+    signaturePrivateKey: Uint8Array;
+    unappliedProposals: UnappliedProposals;
+    confirmationTag: Uint8Array;
+    historicalReceiverData: Map<bigint, EpochReceiverData>;
+    groupActiveState: GroupActiveState;
+    clientConfig: ClientConfig;
+};
+
+declare type Commit = {
+    proposals: ProposalOrRef[];
+    path: UpdatePath | undefined;
+};
+
+declare type ContentTypeName = keyof typeof contentTypes;
+
+declare const contentTypes: {
+    readonly application: 1;
+    readonly proposal: 2;
+    readonly commit: 3;
+};
+
+export declare function createApplicationMessage(state: ClientState, message: Uint8Array, cs: CiphersuiteImpl, authenticatedData?: Uint8Array): Promise<{
+    newState: {
+        secretTree: SecretTree;
+        groupContext: GroupContext;
+        keySchedule: KeySchedule;
+        ratchetTree: RatchetTree;
+        privatePath: PrivateKeyPath;
+        signaturePrivateKey: Uint8Array;
+        unappliedProposals: UnappliedProposals;
+        confirmationTag: Uint8Array;
+        historicalReceiverData: Map<bigint, EpochReceiverData>;
+        groupActiveState: GroupActiveState;
+        clientConfig: ClientConfig;
+    };
+    privateMessage: PrivateMessage;
+}>;
+
+export declare function createCommit(state: ClientState, pskSearch: PskIndex, publicMessage: boolean, extraProposals: Proposal[], cs: CiphersuiteImpl, ratchetTreeExtension?: boolean, authenticatedData?: Uint8Array): Promise<CreateCommitResult>;
+
+declare type CreateCommitResult = {
+    newState: ClientState;
+    welcome: Welcome | undefined;
+    commit: MLSMessage;
+};
+
+export declare function createGroup(groupId: Uint8Array, keyPackage: KeyPackage, privateKeyPackage: PrivateKeyPackage, extensions: Extension[], cs: CiphersuiteImpl, clientConfig?: ClientConfig): Promise<ClientState>;
+
+export declare function createGroupInfoWithExternalPub(state: ClientState, cs: CiphersuiteImpl): Promise<GroupInfo>;
+
+export declare function createGroupInfoWithExternalPubAndRatchetTree(state: ClientState, cs: CiphersuiteImpl): Promise<GroupInfo>;
+
+export declare function createProposal(state: ClientState, publicMessage: boolean, proposal: Proposal, cs: CiphersuiteImpl, authenticatedData?: Uint8Array): Promise<{
+    newState: ClientState;
+    message: MLSMessage;
+}>;
+
+declare type Credential_2 = CredentialBasic | CredentialX509;
+export { Credential_2 as Credential }
+
+declare type CredentialBasic = {
+    credentialType: "basic";
+    identity: Uint8Array;
+};
+
+declare type CredentialTypeName = keyof typeof credentialTypes;
+
+declare const credentialTypes: {
+    readonly basic: 1;
+    readonly x509: 2;
+};
+
+declare type CredentialX509 = {
+    credentialType: "x509";
+    certificates: Uint8Array[];
+};
+
+export declare const decodeMlsMessage: Decoder<MLSMessage>;
+
+declare type Decoder<T> = (b: Uint8Array, offset: number) => [T, number] | undefined;
+
+export declare function defaultCapabilities(): Capabilities;
+
+declare type DefaultExtensionTypeName = keyof typeof defaultExtensionTypes;
+
+declare const defaultExtensionTypes: {
+    readonly application_id: 1;
+    readonly ratchet_tree: 2;
+    readonly required_capabilities: 3;
+    readonly external_pub: 4;
+    readonly external_senders: 5;
+};
+
+export declare const defaultLifetime: Lifetime;
+
+export declare const emptyPskIndex: PskIndex;
+
+export declare const encodeMlsMessage: Encoder<MLSMessage>;
+
+declare type Encoder<T> = (t: T) => Uint8Array;
+
+declare type EncryptedGroupSecrets = {
+    newMember: Uint8Array;
+    encryptedGroupSecrets: HPKECiphertext;
+};
+
+/**
+ * This type contains everything necessary to receieve application messages for an earlier epoch
+ */
+declare type EpochReceiverData = {
+    resumptionPsk: Uint8Array;
+    secretTree: SecretTree;
+    ratchetTree: RatchetTree;
+    senderDataSecret: Uint8Array;
+    groupContext: GroupContext;
+};
+
+declare type Extension = {
+    extensionType: ExtensionType;
+    extensionData: Uint8Array;
+};
+
+declare type ExtensionType = DefaultExtensionTypeName | number;
+
+declare type ExternalInit = {
+    kemOutput: Uint8Array;
+};
+
+declare type FramedContent = FramedContentData & FramedContentInfo;
+
+declare type FramedContentApplicationData = {
+    contentType: "application";
+    applicationData: Uint8Array;
+};
+
+declare type FramedContentAuthData = FramedContentAuthDataCommit | FramedContentAuthDataApplicationOrProposal;
+
+declare type FramedContentAuthDataApplicationOrProposal = {
+    signature: Uint8Array;
+} & FramedContentAuthDataContentApplicationOrProposal;
+
+declare type FramedContentAuthDataCommit = {
+    signature: Uint8Array;
+} & FramedContentAuthDataContentCommit;
+
+declare type FramedContentAuthDataContentApplicationOrProposal = {
+    contentType: Exclude<ContentTypeName, "commit">;
+};
+
+declare type FramedContentAuthDataContentCommit = {
+    contentType: "commit";
+    confirmationTag: Uint8Array;
+};
+
+declare type FramedContentCommitData = {
+    contentType: "commit";
+    commit: Commit;
+};
+
+declare type FramedContentData = {
+    groupId: Uint8Array;
+    epoch: bigint;
+    sender: Sender;
+    authenticatedData: Uint8Array;
+};
+
+declare type FramedContentInfo = FramedContentApplicationData | FramedContentProposalData | FramedContentCommitData;
+
+declare type FramedContentProposalData = {
+    contentType: "proposal";
+    proposal: Proposal;
+};
+
+export declare function generateKeyPackage(credential: Credential_2, capabilities: Capabilities, lifetime: Lifetime, extensions: Extension[], cs: CiphersuiteImpl): Promise<{
+    publicPackage: KeyPackage;
+    privatePackage: PrivateKeyPackage;
+}>;
+
+declare type GenerationSecret = {
+    secret: Uint8Array;
+    generation: number;
+    unusedGenerations: Record<number, Uint8Array>;
+};
+
+export declare function getCiphersuiteFromName(name: CiphersuiteName): Ciphersuite;
+
+export declare function getCiphersuiteImpl(cs: Ciphersuite): Promise<CiphersuiteImpl>;
+
+declare type GroupActiveState = {
+    kind: "active";
+} | {
+    kind: "suspendedPendingReinit";
+    reinit: Reinit;
+} | {
+    kind: "removedFromGroup";
+};
+
+declare type GroupContext = {
+    version: ProtocolVersionName;
+    cipherSuite: CiphersuiteName;
+    groupId: Uint8Array;
+    epoch: bigint;
+    treeHash: Uint8Array;
+    confirmedTranscriptHash: Uint8Array;
+    extensions: Extension[];
+};
+
+declare type GroupContextExtensions = {
+    extensions: Extension[];
+};
+
+declare type GroupInfo = GroupInfoTBS & {
+    signature: Uint8Array;
+};
+
+declare type GroupInfoTBS = {
+    groupContext: GroupContext;
+    extensions: Extension[];
+    confirmationTag: Uint8Array;
+    signer: number;
+};
+
+declare interface Hash {
+    digest(data: Uint8Array): Promise<Uint8Array>;
+    mac(key: Uint8Array, data: Uint8Array): Promise<Uint8Array>;
+    verifyMac(key: Uint8Array, mac: Uint8Array, data: Uint8Array): Promise<boolean>;
+}
+
+declare type HashAlgorithm = "SHA-512" | "SHA-384" | "SHA-256";
+
+declare interface Hpke {
+    open(privateKey: PrivateKey, kemOutput: Uint8Array, ciphertext: Uint8Array, info: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
+    seal(publicKey: PublicKey, plaintext: Uint8Array, info: Uint8Array, aad?: Uint8Array): Promise<{
+        ct: Uint8Array;
+        enc: Uint8Array;
+    }>;
+    importPrivateKey(k: Uint8Array): Promise<PrivateKey>;
+    importPublicKey(k: Uint8Array): Promise<PublicKey>;
+    exportPublicKey(k: PublicKey): Promise<Uint8Array>;
+    exportPrivateKey(k: PrivateKey): Promise<Uint8Array>;
+    encryptAead(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array | undefined, plaintext: Uint8Array): Promise<Uint8Array>;
+    decryptAead(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array | undefined, ciphertext: Uint8Array): Promise<Uint8Array>;
+    exportSecret(publicKey: PublicKey, exporterContext: Uint8Array, length: number, info: Uint8Array): Promise<{
+        enc: Uint8Array;
+        secret: Uint8Array;
+    }>;
+    importSecret(privateKey: PrivateKey, exporterContext: Uint8Array, kemOutput: Uint8Array, length: number, info: Uint8Array): Promise<Uint8Array>;
+    deriveKeyPair(ikm: Uint8Array): Promise<{
+        privateKey: PrivateKey;
+        publicKey: PublicKey;
+    }>;
+    generateKeyPair(): Promise<{
+        privateKey: PrivateKey;
+        publicKey: PublicKey;
+    }>;
+    keyLength: number;
+    nonceLength: number;
+}
+
+declare type HpkeAlgorithm = {
+    kem: KemAlgorithm;
+    kdf: KdfAlgorithm;
+    aead: AeadAlgorithm;
+};
+
+declare type HPKECiphertext = {
+    kemOutput: Uint8Array;
+    ciphertext: Uint8Array;
+};
+
+declare type IncomingMessageAction = "accept" | "reject";
+
+declare type IncomingMessageCallback = (incoming: {
+    kind: "commit";
+    proposals: ProposalWithSender[];
+} | {
+    kind: "proposal";
+    proposal: ProposalWithSender;
+}) => IncomingMessageAction;
+
+export declare function joinGroup(welcome: Welcome, keyPackage: KeyPackage, privateKeys: PrivateKeyPackage, pskSearch: PskIndex, cs: CiphersuiteImpl, ratchetTree?: RatchetTree, resumingFromState?: ClientState, clientConfig?: ClientConfig): Promise<ClientState>;
+
+export declare function joinGroupExternal(groupInfo: GroupInfo, keyPackage: KeyPackage, privateKeys: PrivateKeyPackage, resync: boolean, cs: CiphersuiteImpl, tree?: RatchetTree, clientConfig?: ClientConfig, authenticatedData?: Uint8Array): Promise<{
+    publicMessage: PublicMessage;
+    newState: ClientState;
+}>;
+
+export declare function joinGroupFromBranch(oldState: ClientState, welcome: Welcome, keyPackage: KeyPackage, privateKeyPackage: PrivateKeyPackage, ratchetTree: RatchetTree | undefined, cs: CiphersuiteImpl): Promise<ClientState>;
+
+export declare function joinGroupFromReinit(suspendedState: ClientState, welcome: Welcome, keyPackage: KeyPackage, privateKeyPackage: PrivateKeyPackage, ratchetTree: RatchetTree | undefined): Promise<ClientState>;
+
+declare interface Kdf {
+    extract(salt: Uint8Array, ikm: Uint8Array): Promise<Uint8Array>;
+    expand(prk: Uint8Array, info: Uint8Array, len: number): Promise<Uint8Array>;
+    size: number;
+}
+
+declare type KdfAlgorithm = "HKDF-SHA256" | "HKDF-SHA384" | "HKDF-SHA512";
+
+declare type KemAlgorithm = "DHKEM-P256-HKDF-SHA256" | "DHKEM-X25519-HKDF-SHA256" | "DHKEM-X448-HKDF-SHA512" | "DHKEM-P521-HKDF-SHA512" | "DHKEM-P384-HKDF-SHA384" | "ML-KEM-512" | "ML-KEM-768" | "ML-KEM-1024" | "X-Wing";
+
+declare type KeyPackage = KeyPackageTBS & {
+    signature: Uint8Array;
+};
+
+declare type KeyPackageEqualityConfig = {
+    compareKeyPackages(a: KeyPackage, b: KeyPackage): boolean;
+    compareKeyPackageToLeafNode(a: KeyPackage, b: LeafNode): boolean;
+};
+
+declare type KeyPackageTBS = {
+    version: ProtocolVersionName;
+    cipherSuite: CiphersuiteName;
+    initKey: Uint8Array;
+    leafNode: LeafNodeKeyPackage;
+    extensions: Extension[];
+};
+
+declare type KeyRetentionConfig = {
+    retainKeysForGenerations: number;
+    retainKeysForEpochs: number;
+    maximumForwardRatchetSteps: number;
+};
+
+declare type KeySchedule = {
+    epochSecret: Uint8Array;
+    senderDataSecret: Uint8Array;
+    encryptionSecret: Uint8Array;
+    exporterSecret: Uint8Array;
+    externalSecret: Uint8Array;
+    confirmationKey: Uint8Array;
+    membershipKey: Uint8Array;
+    resumptionPsk: Uint8Array;
+    epochAuthenticator: Uint8Array;
+    initSecret: Uint8Array;
+};
+
+declare type LeafNode = LeafNodeData & LeafNodeInfo & LeafNodeExtensions & {
+    signature: Uint8Array;
+};
+
+declare type LeafNodeCommit = LeafNode & LeafNodeInfoCommit;
+
+declare type LeafNodeData = {
+    hpkePublicKey: Uint8Array;
+    signaturePublicKey: Uint8Array;
+    credential: Credential_2;
+    capabilities: Capabilities;
+};
+
+declare type LeafNodeExtensions = {
+    extensions: Extension[];
+};
+
+declare type LeafNodeInfo = LeafNodeInfoKeyPackage | LeafNodeInfoUpdate | LeafNodeInfoCommit;
+
+declare type LeafNodeInfoCommit = {
+    leafNodeSource: "commit";
+    parentHash: Uint8Array;
+};
+
+declare type LeafNodeInfoKeyPackage = {
+    leafNodeSource: "key_package";
+    lifetime: Lifetime;
+};
+
+declare type LeafNodeInfoUpdate = {
+    leafNodeSource: "update";
+};
+
+declare type LeafNodeKeyPackage = LeafNode & LeafNodeInfoKeyPackage;
+
+declare type LeafNodeUpdate = LeafNode & LeafNodeInfoUpdate;
+
+export declare type Lifetime = {
+    notBefore: bigint;
+    notAfter: bigint;
+};
+
+declare type LifetimeConfig = {
+    maximumTotalLifetime: bigint;
+    validateLifetimeOnReceive: boolean;
+};
+
+export declare function makePskIndex(state: ClientState | undefined, externalPsks: Record<string, Uint8Array>): PskIndex;
+
+declare type MlsGroupInfo = {
+    wireformat: "mls_group_info";
+    groupInfo: GroupInfo;
+};
+
+declare type MlsKeyPackage = {
+    wireformat: "mls_key_package";
+    keyPackage: KeyPackage;
+};
+
+declare type MLSMessage = MlsMessageProtocol & MlsMessageContent;
+
+declare type MlsMessageContent = MlsWelcome | MlsPrivateMessage | MlsGroupInfo | MlsKeyPackage | MlsPublicMessage;
+
+declare type MlsMessageProtocol = {
+    version: ProtocolVersionName;
+};
+
+declare type MlsPrivateMessage = {
+    wireformat: "mls_private_message";
+    privateMessage: PrivateMessage;
+};
+
+declare type MlsPublicMessage = {
+    wireformat: "mls_public_message";
+    publicMessage: PublicMessage;
+};
+
+declare type MlsWelcome = {
+    wireformat: "mls_welcome";
+    welcome: Welcome;
+};
+
+declare type NewStateWithActionTaken = {
+    newState: ClientState;
+    actionTaken: IncomingMessageAction;
+};
+
+declare type Node_2 = NodeParent | NodeLeaf;
+
+declare type NodeLeaf = {
+    nodeType: "leaf";
+    leaf: LeafNode;
+};
+
+declare type NodeParent = {
+    nodeType: "parent";
+    parent: ParentNode_2;
+};
+
+declare type PaddingConfig = {
+    kind: "padUntilLength";
+    padUntilLength: number;
+} | {
+    kind: "alwaysPad";
+    paddingLength: number;
+};
+
+declare type ParentNode_2 = {
+    hpkePublicKey: Uint8Array;
+    parentHash: Uint8Array;
+    unmergedLeaves: number[];
+};
+
+declare type PreSharedKeyID = PSKInfo & PSKNonce;
+
+declare type PrivateKey = CryptoKey & {
+    type: "private";
+};
+
+declare type PrivateKeyPackage = {
+    initPrivateKey: Uint8Array;
+    hpkePrivateKey: Uint8Array;
+    signaturePrivateKey: Uint8Array;
+};
+
+declare type PrivateKeyPath = {
+    leafIndex: number;
+    privateKeys: Record<number, Uint8Array>;
+};
+
+declare type PrivateMessage = {
+    groupId: Uint8Array;
+    epoch: bigint;
+    contentType: ContentTypeName;
+    authenticatedData: Uint8Array;
+    encryptedSenderData: Uint8Array;
+    ciphertext: Uint8Array;
+};
+
+declare type ProcessMessageResult = {
+    kind: "newState";
+    newState: ClientState;
+    actionTaken: IncomingMessageAction;
+} | {
+    kind: "applicationMessage";
+    message: Uint8Array;
+    newState: ClientState;
+};
+
+/**
+ * Process private message and apply proposal or commit and return the updated ClientState or return an application message
+ */
+export declare function processPrivateMessage(state: ClientState, pm: PrivateMessage, pskSearch: PskIndex, cs: CiphersuiteImpl, callback?: IncomingMessageCallback): Promise<ProcessMessageResult>;
+
+export declare function processPublicMessage(state: ClientState, pm: PublicMessage, pskSearch: PskIndex, cs: CiphersuiteImpl, callback?: IncomingMessageCallback): Promise<NewStateWithActionTaken>;
+
+export declare type Proposal = ProposalAdd | ProposalUpdate | ProposalRemove | ProposalPSK | ProposalReinit | ProposalExternalInit | ProposalGroupContextExtensions | ProposalCustom;
+
+export declare type ProposalAdd = {
+    proposalType: "add";
+    add: Add;
+};
+
+declare type ProposalCustom = {
+    proposalType: number;
+    proposalData: Uint8Array;
+};
+
+declare type ProposalExternalInit = {
+    proposalType: "external_init";
+    externalInit: ExternalInit;
+};
+
+declare type ProposalGroupContextExtensions = {
+    proposalType: "group_context_extensions";
+    groupContextExtensions: GroupContextExtensions;
+};
+
+declare type ProposalOrRef = ProposalOrRefProposal | ProposalOrRefProposalRef;
+
+declare type ProposalOrRefProposal = {
+    proposalOrRefType: "proposal";
+    proposal: Proposal;
+};
+
+declare type ProposalOrRefProposalRef = {
+    proposalOrRefType: "reference";
+    reference: Uint8Array;
+};
+
+declare type ProposalPSK = {
+    proposalType: "psk";
+    psk: PSK;
+};
+
+declare type ProposalReinit = {
+    proposalType: "reinit";
+    reinit: Reinit;
+};
+
+declare type ProposalRemove = {
+    proposalType: "remove";
+    remove: Remove;
+};
+
+declare type ProposalUpdate = {
+    proposalType: "update";
+    update: Update;
+};
+
+declare type ProposalWithSender = {
+    proposal: Proposal;
+    senderLeafIndex: number | undefined;
+};
+
+declare type ProtocolVersionName = keyof typeof protocolVersions;
+
+declare const protocolVersions: {
+    readonly mls10: 1;
+};
+
+declare type PSK = {
+    preSharedKeyId: PreSharedKeyID;
+};
+
+export declare interface PskIndex {
+    findPsk(preSharedKeyId: PreSharedKeyID): Uint8Array | undefined;
+}
+
+declare type PSKInfo = PSKInfoExternal | PSKInfoResumption;
+
+declare type PSKInfoExternal = {
+    psktype: "external";
+    pskId: Uint8Array;
+};
+
+declare type PSKInfoResumption = {
+    psktype: "resumption";
+    usage: ResumptionPSKUsageName;
+    pskGroupId: Uint8Array;
+    pskEpoch: bigint;
+};
+
+declare type PSKNonce = {
+    pskNonce: Uint8Array;
+};
+
+declare type PublicKey = CryptoKey & {
+    type: "public";
+};
+
+declare type PublicMessage = {
+    content: FramedContent;
+    auth: FramedContentAuthData;
+} & PublicMessageInfo;
+
+declare type PublicMessageInfo = PublicMessageInfoMember | PublicMessageInfoMemberOther;
+
+declare type PublicMessageInfoMember = {
+    senderType: "member";
+    membershipTag: Uint8Array;
+};
+
+declare type PublicMessageInfoMemberOther = {
+    senderType: Exclude<SenderTypeName, "member">;
+};
+
+declare type RatchetTree = (Node_2 | undefined)[];
+
+declare type Reinit = {
+    groupId: Uint8Array;
+    version: ProtocolVersionName;
+    cipherSuite: CiphersuiteName;
+    extensions: Extension[];
+};
+
+export declare function reinitCreateNewGroup(state: ClientState, keyPackage: KeyPackage, privateKeyPackage: PrivateKeyPackage, memberKeyPackages: KeyPackage[], groupId: Uint8Array, cipherSuite: CiphersuiteName, extensions: Extension[]): Promise<CreateCommitResult>;
+
+export declare function reinitGroup(state: ClientState, groupId: Uint8Array, version: ProtocolVersionName, cipherSuite: CiphersuiteName, extensions: Extension[], cs: CiphersuiteImpl): Promise<CreateCommitResult>;
+
+declare type Remove = {
+    removed: number;
+};
+
+declare type ResumptionPSKUsageName = keyof typeof resumptionPSKUsages;
+
+declare const resumptionPSKUsages: {
+    readonly application: 1;
+    readonly reinit: 2;
+    readonly branch: 3;
+};
+
+declare interface Rng {
+    randomBytes(n: number): Uint8Array;
+}
+
+declare type SecretTree = SecretTreeNode[];
+
+declare type SecretTreeNode = {
+    handshake: GenerationSecret;
+    application: GenerationSecret;
+};
+
+declare type Sender = SenderMember | SenderNonMember;
+
+declare type SenderExternal = {
+    senderType: "external";
+    senderIndex: number;
+};
+
+declare type SenderMember = {
+    senderType: "member";
+    leafIndex: number;
+};
+
+declare type SenderNewMemberCommit = {
+    senderType: "new_member_commit";
+};
+
+declare type SenderNewMemberProposal = {
+    senderType: "new_member_proposal";
+};
+
+declare type SenderNonMember = SenderExternal | SenderNewMemberProposal | SenderNewMemberCommit;
+
+declare type SenderTypeName = keyof typeof senderTypes;
+
+declare const senderTypes: {
+    readonly member: 1;
+    readonly external: 2;
+    readonly new_member_proposal: 3;
+    readonly new_member_commit: 4;
+};
+
+declare interface Signature {
+    sign(signKey: Uint8Array, message: Uint8Array): Promise<Uint8Array>;
+    verify(publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array): Promise<boolean>;
+    keygen(): Promise<{
+        publicKey: Uint8Array;
+        signKey: Uint8Array;
+    }>;
+}
+
+declare type SignatureAlgorithm = "Ed25519" | "Ed448" | "P256" | "P384" | "P521" | "ML-DSA-87";
+
+declare type UnappliedProposals = Record<string, ProposalWithSender>;
+
+declare type Update = {
+    leafNode: LeafNodeUpdate;
+};
+
+declare type UpdatePath = {
+    leafNode: LeafNodeCommit;
+    nodes: UpdatePathNode[];
+};
+
+declare type UpdatePathNode = {
+    hpkePublicKey: Uint8Array;
+    encryptedPathSecret: HPKECiphertext[];
+};
+
+declare type Welcome = {
+    cipherSuite: CiphersuiteName;
+    secrets: EncryptedGroupSecrets[];
+    encryptedGroupInfo: Uint8Array;
+};
+
+export { }