import _m0 from "protobufjs/minimal";
import { AccountID, KeyList } from "./basic_types";
import { Duration } from "./duration";
export declare const protobufPackage = "proto";
/**
 * A hash---presumably of some kind of credential or certificate---along with a list of keys, each
 * of which may be either a primitive or a threshold key.
 */
export interface LiveHash {
    /** The account to which the livehash is attached */
    accountId: AccountID | undefined;
    /** The SHA-384 hash of a credential or certificate */
    hash: Uint8Array;
    /** A list of keys (primitive or threshold), all of which must sign to attach the livehash to an account, and any one of which can later delete it. */
    keys: KeyList | undefined;
    /** The duration for which the livehash will remain valid */
    duration: Duration | undefined;
}
/**
 * At consensus, attaches the given livehash to the given account.  The hash can be deleted by the
 * key controlling the account, or by any of the keys associated to the livehash.  Hence livehashes
 * provide a revocation service for their implied credentials; for example, when an authority grants
 * a credential to the account, the account owner will cosign with the authority (or authorities) to
 * attach a hash of the credential to the account---hence proving the grant. If the credential is
 * revoked, then any of the authorities may delete it (or the account owner). In this way, the
 * livehash mechanism acts as a revocation service.  An account cannot have two identical livehashes
 * associated. To modify the list of keys in a livehash, the livehash should first be deleted, then
 * recreated with a new list of keys.
 */
export interface CryptoAddLiveHashTransactionBody {
    /** A hash of some credential or certificate, along with the keys of the entities that asserted it validity */
    liveHash: LiveHash | undefined;
}
export declare const LiveHash: {
    encode(message: LiveHash, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): LiveHash;
    fromJSON(object: any): LiveHash;
    toJSON(message: LiveHash): unknown;
    create(base?: DeepPartial<LiveHash>): LiveHash;
    fromPartial(object: DeepPartial<LiveHash>): LiveHash;
};
export declare const CryptoAddLiveHashTransactionBody: {
    encode(message: CryptoAddLiveHashTransactionBody, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CryptoAddLiveHashTransactionBody;
    fromJSON(object: any): CryptoAddLiveHashTransactionBody;
    toJSON(message: CryptoAddLiveHashTransactionBody): unknown;
    create(base?: DeepPartial<CryptoAddLiveHashTransactionBody>): CryptoAddLiveHashTransactionBody;
    fromPartial(object: DeepPartial<CryptoAddLiveHashTransactionBody>): CryptoAddLiveHashTransactionBody;
};
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
    $case: string;
} ? {
    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
} & {
    $case: T["$case"];
} : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
export {};
//# sourceMappingURL=crypto_add_live_hash.d.ts.map