import { type Nonces, Session } from '@scure/btc-signer/musig2.js';
type PublicKey = Uint8Array;
type PrivateKey = Uint8Array;
type NonceBytes = Uint8Array;
type PartialSignature = Uint8Array;
type ParticipantIndex = number & {
    readonly __brand: unique symbol;
};
type NoncePair = readonly [PublicKey, NonceBytes];
interface BaseState {
    readonly privateKey: PrivateKey;
    readonly myPublicKey: PublicKey;
    readonly publicKeys: ReadonlyArray<PublicKey>;
    readonly myIndex: ParticipantIndex;
    readonly aggPubkey: PublicKey;
    readonly internalKey: PublicKey;
    readonly tweak?: Uint8Array;
}
interface StateWithMessage extends BaseState {
    readonly msg: Uint8Array;
}
interface StateWithNonce extends StateWithMessage {
    readonly nonce: Nonces;
}
interface StateWithAggregatedNonces extends StateWithNonce {
    readonly pubNonces: ReadonlyArray<NonceBytes>;
    readonly aggregatedNonce: NonceBytes;
}
interface StateWithSession extends StateWithAggregatedNonces {
    readonly session: Session;
    readonly partialSignatures: Array<PartialSignature | null>;
}
interface StateWithSignature extends StateWithSession {
    readonly ourSignature: PartialSignature;
}
declare abstract class MusigBase<S extends BaseState> {
    protected readonly state: S;
    constructor(state: S);
    get aggPubkey(): PublicKey;
    get internalKey(): PublicKey;
    get publicKeys(): ReadonlyArray<PublicKey>;
    get myPublicKey(): PublicKey;
    get myIndex(): ParticipantIndex;
    get tweak(): Uint8Array | undefined;
    get numParticipants(): number;
    hasPublicKey: (publicKey: PublicKey) => boolean;
    indexOfPublicKey: (publicKey: PublicKey) => ParticipantIndex;
}
declare abstract class MusigWithMessageBase<S extends StateWithMessage> extends MusigBase<S> {
    get msg(): Uint8Array;
}
declare abstract class MusigWithNonceBase<S extends StateWithNonce> extends MusigWithMessageBase<S> {
    get publicNonce(): NonceBytes;
}
declare abstract class MusigWithSessionBase<S extends StateWithSession> extends MusigWithNonceBase<S> {
    verifyPartial: (publicKeyOrIndex: PublicKey | number, signature: PartialSignature) => boolean;
    addPartial: (publicKeyOrIndex: PublicKey | number, signature: PartialSignature) => this;
    addPartials: (partials: Iterable<readonly [PublicKey | number, PartialSignature]>) => this;
}
declare abstract class MusigWithOurPartialSignatureBase<S extends StateWithSignature> extends MusigWithSessionBase<S> {
    get ourPartialSignature(): PartialSignature;
}
declare class MusigKeyAgg extends MusigBase<BaseState> {
    xonlyTweakAdd: (tweak: Uint8Array) => MusigKeyAgg;
    message: (msg: Uint8Array) => MusigWithMessage;
}
declare class MusigWithMessage extends MusigWithMessageBase<StateWithMessage> {
    generateNonce: () => MusigWithNonce;
}
declare class MusigWithNonce extends MusigWithNonceBase<StateWithNonce> {
    aggregateNonces: (nonces: Iterable<NoncePair>) => MusigNoncesAggregated;
    aggregateNoncesOrdered: (nonces: ReadonlyArray<NonceBytes>) => MusigNoncesAggregated;
}
declare class MusigNoncesAggregated extends MusigWithNonceBase<StateWithAggregatedNonces> {
    initializeSession: () => MusigSession;
}
declare class MusigSession extends MusigWithSessionBase<StateWithSession> {
    signPartial: () => MusigSigned;
}
declare class MusigSigned extends MusigWithOurPartialSignatureBase<StateWithSignature> {
    aggregatePartials: () => Uint8Array;
}
declare const aggregateKeys: (publicKeys: ReadonlyArray<PublicKey>, tweak?: Uint8Array) => Uint8Array;
declare const create: (privateKey: PrivateKey, publicKeys: ReadonlyArray<PublicKey>) => MusigKeyAgg;
export { aggregateKeys, create, MusigKeyAgg, MusigWithMessage, MusigWithNonce, MusigNoncesAggregated, MusigSession, MusigSigned, type NoncePair, type ParticipantIndex, };
//# sourceMappingURL=Musig.d.ts.map