import * as _ from './..';
import * as __ from './../_';
export declare function _BlockAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        hash?: _.HexEncoded;
        height?: number;
        protocolVersion?: number;
        timestamp?: number;
        author?: _.HexEncoded | null;
        ledgerParameters?: _.HexEncoded;
        parent?: __.Association.to</*elided*/ any> | null;
        parent_ID?: string | null;
        transactions?: __.Composition.of.many<Transactions>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        hash?: _.HexEncoded;
        height?: number;
        protocolVersion?: number;
        timestamp?: number;
        author?: _.HexEncoded | null;
        ledgerParameters?: _.HexEncoded;
        parent?: __.Association.to</*elided*/ any> | null;
        parent_ID?: string | null;
        transactions?: __.Composition.of.many<Transactions>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        hash?: _.HexEncoded;
        height?: number;
        protocolVersion?: number;
        timestamp?: number;
        author?: _.HexEncoded | null;
        ledgerParameters?: _.HexEncoded;
        parent?: __.Association.to</*elided*/ any> | null;
        parent_ID?: string | null;
        transactions?: __.Composition.of.many<Transactions>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const Block_base: {
    new (...args: any[]): {
        hash?: _.HexEncoded;
        height?: number;
        protocolVersion?: number;
        timestamp?: number;
        author?: _.HexEncoded | null;
        ledgerParameters?: _.HexEncoded;
        parent?: /*elided*/ any | null | undefined;
        parent_ID?: string | null;
        transactions?: __.Composition.of.many<Transactions>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        hash?: _.HexEncoded;
        height?: number;
        protocolVersion?: number;
        timestamp?: number;
        author?: _.HexEncoded | null;
        ledgerParameters?: _.HexEncoded;
        parent?: /*elided*/ any | null | undefined;
        parent_ID?: string | null;
        transactions?: __.Composition.of.many<Transactions>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        hash?: _.HexEncoded;
        height?: number;
        protocolVersion?: number;
        timestamp?: number;
        author?: _.HexEncoded | null;
        ledgerParameters?: _.HexEncoded;
        parent?: /*elided*/ any | null | undefined;
        parent_ID?: string | null;
        transactions?: __.Composition.of.many<Transactions>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Represents a block in the Midnight blockchain */
export declare class Block extends Block_base {
}
/** Represents a block in the Midnight blockchain */
export declare class Blocks extends Array<Block> {
    $count?: number;
}
export declare function _TransactionAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        transactionId?: number;
        hash?: _.HexEncoded;
        protocolVersion?: number;
        raw?: import("stream").Readable | null;
        transactionType?: _.TransactionType;
        merkleTreeRoot?: _.HexEncoded | null;
        startIndex?: number | null;
        endIndex?: number | null;
        identifiers?: string | null;
        txType?: _.TxType | null;
        isShielded?: boolean | null;
        senderAddress?: string | null;
        receiverAddress?: string | null;
        nightAmount?: _.BigInt | null;
        dustConsumed?: _.BigInt | null;
        hasProof?: boolean | null;
        proofHash?: _.HexEncoded | null;
        contractAddress?: _.HexEncoded | null;
        circuitName?: string | null;
        size?: number | null;
        block?: __.Association.to<Block>;
        block_ID?: string;
        transactionResult?: __.Composition.of<TransactionResult> | null;
        transactionFees?: __.Composition.of<TransactionFee> | null;
        contractActions?: __.Composition.of.many<ContractActions>;
        unshieldedCreatedOutputs?: __.Composition.of.many<UnshieldedUtxos>;
        unshieldedSpentOutputs?: __.Association.to.many<UnshieldedUtxos>;
        zswapLedgerEvents?: __.Composition.of.many<ZswapLedgerEvents>;
        dustLedgerEvents?: __.Composition.of.many<DustLedgerEvents>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        transactionId?: number;
        hash?: _.HexEncoded;
        protocolVersion?: number;
        raw?: import("stream").Readable | null;
        transactionType?: _.TransactionType;
        merkleTreeRoot?: _.HexEncoded | null;
        startIndex?: number | null;
        endIndex?: number | null;
        identifiers?: string | null;
        txType?: _.TxType | null;
        isShielded?: boolean | null;
        senderAddress?: string | null;
        receiverAddress?: string | null;
        nightAmount?: _.BigInt | null;
        dustConsumed?: _.BigInt | null;
        hasProof?: boolean | null;
        proofHash?: _.HexEncoded | null;
        contractAddress?: _.HexEncoded | null;
        circuitName?: string | null;
        size?: number | null;
        block?: __.Association.to<Block>;
        block_ID?: string;
        transactionResult?: __.Composition.of<TransactionResult> | null;
        transactionFees?: __.Composition.of<TransactionFee> | null;
        contractActions?: __.Composition.of.many<ContractActions>;
        unshieldedCreatedOutputs?: __.Composition.of.many<UnshieldedUtxos>;
        unshieldedSpentOutputs?: __.Association.to.many<UnshieldedUtxos>;
        zswapLedgerEvents?: __.Composition.of.many<ZswapLedgerEvents>;
        dustLedgerEvents?: __.Composition.of.many<DustLedgerEvents>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        transactionId?: number;
        hash?: _.HexEncoded;
        protocolVersion?: number;
        raw?: import("stream").Readable | null;
        transactionType?: _.TransactionType;
        merkleTreeRoot?: _.HexEncoded | null;
        startIndex?: number | null;
        endIndex?: number | null;
        identifiers?: string | null;
        txType?: _.TxType | null;
        isShielded?: boolean | null;
        senderAddress?: string | null;
        receiverAddress?: string | null;
        nightAmount?: _.BigInt | null;
        dustConsumed?: _.BigInt | null;
        hasProof?: boolean | null;
        proofHash?: _.HexEncoded | null;
        contractAddress?: _.HexEncoded | null;
        circuitName?: string | null;
        size?: number | null;
        block?: __.Association.to<Block>;
        block_ID?: string;
        transactionResult?: __.Composition.of<TransactionResult> | null;
        transactionFees?: __.Composition.of<TransactionFee> | null;
        contractActions?: __.Composition.of.many<ContractActions>;
        unshieldedCreatedOutputs?: __.Composition.of.many<UnshieldedUtxos>;
        unshieldedSpentOutputs?: __.Association.to.many<UnshieldedUtxos>;
        zswapLedgerEvents?: __.Composition.of.many<ZswapLedgerEvents>;
        dustLedgerEvents?: __.Composition.of.many<DustLedgerEvents>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const Transaction_base: {
    new (...args: any[]): {
        transactionId?: number;
        hash?: _.HexEncoded;
        protocolVersion?: number;
        raw?: import("stream").Readable | null;
        transactionType?: _.TransactionType;
        merkleTreeRoot?: _.HexEncoded | null;
        startIndex?: number | null;
        endIndex?: number | null;
        identifiers?: string | null;
        txType?: _.TxType | null;
        isShielded?: boolean | null;
        senderAddress?: string | null;
        receiverAddress?: string | null;
        nightAmount?: _.BigInt | null;
        dustConsumed?: _.BigInt | null;
        hasProof?: boolean | null;
        proofHash?: _.HexEncoded | null;
        contractAddress?: _.HexEncoded | null;
        circuitName?: string | null;
        size?: number | null;
        block?: __.Association.to<Block>;
        block_ID?: string;
        transactionResult?: __.Composition.of<TransactionResult> | null;
        transactionFees?: __.Composition.of<TransactionFee> | null;
        contractActions?: __.Composition.of.many<ContractActions>;
        unshieldedCreatedOutputs?: __.Composition.of.many<UnshieldedUtxos>;
        unshieldedSpentOutputs?: __.Association.to.many<UnshieldedUtxos>;
        zswapLedgerEvents?: __.Composition.of.many<ZswapLedgerEvents>;
        dustLedgerEvents?: __.Composition.of.many<DustLedgerEvents>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        transactionId?: number;
        hash?: _.HexEncoded;
        protocolVersion?: number;
        raw?: import("stream").Readable | null;
        transactionType?: _.TransactionType;
        merkleTreeRoot?: _.HexEncoded | null;
        startIndex?: number | null;
        endIndex?: number | null;
        identifiers?: string | null;
        txType?: _.TxType | null;
        isShielded?: boolean | null;
        senderAddress?: string | null;
        receiverAddress?: string | null;
        nightAmount?: _.BigInt | null;
        dustConsumed?: _.BigInt | null;
        hasProof?: boolean | null;
        proofHash?: _.HexEncoded | null;
        contractAddress?: _.HexEncoded | null;
        circuitName?: string | null;
        size?: number | null;
        block?: __.Association.to<Block>;
        block_ID?: string;
        transactionResult?: __.Composition.of<TransactionResult> | null;
        transactionFees?: __.Composition.of<TransactionFee> | null;
        contractActions?: __.Composition.of.many<ContractActions>;
        unshieldedCreatedOutputs?: __.Composition.of.many<UnshieldedUtxos>;
        unshieldedSpentOutputs?: __.Association.to.many<UnshieldedUtxos>;
        zswapLedgerEvents?: __.Composition.of.many<ZswapLedgerEvents>;
        dustLedgerEvents?: __.Composition.of.many<DustLedgerEvents>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        transactionId?: number;
        hash?: _.HexEncoded;
        protocolVersion?: number;
        raw?: import("stream").Readable | null;
        transactionType?: _.TransactionType;
        merkleTreeRoot?: _.HexEncoded | null;
        startIndex?: number | null;
        endIndex?: number | null;
        identifiers?: string | null;
        txType?: _.TxType | null;
        isShielded?: boolean | null;
        senderAddress?: string | null;
        receiverAddress?: string | null;
        nightAmount?: _.BigInt | null;
        dustConsumed?: _.BigInt | null;
        hasProof?: boolean | null;
        proofHash?: _.HexEncoded | null;
        contractAddress?: _.HexEncoded | null;
        circuitName?: string | null;
        size?: number | null;
        block?: __.Association.to<Block>;
        block_ID?: string;
        transactionResult?: __.Composition.of<TransactionResult> | null;
        transactionFees?: __.Composition.of<TransactionFee> | null;
        contractActions?: __.Composition.of.many<ContractActions>;
        unshieldedCreatedOutputs?: __.Composition.of.many<UnshieldedUtxos>;
        unshieldedSpentOutputs?: __.Association.to.many<UnshieldedUtxos>;
        zswapLedgerEvents?: __.Composition.of.many<ZswapLedgerEvents>;
        dustLedgerEvents?: __.Composition.of.many<DustLedgerEvents>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Represents a transaction in the Midnight blockchain */
export declare class Transaction extends Transaction_base {
}
/** Represents a transaction in the Midnight blockchain */
export declare class Transactions extends Array<Transaction> {
    $count?: number;
}
export declare function _TransactionResultAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        status?: _.TransactionResultStatus;
        transaction?: __.Association.to<Transaction> | null;
        transaction_ID?: string | null;
        segments?: __.Composition.of.many<TransactionSegments>;
        ID?: __.Key<string>;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        status?: _.TransactionResultStatus;
        transaction?: __.Association.to<Transaction> | null;
        transaction_ID?: string | null;
        segments?: __.Composition.of.many<TransactionSegments>;
        ID?: __.Key<string>;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        status?: _.TransactionResultStatus;
        transaction?: __.Association.to<Transaction> | null;
        transaction_ID?: string | null;
        segments?: __.Composition.of.many<TransactionSegments>;
        ID?: __.Key<string>;
    }>;
    readonly actions: typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const TransactionResult_base: {
    new (...args: any[]): {
        status?: _.TransactionResultStatus;
        transaction?: __.Association.to<Transaction> | null;
        transaction_ID?: string | null;
        segments?: __.Composition.of.many<TransactionSegments>;
        ID?: __.Key<string>;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        status?: _.TransactionResultStatus;
        transaction?: __.Association.to<Transaction> | null;
        transaction_ID?: string | null;
        segments?: __.Composition.of.many<TransactionSegments>;
        ID?: __.Key<string>;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        status?: _.TransactionResultStatus;
        transaction?: __.Association.to<Transaction> | null;
        transaction_ID?: string | null;
        segments?: __.Composition.of.many<TransactionSegments>;
        ID?: __.Key<string>;
    }>;
    readonly actions: typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Transaction execution result */
export declare class TransactionResult extends TransactionResult_base {
}
/** Transaction execution result */
export declare class TransactionResults extends Array<TransactionResult> {
    $count?: number;
}
export declare function _TransactionSegmentAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        segmentId?: number;
        success?: boolean;
        transactionResult?: __.Association.to<TransactionResult> | null;
        transactionResult_ID?: string | null;
        ID?: __.Key<string>;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        segmentId?: number;
        success?: boolean;
        transactionResult?: __.Association.to<TransactionResult> | null;
        transactionResult_ID?: string | null;
        ID?: __.Key<string>;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        segmentId?: number;
        success?: boolean;
        transactionResult?: __.Association.to<TransactionResult> | null;
        transactionResult_ID?: string | null;
        ID?: __.Key<string>;
    }>;
    readonly actions: typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const TransactionSegment_base: {
    new (...args: any[]): {
        segmentId?: number;
        success?: boolean;
        transactionResult?: __.Association.to<TransactionResult> | null;
        transactionResult_ID?: string | null;
        ID?: __.Key<string>;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        segmentId?: number;
        success?: boolean;
        transactionResult?: __.Association.to<TransactionResult> | null;
        transactionResult_ID?: string | null;
        ID?: __.Key<string>;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        segmentId?: number;
        success?: boolean;
        transactionResult?: __.Association.to<TransactionResult> | null;
        transactionResult_ID?: string | null;
        ID?: __.Key<string>;
    }>;
    readonly actions: typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Segment of a transaction result (for partial success) */
export declare class TransactionSegment extends TransactionSegment_base {
}
/** Segment of a transaction result (for partial success) */
export declare class TransactionSegments extends Array<TransactionSegment> {
    $count?: number;
}
export declare function _TransactionFeeAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        paidFees?: _.BigInt;
        estimatedFees?: _.BigInt;
        transaction?: __.Association.to<Transaction> | null;
        transaction_ID?: string | null;
        ID?: __.Key<string>;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        paidFees?: _.BigInt;
        estimatedFees?: _.BigInt;
        transaction?: __.Association.to<Transaction> | null;
        transaction_ID?: string | null;
        ID?: __.Key<string>;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        paidFees?: _.BigInt;
        estimatedFees?: _.BigInt;
        transaction?: __.Association.to<Transaction> | null;
        transaction_ID?: string | null;
        ID?: __.Key<string>;
    }>;
    readonly actions: typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const TransactionFee_base: {
    new (...args: any[]): {
        paidFees?: _.BigInt;
        estimatedFees?: _.BigInt;
        transaction?: __.Association.to<Transaction> | null;
        transaction_ID?: string | null;
        ID?: __.Key<string>;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        paidFees?: _.BigInt;
        estimatedFees?: _.BigInt;
        transaction?: __.Association.to<Transaction> | null;
        transaction_ID?: string | null;
        ID?: __.Key<string>;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        paidFees?: _.BigInt;
        estimatedFees?: _.BigInt;
        transaction?: __.Association.to<Transaction> | null;
        transaction_ID?: string | null;
        ID?: __.Key<string>;
    }>;
    readonly actions: typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Transaction fee information */
export declare class TransactionFee extends TransactionFee_base {
}
/** Transaction fee information */
export declare class TransactionFees extends Array<TransactionFee> {
    $count?: number;
}
export declare function _ContractActionAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        address?: _.HexEncoded;
        state?: import("stream").Readable | null;
        zswapState?: import("stream").Readable | null;
        actionType?: _.ContractActionType;
        entryPoint?: string | null;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        deploy?: __.Association.to</*elided*/ any> | null;
        deploy_ID?: string | null;
        unshieldedBalances?: __.Composition.of.many<ContractBalances>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        address?: _.HexEncoded;
        state?: import("stream").Readable | null;
        zswapState?: import("stream").Readable | null;
        actionType?: _.ContractActionType;
        entryPoint?: string | null;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        deploy?: __.Association.to</*elided*/ any> | null;
        deploy_ID?: string | null;
        unshieldedBalances?: __.Composition.of.many<ContractBalances>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        address?: _.HexEncoded;
        state?: import("stream").Readable | null;
        zswapState?: import("stream").Readable | null;
        actionType?: _.ContractActionType;
        entryPoint?: string | null;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        deploy?: __.Association.to</*elided*/ any> | null;
        deploy_ID?: string | null;
        unshieldedBalances?: __.Composition.of.many<ContractBalances>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const ContractAction_base: {
    new (...args: any[]): {
        address?: _.HexEncoded;
        state?: import("stream").Readable | null;
        zswapState?: import("stream").Readable | null;
        actionType?: _.ContractActionType;
        entryPoint?: string | null;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        deploy?: /*elided*/ any | null | undefined;
        deploy_ID?: string | null;
        unshieldedBalances?: __.Composition.of.many<ContractBalances>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        address?: _.HexEncoded;
        state?: import("stream").Readable | null;
        zswapState?: import("stream").Readable | null;
        actionType?: _.ContractActionType;
        entryPoint?: string | null;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        deploy?: /*elided*/ any | null | undefined;
        deploy_ID?: string | null;
        unshieldedBalances?: __.Composition.of.many<ContractBalances>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        address?: _.HexEncoded;
        state?: import("stream").Readable | null;
        zswapState?: import("stream").Readable | null;
        actionType?: _.ContractActionType;
        entryPoint?: string | null;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        deploy?: /*elided*/ any | null | undefined;
        deploy_ID?: string | null;
        unshieldedBalances?: __.Composition.of.many<ContractBalances>;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Contract actions (Deploy, Call, Update) */
export declare class ContractAction extends ContractAction_base {
}
/** Contract actions (Deploy, Call, Update) */
export declare class ContractActions extends Array<ContractAction> {
    $count?: number;
}
export declare function _ContractBalanceAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        tokenType?: _.HexEncoded;
        amount?: _.BigInt;
        contractAction?: __.Association.to<ContractAction> | null;
        contractAction_ID?: string | null;
        ID?: __.Key<string>;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        tokenType?: _.HexEncoded;
        amount?: _.BigInt;
        contractAction?: __.Association.to<ContractAction> | null;
        contractAction_ID?: string | null;
        ID?: __.Key<string>;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        tokenType?: _.HexEncoded;
        amount?: _.BigInt;
        contractAction?: __.Association.to<ContractAction> | null;
        contractAction_ID?: string | null;
        ID?: __.Key<string>;
    }>;
    readonly actions: typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const ContractBalance_base: {
    new (...args: any[]): {
        tokenType?: _.HexEncoded;
        amount?: _.BigInt;
        contractAction?: __.Association.to<ContractAction> | null;
        contractAction_ID?: string | null;
        ID?: __.Key<string>;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        tokenType?: _.HexEncoded;
        amount?: _.BigInt;
        contractAction?: __.Association.to<ContractAction> | null;
        contractAction_ID?: string | null;
        ID?: __.Key<string>;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        tokenType?: _.HexEncoded;
        amount?: _.BigInt;
        contractAction?: __.Association.to<ContractAction> | null;
        contractAction_ID?: string | null;
        ID?: __.Key<string>;
    }>;
    readonly actions: typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Token balances for contracts */
export declare class ContractBalance extends ContractBalance_base {
}
/** Token balances for contracts */
export declare class ContractBalances extends Array<ContractBalance> {
    $count?: number;
}
export declare function _UnshieldedUtxoAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        owner?: _.UnshieldedAddr;
        tokenType?: _.HexEncoded;
        value?: _.BigInt;
        intentHash?: _.HexEncoded;
        outputIndex?: number;
        ctime?: number | null;
        initialNonce?: _.HexEncoded;
        registeredForDustGeneration?: boolean | null;
        createdAtTransaction?: __.Association.to<Transaction>;
        createdAtTransaction_ID?: string;
        spentAtTransaction?: __.Association.to<Transaction> | null;
        spentAtTransaction_ID?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        owner?: _.UnshieldedAddr;
        tokenType?: _.HexEncoded;
        value?: _.BigInt;
        intentHash?: _.HexEncoded;
        outputIndex?: number;
        ctime?: number | null;
        initialNonce?: _.HexEncoded;
        registeredForDustGeneration?: boolean | null;
        createdAtTransaction?: __.Association.to<Transaction>;
        createdAtTransaction_ID?: string;
        spentAtTransaction?: __.Association.to<Transaction> | null;
        spentAtTransaction_ID?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        owner?: _.UnshieldedAddr;
        tokenType?: _.HexEncoded;
        value?: _.BigInt;
        intentHash?: _.HexEncoded;
        outputIndex?: number;
        ctime?: number | null;
        initialNonce?: _.HexEncoded;
        registeredForDustGeneration?: boolean | null;
        createdAtTransaction?: __.Association.to<Transaction>;
        createdAtTransaction_ID?: string;
        spentAtTransaction?: __.Association.to<Transaction> | null;
        spentAtTransaction_ID?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const UnshieldedUtxo_base: {
    new (...args: any[]): {
        owner?: _.UnshieldedAddr;
        tokenType?: _.HexEncoded;
        value?: _.BigInt;
        intentHash?: _.HexEncoded;
        outputIndex?: number;
        ctime?: number | null;
        initialNonce?: _.HexEncoded;
        registeredForDustGeneration?: boolean | null;
        createdAtTransaction?: __.Association.to<Transaction>;
        createdAtTransaction_ID?: string;
        spentAtTransaction?: __.Association.to<Transaction> | null;
        spentAtTransaction_ID?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        owner?: _.UnshieldedAddr;
        tokenType?: _.HexEncoded;
        value?: _.BigInt;
        intentHash?: _.HexEncoded;
        outputIndex?: number;
        ctime?: number | null;
        initialNonce?: _.HexEncoded;
        registeredForDustGeneration?: boolean | null;
        createdAtTransaction?: __.Association.to<Transaction>;
        createdAtTransaction_ID?: string;
        spentAtTransaction?: __.Association.to<Transaction> | null;
        spentAtTransaction_ID?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        owner?: _.UnshieldedAddr;
        tokenType?: _.HexEncoded;
        value?: _.BigInt;
        intentHash?: _.HexEncoded;
        outputIndex?: number;
        ctime?: number | null;
        initialNonce?: _.HexEncoded;
        registeredForDustGeneration?: boolean | null;
        createdAtTransaction?: __.Association.to<Transaction>;
        createdAtTransaction_ID?: string;
        spentAtTransaction?: __.Association.to<Transaction> | null;
        spentAtTransaction_ID?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Unshielded Unspent Transaction Outputs */
export declare class UnshieldedUtxo extends UnshieldedUtxo_base {
}
/** Unshielded Unspent Transaction Outputs */
export declare class UnshieldedUtxos extends Array<UnshieldedUtxo> {
    $count?: number;
}
export declare function _ZswapLedgerEventAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        eventId?: number;
        raw?: import("stream").Readable | null;
        maxId?: number;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        ID?: __.Key<string>;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        eventId?: number;
        raw?: import("stream").Readable | null;
        maxId?: number;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        ID?: __.Key<string>;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        eventId?: number;
        raw?: import("stream").Readable | null;
        maxId?: number;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        ID?: __.Key<string>;
    }>;
    readonly actions: typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const ZswapLedgerEvent_base: {
    new (...args: any[]): {
        eventId?: number;
        raw?: import("stream").Readable | null;
        maxId?: number;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        ID?: __.Key<string>;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        eventId?: number;
        raw?: import("stream").Readable | null;
        maxId?: number;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        ID?: __.Key<string>;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        eventId?: number;
        raw?: import("stream").Readable | null;
        maxId?: number;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        ID?: __.Key<string>;
    }>;
    readonly actions: typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Zswap Ledger Events */
export declare class ZswapLedgerEvent extends ZswapLedgerEvent_base {
}
/** Zswap Ledger Events */
export declare class ZswapLedgerEvents extends Array<ZswapLedgerEvent> {
    $count?: number;
}
export declare function _DustLedgerEventAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        eventId?: number;
        raw?: import("stream").Readable | null;
        maxId?: number;
        eventType?: _.DustLedgerEventType;
        dustOutputNonce?: _.HexEncoded | null;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        ID?: __.Key<string>;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        eventId?: number;
        raw?: import("stream").Readable | null;
        maxId?: number;
        eventType?: _.DustLedgerEventType;
        dustOutputNonce?: _.HexEncoded | null;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        ID?: __.Key<string>;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        eventId?: number;
        raw?: import("stream").Readable | null;
        maxId?: number;
        eventType?: _.DustLedgerEventType;
        dustOutputNonce?: _.HexEncoded | null;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        ID?: __.Key<string>;
    }>;
    readonly actions: typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const DustLedgerEvent_base: {
    new (...args: any[]): {
        eventId?: number;
        raw?: import("stream").Readable | null;
        maxId?: number;
        eventType?: _.DustLedgerEventType;
        dustOutputNonce?: _.HexEncoded | null;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        ID?: __.Key<string>;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        eventId?: number;
        raw?: import("stream").Readable | null;
        maxId?: number;
        eventType?: _.DustLedgerEventType;
        dustOutputNonce?: _.HexEncoded | null;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        ID?: __.Key<string>;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        eventId?: number;
        raw?: import("stream").Readable | null;
        maxId?: number;
        eventType?: _.DustLedgerEventType;
        dustOutputNonce?: _.HexEncoded | null;
        transaction?: __.Association.to<Transaction>;
        transaction_ID?: string;
        ID?: __.Key<string>;
    }>;
    readonly actions: typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** DUST Ledger Events */
export declare class DustLedgerEvent extends DustLedgerEvent_base {
}
/** DUST Ledger Events */
export declare class DustLedgerEvents extends Array<DustLedgerEvent> {
    $count?: number;
}
export declare function _WalletSessionAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        viewingKeyHash?: string | null;
        encryptedViewingKey?: string | null;
        encryptedSeedKey?: string | null;
        sessionId?: string;
        connectedAt?: __.CdsTimestamp;
        disconnectedAt?: __.CdsTimestamp | null;
        expiresAt?: __.CdsTimestamp | null;
        isActive?: boolean | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        viewingKeyHash?: string | null;
        encryptedViewingKey?: string | null;
        encryptedSeedKey?: string | null;
        sessionId?: string;
        connectedAt?: __.CdsTimestamp;
        disconnectedAt?: __.CdsTimestamp | null;
        expiresAt?: __.CdsTimestamp | null;
        isActive?: boolean | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        viewingKeyHash?: string | null;
        encryptedViewingKey?: string | null;
        encryptedSeedKey?: string | null;
        sessionId?: string;
        connectedAt?: __.CdsTimestamp;
        disconnectedAt?: __.CdsTimestamp | null;
        expiresAt?: __.CdsTimestamp | null;
        isActive?: boolean | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const WalletSession_base: {
    new (...args: any[]): {
        viewingKeyHash?: string | null;
        encryptedViewingKey?: string | null;
        encryptedSeedKey?: string | null;
        sessionId?: string;
        connectedAt?: __.CdsTimestamp;
        disconnectedAt?: __.CdsTimestamp | null;
        expiresAt?: __.CdsTimestamp | null;
        isActive?: boolean | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        viewingKeyHash?: string | null;
        encryptedViewingKey?: string | null;
        encryptedSeedKey?: string | null;
        sessionId?: string;
        connectedAt?: __.CdsTimestamp;
        disconnectedAt?: __.CdsTimestamp | null;
        expiresAt?: __.CdsTimestamp | null;
        isActive?: boolean | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        viewingKeyHash?: string | null;
        encryptedViewingKey?: string | null;
        encryptedSeedKey?: string | null;
        sessionId?: string;
        connectedAt?: __.CdsTimestamp;
        disconnectedAt?: __.CdsTimestamp | null;
        expiresAt?: __.CdsTimestamp | null;
        isActive?: boolean | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Wallet sessions for authenticated access. */
export declare class WalletSession extends WalletSession_base {
}
/** Wallet sessions for authenticated access. */
export declare class WalletSessions extends Array<WalletSession> {
    $count?: number;
}
export declare function _SyncStateAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        ID?: __.Key<string>;
        networkId?: string | null;
        lastIndexedHeight?: number | null;
        lastIndexedHash?: _.HexEncoded | null;
        lastIndexedAt?: __.CdsTimestamp | null;
        lastFinalizedHeight?: number | null;
        lastFinalizedHash?: _.HexEncoded | null;
        nodeUrl?: string | null;
        chainHeight?: number | null;
        syncStatus?: _.SyncStatus | null;
        syncProgress?: number | null;
        blocksPerSecond?: number | null;
        lastError?: string | null;
        lastErrorAt?: __.CdsTimestamp | null;
        consecutiveErrors?: number | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        ID?: __.Key<string>;
        networkId?: string | null;
        lastIndexedHeight?: number | null;
        lastIndexedHash?: _.HexEncoded | null;
        lastIndexedAt?: __.CdsTimestamp | null;
        lastFinalizedHeight?: number | null;
        lastFinalizedHash?: _.HexEncoded | null;
        nodeUrl?: string | null;
        chainHeight?: number | null;
        syncStatus?: _.SyncStatus | null;
        syncProgress?: number | null;
        blocksPerSecond?: number | null;
        lastError?: string | null;
        lastErrorAt?: __.CdsTimestamp | null;
        consecutiveErrors?: number | null;
    }>;
    readonly elements: __.ElementsOf<{
        ID?: __.Key<string>;
        networkId?: string | null;
        lastIndexedHeight?: number | null;
        lastIndexedHash?: _.HexEncoded | null;
        lastIndexedAt?: __.CdsTimestamp | null;
        lastFinalizedHeight?: number | null;
        lastFinalizedHash?: _.HexEncoded | null;
        nodeUrl?: string | null;
        chainHeight?: number | null;
        syncStatus?: _.SyncStatus | null;
        syncProgress?: number | null;
        blocksPerSecond?: number | null;
        lastError?: string | null;
        lastErrorAt?: __.CdsTimestamp | null;
        consecutiveErrors?: number | null;
    }>;
    readonly actions: globalThis.Record<never, never>;
} & TBase;
declare const SyncState_base: {
    new (...args: any[]): {
        ID?: __.Key<string>;
        networkId?: string | null;
        lastIndexedHeight?: number | null;
        lastIndexedHash?: _.HexEncoded | null;
        lastIndexedAt?: __.CdsTimestamp | null;
        lastFinalizedHeight?: number | null;
        lastFinalizedHash?: _.HexEncoded | null;
        nodeUrl?: string | null;
        chainHeight?: number | null;
        syncStatus?: _.SyncStatus | null;
        syncProgress?: number | null;
        blocksPerSecond?: number | null;
        lastError?: string | null;
        lastErrorAt?: __.CdsTimestamp | null;
        consecutiveErrors?: number | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        ID?: __.Key<string>;
        networkId?: string | null;
        lastIndexedHeight?: number | null;
        lastIndexedHash?: _.HexEncoded | null;
        lastIndexedAt?: __.CdsTimestamp | null;
        lastFinalizedHeight?: number | null;
        lastFinalizedHash?: _.HexEncoded | null;
        nodeUrl?: string | null;
        chainHeight?: number | null;
        syncStatus?: _.SyncStatus | null;
        syncProgress?: number | null;
        blocksPerSecond?: number | null;
        lastError?: string | null;
        lastErrorAt?: __.CdsTimestamp | null;
        consecutiveErrors?: number | null;
    }>;
    readonly elements: __.ElementsOf<{
        ID?: __.Key<string>;
        networkId?: string | null;
        lastIndexedHeight?: number | null;
        lastIndexedHash?: _.HexEncoded | null;
        lastIndexedAt?: __.CdsTimestamp | null;
        lastFinalizedHeight?: number | null;
        lastFinalizedHash?: _.HexEncoded | null;
        nodeUrl?: string | null;
        chainHeight?: number | null;
        syncStatus?: _.SyncStatus | null;
        syncProgress?: number | null;
        blocksPerSecond?: number | null;
        lastError?: string | null;
        lastErrorAt?: __.CdsTimestamp | null;
        consecutiveErrors?: number | null;
    }>;
    readonly actions: globalThis.Record<never, never>;
} & typeof __.Entity;
/** Indexer sync status, singleton table tracking crawler progress */
export declare class SyncState extends SyncState_base {
}
/** Indexer sync status, singleton table tracking crawler progress */
export declare class SyncState_ extends Array<SyncState> {
    $count?: number;
}
export declare function _ReorgLogAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        detectedAt?: __.CdsTimestamp;
        forkHeight?: number;
        oldTipHash?: _.HexEncoded;
        newTipHash?: _.HexEncoded;
        blocksRolledBack?: number | null;
        blocksReIndexed?: number | null;
        status?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        detectedAt?: __.CdsTimestamp;
        forkHeight?: number;
        oldTipHash?: _.HexEncoded;
        newTipHash?: _.HexEncoded;
        blocksRolledBack?: number | null;
        blocksReIndexed?: number | null;
        status?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        detectedAt?: __.CdsTimestamp;
        forkHeight?: number;
        oldTipHash?: _.HexEncoded;
        newTipHash?: _.HexEncoded;
        blocksRolledBack?: number | null;
        blocksReIndexed?: number | null;
        status?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const ReorgLog_base: {
    new (...args: any[]): {
        detectedAt?: __.CdsTimestamp;
        forkHeight?: number;
        oldTipHash?: _.HexEncoded;
        newTipHash?: _.HexEncoded;
        blocksRolledBack?: number | null;
        blocksReIndexed?: number | null;
        status?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        detectedAt?: __.CdsTimestamp;
        forkHeight?: number;
        oldTipHash?: _.HexEncoded;
        newTipHash?: _.HexEncoded;
        blocksRolledBack?: number | null;
        blocksReIndexed?: number | null;
        status?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        detectedAt?: __.CdsTimestamp;
        forkHeight?: number;
        oldTipHash?: _.HexEncoded;
        newTipHash?: _.HexEncoded;
        blocksRolledBack?: number | null;
        blocksReIndexed?: number | null;
        status?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Reorg history, tracks blockchain reorganizations detected by the crawler */
export declare class ReorgLog extends ReorgLog_base {
}
/** Reorg history, tracks blockchain reorganizations detected by the crawler */
export declare class ReorgLog_ extends Array<ReorgLog> {
    $count?: number;
}
export declare function _PendingSubmissionAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        txHash?: _.HexEncoded | null;
        contractAddress?: _.HexEncoded | null;
        circuitName?: string | null;
        actionType?: _.ContractActionType;
        submittedAt?: __.CdsTimestamp;
        status?: _.PendingSubmissionStatus | null;
        finalizedAt?: __.CdsTimestamp | null;
        finalizedTxData?: string | null;
        errorCode?: string | null;
        errorMessage?: string | null;
        sessionId?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        txHash?: _.HexEncoded | null;
        contractAddress?: _.HexEncoded | null;
        circuitName?: string | null;
        actionType?: _.ContractActionType;
        submittedAt?: __.CdsTimestamp;
        status?: _.PendingSubmissionStatus | null;
        finalizedAt?: __.CdsTimestamp | null;
        finalizedTxData?: string | null;
        errorCode?: string | null;
        errorMessage?: string | null;
        sessionId?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        txHash?: _.HexEncoded | null;
        contractAddress?: _.HexEncoded | null;
        circuitName?: string | null;
        actionType?: _.ContractActionType;
        submittedAt?: __.CdsTimestamp;
        status?: _.PendingSubmissionStatus | null;
        finalizedAt?: __.CdsTimestamp | null;
        finalizedTxData?: string | null;
        errorCode?: string | null;
        errorMessage?: string | null;
        sessionId?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const PendingSubmission_base: {
    new (...args: any[]): {
        txHash?: _.HexEncoded | null;
        contractAddress?: _.HexEncoded | null;
        circuitName?: string | null;
        actionType?: _.ContractActionType;
        submittedAt?: __.CdsTimestamp;
        status?: _.PendingSubmissionStatus | null;
        finalizedAt?: __.CdsTimestamp | null;
        finalizedTxData?: string | null;
        errorCode?: string | null;
        errorMessage?: string | null;
        sessionId?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        txHash?: _.HexEncoded | null;
        contractAddress?: _.HexEncoded | null;
        circuitName?: string | null;
        actionType?: _.ContractActionType;
        submittedAt?: __.CdsTimestamp;
        status?: _.PendingSubmissionStatus | null;
        finalizedAt?: __.CdsTimestamp | null;
        finalizedTxData?: string | null;
        errorCode?: string | null;
        errorMessage?: string | null;
        sessionId?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        txHash?: _.HexEncoded | null;
        contractAddress?: _.HexEncoded | null;
        circuitName?: string | null;
        actionType?: _.ContractActionType;
        submittedAt?: __.CdsTimestamp;
        status?: _.PendingSubmissionStatus | null;
        finalizedAt?: __.CdsTimestamp | null;
        finalizedTxData?: string | null;
        errorCode?: string | null;
        errorMessage?: string | null;
        sessionId?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Tracks transactions submitted through NIGHTGATE's submission path */
export declare class PendingSubmission extends PendingSubmission_base {
}
/** Tracks transactions submitted through NIGHTGATE's submission path */
export declare class PendingSubmissions extends Array<PendingSubmission> {
    $count?: number;
}
export declare function _BackgroundJobAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        kind?: _.BackgroundJobKind;
        sessionId?: string | null;
        status?: _.BackgroundJobStatus | null;
        idempotencyKey?: string | null;
        request?: string | null;
        result?: string | null;
        errorCode?: string | null;
        errorMessage?: string | null;
        startedAt?: __.CdsTimestamp | null;
        finishedAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        kind?: _.BackgroundJobKind;
        sessionId?: string | null;
        status?: _.BackgroundJobStatus | null;
        idempotencyKey?: string | null;
        request?: string | null;
        result?: string | null;
        errorCode?: string | null;
        errorMessage?: string | null;
        startedAt?: __.CdsTimestamp | null;
        finishedAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        kind?: _.BackgroundJobKind;
        sessionId?: string | null;
        status?: _.BackgroundJobStatus | null;
        idempotencyKey?: string | null;
        request?: string | null;
        result?: string | null;
        errorCode?: string | null;
        errorMessage?: string | null;
        startedAt?: __.CdsTimestamp | null;
        finishedAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const BackgroundJob_base: {
    new (...args: any[]): {
        kind?: _.BackgroundJobKind;
        sessionId?: string | null;
        status?: _.BackgroundJobStatus | null;
        idempotencyKey?: string | null;
        request?: string | null;
        result?: string | null;
        errorCode?: string | null;
        errorMessage?: string | null;
        startedAt?: __.CdsTimestamp | null;
        finishedAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        kind?: _.BackgroundJobKind;
        sessionId?: string | null;
        status?: _.BackgroundJobStatus | null;
        idempotencyKey?: string | null;
        request?: string | null;
        result?: string | null;
        errorCode?: string | null;
        errorMessage?: string | null;
        startedAt?: __.CdsTimestamp | null;
        finishedAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        kind?: _.BackgroundJobKind;
        sessionId?: string | null;
        status?: _.BackgroundJobStatus | null;
        idempotencyKey?: string | null;
        request?: string | null;
        result?: string | null;
        errorCode?: string | null;
        errorMessage?: string | null;
        startedAt?: __.CdsTimestamp | null;
        finishedAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Backgroundjobs for diffrent purposes */
export declare class BackgroundJob extends BackgroundJob_base {
}
/** Backgroundjobs for diffrent purposes */
export declare class BackgroundJobs extends Array<BackgroundJob> {
    $count?: number;
}
export declare function _PrivateStateAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        accountId?: __.Key<string>;
        contractAddress?: __.Key<string>;
        privateStateId?: __.Key<string>;
        ciphertext?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        accountId?: __.Key<string>;
        contractAddress?: __.Key<string>;
        privateStateId?: __.Key<string>;
        ciphertext?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    }>;
    readonly elements: __.ElementsOf<{
        accountId?: __.Key<string>;
        contractAddress?: __.Key<string>;
        privateStateId?: __.Key<string>;
        ciphertext?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    }>;
    readonly actions: globalThis.Record<never, never>;
} & TBase;
declare const PrivateState_base: {
    new (...args: any[]): {
        accountId?: __.Key<string>;
        contractAddress?: __.Key<string>;
        privateStateId?: __.Key<string>;
        ciphertext?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        accountId?: __.Key<string>;
        contractAddress?: __.Key<string>;
        privateStateId?: __.Key<string>;
        ciphertext?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    }>;
    readonly elements: __.ElementsOf<{
        accountId?: __.Key<string>;
        contractAddress?: __.Key<string>;
        privateStateId?: __.Key<string>;
        ciphertext?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    }>;
    readonly actions: globalThis.Record<never, never>;
} & typeof __.Entity;
/** Encrypted private states held on behalf of authenticated wallet sessions. */
export declare class PrivateState extends PrivateState_base {
}
/** Encrypted private states held on behalf of authenticated wallet sessions. */
export declare class PrivateStates extends Array<PrivateState> {
    $count?: number;
}
export declare function _ContractSigningKeyAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        accountId?: __.Key<string>;
        contractAddress?: __.Key<string>;
        ciphertext?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        accountId?: __.Key<string>;
        contractAddress?: __.Key<string>;
        ciphertext?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    }>;
    readonly elements: __.ElementsOf<{
        accountId?: __.Key<string>;
        contractAddress?: __.Key<string>;
        ciphertext?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    }>;
    readonly actions: globalThis.Record<never, never>;
} & TBase;
declare const ContractSigningKey_base: {
    new (...args: any[]): {
        accountId?: __.Key<string>;
        contractAddress?: __.Key<string>;
        ciphertext?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        accountId?: __.Key<string>;
        contractAddress?: __.Key<string>;
        ciphertext?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    }>;
    readonly elements: __.ElementsOf<{
        accountId?: __.Key<string>;
        contractAddress?: __.Key<string>;
        ciphertext?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    }>;
    readonly actions: globalThis.Record<never, never>;
} & typeof __.Entity;
/** Encrypted contract signing keys, scoped per (accountId, contractAddress) */
export declare class ContractSigningKey extends ContractSigningKey_base {
}
/** Encrypted contract signing keys, scoped per (accountId, contractAddress) */
export declare class ContractSigningKeys extends Array<ContractSigningKey> {
    $count?: number;
}
export declare function _WalletSyncStateAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        accountId?: __.Key<string>;
        shieldedStateBlob?: string | null;
        unshieldedStateBlob?: string | null;
        dustStateBlob?: string | null;
        sdkVersion?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        accountId?: __.Key<string>;
        shieldedStateBlob?: string | null;
        unshieldedStateBlob?: string | null;
        dustStateBlob?: string | null;
        sdkVersion?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    }>;
    readonly elements: __.ElementsOf<{
        accountId?: __.Key<string>;
        shieldedStateBlob?: string | null;
        unshieldedStateBlob?: string | null;
        dustStateBlob?: string | null;
        sdkVersion?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    }>;
    readonly actions: globalThis.Record<never, never>;
} & TBase;
declare const WalletSyncState_base: {
    new (...args: any[]): {
        accountId?: __.Key<string>;
        shieldedStateBlob?: string | null;
        unshieldedStateBlob?: string | null;
        dustStateBlob?: string | null;
        sdkVersion?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        accountId?: __.Key<string>;
        shieldedStateBlob?: string | null;
        unshieldedStateBlob?: string | null;
        dustStateBlob?: string | null;
        sdkVersion?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    }>;
    readonly elements: __.ElementsOf<{
        accountId?: __.Key<string>;
        shieldedStateBlob?: string | null;
        unshieldedStateBlob?: string | null;
        dustStateBlob?: string | null;
        sdkVersion?: string;
        createdAt?: __.CdsTimestamp | null;
        updatedAt?: __.CdsTimestamp | null;
    }>;
    readonly actions: globalThis.Record<never, never>;
} & typeof __.Entity;
/** Persisted wallet sub-state, one row per session (accountId) */
export declare class WalletSyncState extends WalletSyncState_base {
}
/** Persisted wallet sub-state, one row per session (accountId) */
export declare class WalletSyncStates extends Array<WalletSyncState> {
    $count?: number;
}
export declare function _AttestationAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        attestationId?: _.HexEncoded;
        contractAddress?: _.HexEncoded;
        attester?: _.HexEncoded;
        publicMetadata?: string | null;
        payloadCipher?: import("stream").Readable | null;
        anchoredTxHash?: _.HexEncoded | null;
        anchoredAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        attestationId?: _.HexEncoded;
        contractAddress?: _.HexEncoded;
        attester?: _.HexEncoded;
        publicMetadata?: string | null;
        payloadCipher?: import("stream").Readable | null;
        anchoredTxHash?: _.HexEncoded | null;
        anchoredAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        attestationId?: _.HexEncoded;
        contractAddress?: _.HexEncoded;
        attester?: _.HexEncoded;
        publicMetadata?: string | null;
        payloadCipher?: import("stream").Readable | null;
        anchoredTxHash?: _.HexEncoded | null;
        anchoredAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const Attestation_base: {
    new (...args: any[]): {
        attestationId?: _.HexEncoded;
        contractAddress?: _.HexEncoded;
        attester?: _.HexEncoded;
        publicMetadata?: string | null;
        payloadCipher?: import("stream").Readable | null;
        anchoredTxHash?: _.HexEncoded | null;
        anchoredAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        attestationId?: _.HexEncoded;
        contractAddress?: _.HexEncoded;
        attester?: _.HexEncoded;
        publicMetadata?: string | null;
        payloadCipher?: import("stream").Readable | null;
        anchoredTxHash?: _.HexEncoded | null;
        anchoredAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        attestationId?: _.HexEncoded;
        contractAddress?: _.HexEncoded;
        attester?: _.HexEncoded;
        publicMetadata?: string | null;
        payloadCipher?: import("stream").Readable | null;
        anchoredTxHash?: _.HexEncoded | null;
        anchoredAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Attestations recorded on-chain via the AttestationVault Compact contract */
export declare class Attestation extends Attestation_base {
}
/** Attestations recorded on-chain via the AttestationVault Compact contract */
export declare class Attestations extends Array<Attestation> {
    $count?: number;
}
export declare function _DocumentAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        sha256?: _.HexEncoded;
        contentType?: string | null;
        size?: number | null;
        storageRef?: string | null;
        anchoredTxHash?: _.HexEncoded | null;
        anchoredAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        sha256?: _.HexEncoded;
        contentType?: string | null;
        size?: number | null;
        storageRef?: string | null;
        anchoredTxHash?: _.HexEncoded | null;
        anchoredAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        sha256?: _.HexEncoded;
        contentType?: string | null;
        size?: number | null;
        storageRef?: string | null;
        anchoredTxHash?: _.HexEncoded | null;
        anchoredAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const Document_base: {
    new (...args: any[]): {
        sha256?: _.HexEncoded;
        contentType?: string | null;
        size?: number | null;
        storageRef?: string | null;
        anchoredTxHash?: _.HexEncoded | null;
        anchoredAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        sha256?: _.HexEncoded;
        contentType?: string | null;
        size?: number | null;
        storageRef?: string | null;
        anchoredTxHash?: _.HexEncoded | null;
        anchoredAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        sha256?: _.HexEncoded;
        contentType?: string | null;
        size?: number | null;
        storageRef?: string | null;
        anchoredTxHash?: _.HexEncoded | null;
        anchoredAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Document anchoring */
export declare class Document extends Document_base {
}
/** Document anchoring */
export declare class Documents extends Array<Document> {
    $count?: number;
}
export declare function _PredicateAttestationAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        payloadHash?: _.HexEncoded;
        contractAddress?: _.HexEncoded;
        predicate?: string;
        op?: number;
        threshold?: number;
        unit?: string | null;
        valueCommitment?: _.HexEncoded | null;
        provenTxHash?: _.HexEncoded | null;
        provenAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        payloadHash?: _.HexEncoded;
        contractAddress?: _.HexEncoded;
        predicate?: string;
        op?: number;
        threshold?: number;
        unit?: string | null;
        valueCommitment?: _.HexEncoded | null;
        provenTxHash?: _.HexEncoded | null;
        provenAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        payloadHash?: _.HexEncoded;
        contractAddress?: _.HexEncoded;
        predicate?: string;
        op?: number;
        threshold?: number;
        unit?: string | null;
        valueCommitment?: _.HexEncoded | null;
        provenTxHash?: _.HexEncoded | null;
        provenAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const PredicateAttestation_base: {
    new (...args: any[]): {
        payloadHash?: _.HexEncoded;
        contractAddress?: _.HexEncoded;
        predicate?: string;
        op?: number;
        threshold?: number;
        unit?: string | null;
        valueCommitment?: _.HexEncoded | null;
        provenTxHash?: _.HexEncoded | null;
        provenAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        payloadHash?: _.HexEncoded;
        contractAddress?: _.HexEncoded;
        predicate?: string;
        op?: number;
        threshold?: number;
        unit?: string | null;
        valueCommitment?: _.HexEncoded | null;
        provenTxHash?: _.HexEncoded | null;
        provenAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        payloadHash?: _.HexEncoded;
        contractAddress?: _.HexEncoded;
        predicate?: string;
        op?: number;
        threshold?: number;
        unit?: string | null;
        valueCommitment?: _.HexEncoded | null;
        provenTxHash?: _.HexEncoded | null;
        provenAt?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** ZK predicate attestations */
export declare class PredicateAttestation extends PredicateAttestation_base {
}
/** ZK predicate attestations */
export declare class PredicateAttestations extends Array<PredicateAttestation> {
    $count?: number;
}
export declare function _DisclosureRoleAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        userId?: string;
        role?: _.DisclosureRole;
        scope?: string | null;
        grantedBy?: string | null;
        validFrom?: __.CdsTimestamp | null;
        validUntil?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        userId?: string;
        role?: _.DisclosureRole;
        scope?: string | null;
        grantedBy?: string | null;
        validFrom?: __.CdsTimestamp | null;
        validUntil?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        userId?: string;
        role?: _.DisclosureRole;
        scope?: string | null;
        grantedBy?: string | null;
        validFrom?: __.CdsTimestamp | null;
        validUntil?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const DisclosureRole_base: {
    new (...args: any[]): {
        userId?: string;
        role?: _.DisclosureRole;
        scope?: string | null;
        grantedBy?: string | null;
        validFrom?: __.CdsTimestamp | null;
        validUntil?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        userId?: string;
        role?: _.DisclosureRole;
        scope?: string | null;
        grantedBy?: string | null;
        validFrom?: __.CdsTimestamp | null;
        validUntil?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        userId?: string;
        role?: _.DisclosureRole;
        scope?: string | null;
        grantedBy?: string | null;
        validFrom?: __.CdsTimestamp | null;
        validUntil?: __.CdsTimestamp | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/** Disclosure role grants for tiered access */
export declare class DisclosureRole extends DisclosureRole_base {
}
/** Disclosure role grants for tiered access */
export declare class DisclosureRoles extends Array<DisclosureRole> {
    $count?: number;
}
export declare function _DisclosureGrantAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        payloadHash?: _.HexEncoded;
        grantee?: _.HexEncoded;
        level?: number;
        contractAddress?: _.HexEncoded;
        grantedTxHash?: _.HexEncoded | null;
        revokedTxHash?: _.HexEncoded | null;
        active?: boolean | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        payloadHash?: _.HexEncoded;
        grantee?: _.HexEncoded;
        level?: number;
        contractAddress?: _.HexEncoded;
        grantedTxHash?: _.HexEncoded | null;
        revokedTxHash?: _.HexEncoded | null;
        active?: boolean | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        payloadHash?: _.HexEncoded;
        grantee?: _.HexEncoded;
        level?: number;
        contractAddress?: _.HexEncoded;
        grantedTxHash?: _.HexEncoded | null;
        revokedTxHash?: _.HexEncoded | null;
        active?: boolean | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const DisclosureGrant_base: {
    new (...args: any[]): {
        payloadHash?: _.HexEncoded;
        grantee?: _.HexEncoded;
        level?: number;
        contractAddress?: _.HexEncoded;
        grantedTxHash?: _.HexEncoded | null;
        revokedTxHash?: _.HexEncoded | null;
        active?: boolean | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        payloadHash?: _.HexEncoded;
        grantee?: _.HexEncoded;
        level?: number;
        contractAddress?: _.HexEncoded;
        grantedTxHash?: _.HexEncoded | null;
        revokedTxHash?: _.HexEncoded | null;
        active?: boolean | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        payloadHash?: _.HexEncoded;
        grantee?: _.HexEncoded;
        level?: number;
        contractAddress?: _.HexEncoded;
        grantedTxHash?: _.HexEncoded | null;
        revokedTxHash?: _.HexEncoded | null;
        active?: boolean | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/**
* On-chain disclosure grants read off the AttestationVault `disclosures`
* ledger Map. Distinct from DisclosureRoles (off-chain, operator-configured):
* these are CHAIN-DERIVED entitlement records — the contract is the ACL.
*
* Rows are inserted optimistically (active=false) by `grantDisclosure` and
* confirmed/flipped by the chain indexer (Phase 2) once the grant appears in
* ledger state. Logical key for cross-contract reuse:
* (contractAddress, payloadHash, grantee). `level`: 0=public,
* 1=legitimate-interest, 2=authority.
*/
export declare class DisclosureGrant extends DisclosureGrant_base {
}
/**
* On-chain disclosure grants read off the AttestationVault `disclosures`
* ledger Map. Distinct from DisclosureRoles (off-chain, operator-configured):
* these are CHAIN-DERIVED entitlement records — the contract is the ACL.
*
* Rows are inserted optimistically (active=false) by `grantDisclosure` and
* confirmed/flipped by the chain indexer (Phase 2) once the grant appears in
* ledger state. Logical key for cross-contract reuse:
* (contractAddress, payloadHash, grantee). `level`: 0=public,
* 1=legitimate-interest, 2=authority.
*/
export declare class DisclosureGrants extends Array<DisclosureGrant> {
    $count?: number;
}
export declare function _GranteeIdentityAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        userId?: string;
        granteeId?: _.HexEncoded;
        bindingKind?: string;
        scope?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        userId?: string;
        granteeId?: _.HexEncoded;
        bindingKind?: string;
        scope?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & typeof _.cuid.keys;
    readonly elements: __.ElementsOf<{
        userId?: string;
        granteeId?: _.HexEncoded;
        bindingKind?: string;
        scope?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & TBase;
declare const GranteeIdentity_base: {
    new (...args: any[]): {
        userId?: string;
        granteeId?: _.HexEncoded;
        bindingKind?: string;
        scope?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        userId?: string;
        granteeId?: _.HexEncoded;
        bindingKind?: string;
        scope?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }> & __.KeysOf<{
        ID?: __.Key<string>;
    }>;
    readonly elements: __.ElementsOf<{
        userId?: string;
        granteeId?: _.HexEncoded;
        bindingKind?: string;
        scope?: string | null;
        ID?: __.Key<string>;
        createdAt?: __.CdsTimestamp | null;
        createdBy?: _.User | null;
        modifiedAt?: __.CdsTimestamp | null;
        modifiedBy?: _.User | null;
    }>;
    readonly actions: typeof _.managed.actions & typeof _.cuid.actions & globalThis.Record<never, never>;
} & typeof __.Entity;
/**
* Binds an authenticated principal (req.user.id) to the `Bytes<32>` grantee id
* the AttestationVault circuit checks, so the read gate can resolve
* principal → granteeId and match an on-chain DisclosureGrant (Phase 0 of
* expose-disclosure-grants). `bindingKind` records how the id was derived
* ('wallet' | 'did' | 'custom'); see srv/submission/grantee-identity.ts.
* Resolution mirrors DisclosureRoles scope precedence: a scoped row wins,
* else a global (null/empty scope) row applies.
*/
export declare class GranteeIdentity extends GranteeIdentity_base {
}
/**
* Binds an authenticated principal (req.user.id) to the `Bytes<32>` grantee id
* the AttestationVault circuit checks, so the read gate can resolve
* principal → granteeId and match an on-chain DisclosureGrant (Phase 0 of
* expose-disclosure-grants). `bindingKind` records how the id was derived
* ('wallet' | 'did' | 'custom'); see srv/submission/grantee-identity.ts.
* Resolution mirrors DisclosureRoles scope precedence: a scoped row wins,
* else a global (null/empty scope) row applies.
*/
export declare class GranteeIdentities extends Array<GranteeIdentity> {
    $count?: number;
}
export declare function _NightBalanceAspect<TBase extends new (...args: any[]) => object>(Base: TBase): {
    new (...args: any[]): {
        address?: __.Key<string>;
        balance?: number | null;
        utxoCount?: number | null;
        firstSeenHeight?: number | null;
        firstSeenAt?: __.CdsTimestamp | null;
        lastActivityHeight?: number | null;
        lastActivityAt?: __.CdsTimestamp | null;
        txSentCount?: number | null;
        txReceivedCount?: number | null;
        totalSent?: number | null;
        totalReceived?: number | null;
        dustAddress?: _.DustAddr | null;
        isDustRegistered?: boolean | null;
        lastUpdatedHeight?: number | null;
        lastUpdatedAt?: __.CdsTimestamp | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        address?: __.Key<string>;
        balance?: number | null;
        utxoCount?: number | null;
        firstSeenHeight?: number | null;
        firstSeenAt?: __.CdsTimestamp | null;
        lastActivityHeight?: number | null;
        lastActivityAt?: __.CdsTimestamp | null;
        txSentCount?: number | null;
        txReceivedCount?: number | null;
        totalSent?: number | null;
        totalReceived?: number | null;
        dustAddress?: _.DustAddr | null;
        isDustRegistered?: boolean | null;
        lastUpdatedHeight?: number | null;
        lastUpdatedAt?: __.CdsTimestamp | null;
    }>;
    readonly elements: __.ElementsOf<{
        address?: __.Key<string>;
        balance?: number | null;
        utxoCount?: number | null;
        firstSeenHeight?: number | null;
        firstSeenAt?: __.CdsTimestamp | null;
        lastActivityHeight?: number | null;
        lastActivityAt?: __.CdsTimestamp | null;
        txSentCount?: number | null;
        txReceivedCount?: number | null;
        totalSent?: number | null;
        totalReceived?: number | null;
        dustAddress?: _.DustAddr | null;
        isDustRegistered?: boolean | null;
        lastUpdatedHeight?: number | null;
        lastUpdatedAt?: __.CdsTimestamp | null;
    }>;
    readonly actions: globalThis.Record<never, never>;
} & TBase;
declare const NightBalance_base: {
    new (...args: any[]): {
        address?: __.Key<string>;
        balance?: number | null;
        utxoCount?: number | null;
        firstSeenHeight?: number | null;
        firstSeenAt?: __.CdsTimestamp | null;
        lastActivityHeight?: number | null;
        lastActivityAt?: __.CdsTimestamp | null;
        txSentCount?: number | null;
        txReceivedCount?: number | null;
        totalSent?: number | null;
        totalReceived?: number | null;
        dustAddress?: _.DustAddr | null;
        isDustRegistered?: boolean | null;
        lastUpdatedHeight?: number | null;
        lastUpdatedAt?: __.CdsTimestamp | null;
    };
    readonly kind: "entity" | "type" | "aspect";
    readonly keys: __.KeysOf<{
        address?: __.Key<string>;
        balance?: number | null;
        utxoCount?: number | null;
        firstSeenHeight?: number | null;
        firstSeenAt?: __.CdsTimestamp | null;
        lastActivityHeight?: number | null;
        lastActivityAt?: __.CdsTimestamp | null;
        txSentCount?: number | null;
        txReceivedCount?: number | null;
        totalSent?: number | null;
        totalReceived?: number | null;
        dustAddress?: _.DustAddr | null;
        isDustRegistered?: boolean | null;
        lastUpdatedHeight?: number | null;
        lastUpdatedAt?: __.CdsTimestamp | null;
    }>;
    readonly elements: __.ElementsOf<{
        address?: __.Key<string>;
        balance?: number | null;
        utxoCount?: number | null;
        firstSeenHeight?: number | null;
        firstSeenAt?: __.CdsTimestamp | null;
        lastActivityHeight?: number | null;
        lastActivityAt?: __.CdsTimestamp | null;
        txSentCount?: number | null;
        txReceivedCount?: number | null;
        totalSent?: number | null;
        totalReceived?: number | null;
        dustAddress?: _.DustAddr | null;
        isDustRegistered?: boolean | null;
        lastUpdatedHeight?: number | null;
        lastUpdatedAt?: __.CdsTimestamp | null;
    }>;
    readonly actions: globalThis.Record<never, never>;
} & typeof __.Entity;
/** Unshielded NIGHT token balances per address */
export declare class NightBalance extends NightBalance_base {
}
/** Unshielded NIGHT token balances per address */
export declare class NightBalances extends Array<NightBalance> {
    $count?: number;
}
export {};
