import { type TArg, type TRet } from '@noble/hashes/utils.js';
import * as P from 'micro-packed';
/**
 * ASN.1 OID coder without DER tag/length wrappers.
 * @example
 * Encode one ASN.1 object identifier without DER tag and length bytes.
 * ```ts
 * import { oid } from 'micro-key-producer/asn1.js';
 * oid.encode('1.3.6.1.4.1.11591.15.1');
 * ```
 */
export declare const oid: P.CoderType<string>;
/**
 * ASN.1 OID coder that decodes known OIDs to names and preserves unknown OIDs as raw dotted text.
 * @example
 * Encode a named OID and decode the same bytes back to its known name.
 * ```ts
 * import { oidName } from 'micro-key-producer/asn1.js';
 * oidName.decode(oidName.encode('signedData'));
 * ```
 */
export declare const oidName: P.CoderType<string>;
type ASN1DebugTag = {
    TAG: 'universal';
    data: {
        constructed: number;
        type: string;
    };
} | {
    TAG: 'application';
    data: {
        constructed: number;
        number: number;
    };
} | {
    TAG: 'contextSpecific';
    data: {
        constructed: number;
        number: number;
    };
} | {
    TAG: 'private';
    data: {
        constructed: number;
        number: number;
    };
};
type ASN1DebugTLV = {
    tag: ASN1DebugTag;
    data: Uint8Array;
};
type ASN1Debug = null | bigint | string | Uint8Array | ASN1DebugTLV | ASN1Debug[];
type ASN1StructRecord<T extends Record<string, unknown>> = {
    [K in keyof T]: P.CoderType<T[K]>;
};
/** Generic ASN.1 tree node used for lossless unsupported DER TLV payloads. */
type TLVNode = {
    /** First ASN.1 identifier octet. */
    tag: number;
    /** Full ASN.1 identifier octets when the tag uses high-tag-number form. */
    tagHex?: string;
    /** Nested child nodes for constructed values. */
    children?: TLVNode[];
    /** Hex-encoded payload for primitive values. */
    valueHex?: string;
};
/** Generic ASN.1 AlgorithmIdentifier shell with optional raw parameters. */
type ASN1AlgorithmIdentifier = {
    /** Algorithm object identifier. */
    algorithm: string;
    /** Optional raw AlgorithmIdentifier parameters TLV. */
    params?: TLVNode;
};
/** Generic ASN.1 Attribute shell with raw SET OF values. */
type ASN1Attribute = {
    /** Attribute object identifier. */
    oid: string;
    /** Raw ASN.1 attribute values. */
    values: Uint8Array[];
};
/** Generic ASN.1 Time choice. */
type ASN1Time = {
    TAG: 'utc';
    data: string;
} | {
    TAG: 'generalized';
    data: string;
};
/** Generic ASN.1 string value choice used by schema-less TLV helpers. */
type ASN1StringValue = {
    TAG: 'utf8';
    data: string;
} | {
    TAG: 'printable';
    data: string;
} | {
    TAG: 'teletex';
    data: string;
} | {
    TAG: 'ia5';
    data: string;
} | {
    TAG: 'bmp';
    data: string;
} | {
    TAG: 'universal';
    data: string;
} | {
    TAG: 'visible';
    data: string;
} | {
    TAG: 'numeric';
    data: string;
};
/** Generic parsed ASN.1 string-or-raw value. */
type ASN1StringOrRaw = ASN1StringValue | {
    TAG: 'raw';
    data: TLVNode;
};
/** Generic best-effort parsed ASN.1 ANY value. */
type ASN1AnyValue = {
    TAG: 'text';
    data: ASN1StringValue;
} | {
    TAG: 'oid';
    data: string;
} | {
    TAG: 'int';
    data: bigint;
} | {
    TAG: 'bool';
    data: boolean;
} | {
    TAG: 'time';
    data: ASN1Time;
} | {
    TAG: 'octet';
    data: Uint8Array;
} | {
    TAG: 'raw';
    data: TLVNode;
};
type ASN1TagCoder<T> = P.CoderType<T> & {
    tagByte: number;
    tagBytes: number[];
    constructed: number;
    inner: P.CoderType<T>;
};
type ASN1MaybeCoder<T> = P.CoderType<T> & Partial<Pick<ASN1TagCoder<T>, 'tagByte' | 'tagBytes' | 'constructed' | 'inner'>>;
type ASN1ChoiceRecord<T extends Record<string, unknown>> = {
    [K in keyof T]: ASN1MaybeCoder<T[K]>;
};
type ASN1ChoiceResult<T extends Record<string, unknown>> = {
    [K in keyof T]: {
        TAG: K;
        data: T[K];
    };
}[keyof T];
type ASN1Value<C> = C extends ASN1MaybeCoder<infer T> ? T : never;
type ASN1Pub = {
    debug: P.CoderType<ASN1Debug>;
    tagged: <T>(tag: number, inner: P.CoderType<T>) => ASN1TagCoder<T>;
    ASCII: P.CoderType<string>;
    Integer: ASN1TagCoder<bigint>;
    /** Create a nonnegative DER INTEGER coder with a maximum content width. */
    integer: (maxBytes: number) => ASN1TagCoder<bigint>;
    Boolean: ASN1TagCoder<boolean>;
    OctetString: ASN1TagCoder<Uint8Array>;
    OID: ASN1TagCoder<string>;
    OIDMap: ASN1TagCoder<string>;
    BitString: ASN1TagCoder<Uint8Array>;
    BitStringRaw: ASN1TagCoder<{
        unused: number;
        bytes: Uint8Array;
    }>;
    UTF8: ASN1TagCoder<string>;
    UTF8String: ASN1TagCoder<string>;
    IA5String: ASN1TagCoder<string>;
    PrintableString: ASN1TagCoder<string>;
    TeletexString: ASN1TagCoder<string>;
    VisibleString: ASN1TagCoder<string>;
    NumericString: ASN1TagCoder<string>;
    BMPString: ASN1TagCoder<string>;
    UniversalString: ASN1TagCoder<string>;
    String: P.CoderType<ASN1StringValue>;
    UTCTime: ASN1TagCoder<string>;
    GeneralizedTime: ASN1TagCoder<string>;
    Time: P.CoderType<ASN1Time>;
    null: ASN1TagCoder<null>;
    any: P.CoderType<Uint8Array>;
    TLVNode: P.CoderType<TLVNode>;
    StringOrRaw: P.CoderType<ASN1StringOrRaw>;
    AnyValue: P.CoderType<ASN1AnyValue>;
    AlgorithmIdentifier: ASN1TagCoder<ASN1AlgorithmIdentifier>;
    Attribute: ASN1TagCoder<ASN1Attribute>;
    ECDSASig: ASN1TagCoder<{
        r: bigint;
        s: bigint;
    }>;
    choice: <T extends Record<string, unknown>>(variants: ASN1ChoiceRecord<T>) => P.CoderType<ASN1ChoiceResult<T>>;
    sequence: <T extends Record<string, unknown>>(fields: ASN1StructRecord<T>) => ASN1TagCoder<T>;
    set: <T>(inner: P.CoderType<T>, opts?: {
        ber?: boolean;
    }) => ASN1TagCoder<T[]>;
    explicit: <T>(number: number, inner: P.CoderType<T>) => ASN1TagCoder<T>;
    implicit: <T>(number: number, inner: ASN1TagCoder<T>) => ASN1TagCoder<T>;
    optional: {
        <T>(inner: ASN1TagCoder<T>): ASN1TagCoder<T | undefined>;
        <T>(inner: P.CoderType<T>): P.CoderType<T | undefined>;
    };
    validate: <C extends object>(inner: C, fn: (value: ASN1Value<C>) => ASN1Value<C>) => C;
};
/** Generic ASN.1 building blocks. */
export declare const ASN1: TRet<ASN1Pub>;
type BERPub = {
    view: (src: TArg<Uint8Array>, opts?: BEROpts) => TRet<BERDoc>;
    decode: (src: TArg<Uint8Array>, opts?: {
        allowBER?: boolean;
    }) => TRet<{
        nodes: BerNode[];
        der: Uint8Array;
    }>;
    encode: (nodes: BerNode[], der: TArg<Uint8Array>) => TRet<Uint8Array>;
    normalize: (src: TArg<Uint8Array>, opts?: {
        allowBER?: boolean;
    }) => TRet<Uint8Array>;
};
type DERPub = {
    /** DER length coder with minimal-length validation. */
    length: P.CoderType<number>;
};
type BerNode = {
    len: number;
    lenBytes: number;
    indefinite: boolean;
    bitUnused?: number;
    children?: BerNode[];
    cls: number;
    tagNum: number;
    cons: boolean;
};
type BERDoc = {
    nodes: BerNode[];
    der: Uint8Array;
};
type BEROpts = {
    allowBER?: boolean;
};
/** BER decoder/encoder used to normalize supported BER input to DER. */
export declare const BER: TRet<BERPub>;
/** DER helpers. */
export declare const DER: TRet<DERPub>;
export {};