import type { ColdCode } from "../core/types.js";
/**
 * Supported initialization forms for Matter-derived primitives.
 *
 * Mirrors KERIpy behavior: construct from raw+code or from any qualified form
 * (`qb64`, `qb64b`, `qb2`).
 */
export interface MatterInit {
    raw?: Uint8Array;
    code?: string;
    qb64b?: Uint8Array;
    qb64?: string;
    qb2?: Uint8Array;
}
interface MatterData {
    code: string;
    raw: Uint8Array;
    qb64: string;
    fullSize: number;
    fullSizeB2: number;
}
/**
 * Base CESR primitive carrying qualified matter material.
 *
 * KERIpy substance: `Matter` is the foundational primitive abstraction that
 * handles exfil/infil between raw bytes and qualified CESR encodings and owns
 * the base derivation-code semantic projections shared by semantic subclasses.
 */
export declare class Matter {
    protected readonly _code: string;
    protected readonly _raw: Uint8Array;
    protected readonly _qb64: string;
    protected readonly _fullSize: number;
    protected readonly _fullSizeB2: number;
    constructor(init: Matter | MatterData | MatterInit);
    protected toMatterData(): MatterData;
    get code(): string;
    /** KERIpy parity alias: codex member name for this derivation code. */
    get name(): string;
    /** KERIpy parity alias: hard code portion of the qualified text code. */
    get hard(): string;
    /** Soft code portion exclusive of any prepad xtra characters. */
    get soft(): string;
    /**
     * KERIpy parity size projection.
     *
     * This follows KERIpy's generic `Matter.size` rule: decode the soft sextets
     * when present, otherwise return `null`.
     */
    get size(): number | null;
    /** Hard + padded-soft view of the full text code. */
    get both(): string;
    get raw(): Uint8Array;
    get qb64(): string;
    get qb64b(): Uint8Array;
    get qb2(): Uint8Array;
    get fullSize(): number;
    get fullSizeB2(): number;
    /** Generic KERIpy derivation-code transferability rule. */
    get transferable(): boolean;
    /** Generic KERIpy digest-family semantic projection. */
    get digestive(): boolean;
    /** Generic KERIpy identifier-prefix semantic projection. */
    get prefixive(): boolean;
    /** True when the code family carries fixed-size soft text metadata. */
    get special(): boolean;
    /** True when both qb64 and qb2 are 24-bit aligned and round-trip exactly. */
    get composable(): boolean;
    equals(other: {
        qb64: string;
    }): boolean;
    toString(): string;
    /** KERIpy parity helper: fixed raw size for one code. */
    static rawSizeForCode(code: string): number;
    /** KERIpy parity helper: fixed full qb64 size for one code. */
    static fullSizeForCode(code: string): number;
    /** KERIpy parity helper: lead-byte size for one code. */
    static leadSizeForCode(code: string): number;
}
/** Parse matter from text-domain CESR bytes. */
export declare function parseMatterFromText(input: Uint8Array): Matter;
/** Parse matter from binary-domain CESR bytes. */
export declare function parseMatterFromBinary(input: Uint8Array): Matter;
/** Parse matter using caller-provided cold-start domain hint (`txt` or `bny`). */
export declare function parseMatter(input: Uint8Array, cold: Extract<ColdCode, "txt" | "bny">): Matter;
export {};
//# sourceMappingURL=matter.d.ts.map