import type { ProfileAgents } from '@interop/was-client/identity';
/**
 * The HKDF salt for a standing credential's client-side expansions, and the
 * per-key info labels. All permanent. The salt differs from the recovery
 * code's client salt (`freewallet/recovery/client-keys/v1`), so a code and a
 * standing method that somehow shared input material could still never derive
 * the same client identity.
 */
export declare const STANDING_CLIENT_SALT = "freewallet/unlock/standing-client/v1";
/**
 * A credential-derived client identity, assembled from its 32-byte client
 * seed: the derived agents, the client did:key, the public multibases the
 * document and roster carry, and the roster recipient kid. The shared shape
 * of a standing credential's identity and a recovery code's (which extends it
 * with the code's single update key).
 */
export interface UnlockClientIdentity {
    clientSeed: Uint8Array;
    agents: ProfileAgents;
    clientDid: string;
    signingKeyMultibase: string;
    keyAgreementKeyMultibase: string;
    /**
     * The kid of the credential's user-key-roster entry -- its key-agreement
     * key's id exactly as `agentsFromSeed` derives it (`did:key:<ed>#<x>`), so
     * the wrap minted at bind time is the one a fresh browser's roster read
     * looks for.
     */
    recipientKid: string;
}
/**
 * Assembles a client identity from its 32-byte client seed: the one place the
 * agents, multibases, and roster kid are derived, shared by the standing
 * credential derivation here and the recovery code's
 * (`recoveryClientFromCode`), so the two derivations can never disagree on how a
 * seed becomes an identity.
 *
 * @param options {object}
 * @param options.clientSeed {Uint8Array}   the 32-byte client seed
 * @returns {Promise<UnlockClientIdentity>}
 */
export declare function unlockClientIdentityFromSeed({ clientSeed }: {
    clientSeed: Uint8Array;
}): Promise<UnlockClientIdentity>;
/**
 * A standing unlock credential's full client-side key set: the client
 * identity plus the binding MAC key that authenticates the unlock record's
 * account core (computed at bind time, verified before the pointer is
 * trusted -- the storage host never holds it).
 */
export interface StandingUnlockClient extends UnlockClientIdentity {
    bindingMacKey: Uint8Array;
}
/**
 * Derives a standing credential's client key set from the method's 32-byte
 * unlock seed (the output of `deriveUnlockSeed` under the method's own KDF).
 * Deterministic: the same secret under the same KDF always yields the same
 * key set, which is what makes a fresh browser's self-enrollment possible
 * with nothing but the credential in hand.
 *
 * @param options {object}
 * @param options.unlockSeed {Uint8Array}   the method's 32-byte unlock seed
 * @returns {Promise<StandingUnlockClient>}
 */
export declare function standingClientFromUnlockSeed({ unlockSeed }: {
    unlockSeed: Uint8Array;
}): Promise<StandingUnlockClient>;
//# sourceMappingURL=standingClient.d.ts.map