@ddunigma/node/dist/core-ihIEWmI5.d.ts

ddunigma

/**
 * ddunigma 아이소모픽 라이브러리의 핵심 타입 정의.
 * 모든 타입 정의의 정규 소스입니다.
 *
 * @module core/types
 */
declare enum DduSetSymbol {
    DDU = "ddu",
    DDU_V1 = "ddu_v1",
    ONECHARSET = "oneCharSet"
}
/**
 * `dduSetSymbol` 옵션이 받는 입력 타입.
 * `DduSetSymbol` enum 멤버 또는 그 문자열 리터럴(`"ddu" | "ddu_v1" | "oneCharSet"`)을 허용해,
 * enum을 import하지 않고도 `{ dduSetSymbol: "ddu" }`처럼 타입 안전하게 지정할 수 있습니다.
 * 런타임 값은 enum 값과 동일하므로 동작·와이어 포맷에 영향이 없습니다.
 */
type DduSetSymbolInput = DduSetSymbol | `${DduSetSymbol}`;
interface EncodingProfile {
    /** 논리 심볼당 비트 수 */
    bitLength: number;
    /** 2의 제곱수 charset 직접 인덱스 모드 여부 */
    usePowerOfTwo: boolean;
    /** 반복 패딩 시 패딩 문자 1개가 나타내는 비트 수 */
    bitsPerPadChar?: number;
}
interface CharSetConfig {
    /** charset 식별 심볼 */
    symbol: DduSetSymbol;
    /** 인코딩에 사용할 문자 배열 (codaChar가 있으면 기본 문자 배열) */
    charSet: string[];
    /** 종성 문자 배열 (charSet × codaChar 조합으로 최종 charset 생성) */
    codaChar?: string[];
    /** 최대 필요 문자 수 */
    maxRequiredLength: number;
    /** 비트 길이 (log2) */
    bitLength: number;
    /** 패딩 문자 */
    paddingChar: string;
    /** 패딩 문자 반복 방식 사용 여부 */
    useRepeatPadding?: boolean;
    /** 반복 패딩 시 패딩 문자 1개가 나타내는 비트 수 (기본값: 2) */
    bitsPerPadChar?: number;
    /** 2의 제곱수 모드 강제 여부 (false로 설정하면 인덱스 쌍 출력 모드 사용) */
    usePowerOfTwo?: boolean;
    /** 프리셋별 인코딩 프로필. 레거시 와이어 호환성을 고정할 때 사용 */
    encodingProfile?: EncodingProfile;
}
interface CharSetInfo {
    /** 인코딩에 사용할 문자 배열 */
    charSet: string[];
    /** 패딩 문자 */
    paddingChar: string;
    /** 비트 길이 */
    bitLength: number;
    /** 2의 제곱수 charset 여부 */
    usePowerOfTwo: boolean;
    /** 문자열 인코딩 방식 (런타임은 항상 UTF-8) */
    encoding: "utf-8";
    /** 기본 압축 사용 여부 */
    defaultCompress: boolean;
    /** 기본 최대 디코딩 바이트 수 */
    defaultMaxDecodedBytes: number;
    /** 기본 최대 압축해제 바이트 수 */
    defaultMaxDecompressedBytes: number;
    /** URL-Safe 모드 여부 */
    urlSafe: boolean;
    /** 암호화 키 보유 여부 */
    hasEncryptionKey: boolean;
    /** 기본 체크섬 사용 여부 */
    defaultChecksum: boolean;
    /** 기본 체크섬 계산 범위 (5.0: "output") */
    defaultChecksumScope: "plaintext" | "output";
    /** 기본 난독화 사용 여부 */
    defaultObfuscate: boolean;
    /** 암호화 키가 있을 때 암호화 payload만 허용하는지 여부 */
    defaultRequireEncryption: boolean;
    /** 기본 청크 크기 */
    defaultChunkSize: number | undefined;
    /** 기본 청크 구분자 */
    defaultChunkSeparator: string;
    /** 기본 압축 레벨 */
    defaultCompressionLevel: number;
    /** 기본 압축 알고리즘 */
    defaultCompressionAlgorithm: "deflate" | "brotli";
}
/** 진행률 콜백 정보 */
interface DduProgressInfo {
    /** 현재 처리된 바이트 수 (근사값) */
    processedBytes: number;
    /** 전체 바이트 수 */
    totalBytes: number;
    /** 진행률 (0-100, 단계별 근사값) */
    percent: number;
    /** 현재 처리 단계 */
    stage?: "start" | "encrypt" | "compress" | "encode" | "decode" | "decompress" | "checksum" | "decrypt" | "done";
}
/** 인코딩 통계 정보 */
interface DduEncodeStats {
    /** 원본 데이터 크기 (바이트) */
    originalSize: number;
    /** 인코딩된 문자열 길이 */
    encodedSize: number;
    /** 압축된 크기 (압축 사용시) */
    compressedSize?: number;
    /** 압축률 (0-1, 낮을수록 효율적) */
    compressionRatio?: number;
    /** 인코딩 확장 비율 */
    expansionRatio: number;
    /** 사용된 charset 크기 */
    charsetSize: number;
    /** 비트 길이 */
    bitLength: number;
}
type KeyDerivationAlgorithm = "sha256" | "pbkdf2";
interface KeyDerivationOptions {
    /**
     * Key derivation algorithm. Defaults to `pbkdf2` (5.0).
     *
     * ⚠️ Migration: 4.x defaulted to `sha256`. Data encrypted with 4.x defaults must be decrypted with
     * `algorithm: "sha256"` explicitly (key derivation is NOT self-described in the wire format).
     * For low-entropy keys (human passwords), keep the `pbkdf2` default and provide an
     * application-specific `salt`. Use `sha256` only for high-entropy keys (e.g. 32 random bytes) or
     * legacy data compatibility.
     */
    algorithm?: KeyDerivationAlgorithm;
    /**
     * Salt for PBKDF2. Provide a stable, application-specific value to decode
     * across instances. If omitted, a fixed default salt is used (weaker — set
     * your own when security matters).
     */
    salt?: string | Uint8Array;
    /** PBKDF2 iteration count. Positive values below 10000 are clamped to 10000. */
    iterations?: number;
    /** Hash function used by PBKDF2. */
    hash?: "SHA-256" | "SHA-384" | "SHA-512";
}
/**
 * 기본(Base) 런타임 옵션 — 플랫폼 어댑터 없이 처리 가능한 옵션 부분집합입니다.
 * 인코딩 + 한글 난독화(재미 풀세트)에 필요한 옵션을 포함합니다.
 */
interface DduBaseOptions {
    /** 최대 디코딩 바이트 수 (Zip Bomb 방어) */
    maxDecodedBytes?: number;
    /**
     * 최대 디코딩 입력(인코딩 문자열) 길이(문자 수). 청크/개행 제거 등 전처리 이전에
     * 선검사하여 거대한 입력에 의한 한도 우회·대량 할당을 차단합니다. 기본값은
     * `maxDecodedBytes`에 비례합니다.
     */
    maxEncodedChars?: number;
    /** 최대 압축해제 바이트 수 (Zip Bomb 방어) */
    maxDecompressedBytes?: number;
    /** 청크 분할 크기 (0이면 청킹 비활성화 — 생성자 기본값을 호출 단위로 끌 때 사용) */
    chunkSize?: number;
    /** 청크 구분자 (기본값: '\n') */
    chunkSeparator?: string;
    /** 진행률 콜백 */
    onProgress?: (info: DduProgressInfo) => void;
    /** 한글 난독화 활성화 (6.0: 암호화 키와 무관하게 동작) */
    obfuscate?: boolean;
}
/**
 * Secure 확장 옵션 — `DduBaseOptions`에 압축/암호화/체크섬 부가기능 옵션을 더합니다.
 * `@ddunigma/node`/`@ddunigma/node/browser`는 adapter-backed 옵션을 비동기 메서드에서
 * lazy secure로 처리하고, `@ddunigma/node/secure`는 sync/async secure 표면을 모두 제공합니다.
 */
interface DduSecureOptions extends DduBaseOptions {
    /** 압축 사용 여부 (zlib deflate 또는 brotli) */
    compress?: boolean;
    /** 압축 알고리즘 (기본값: "deflate") */
    compressionAlgorithm?: "deflate" | "brotli";
    /** 압축 레벨 (deflate 기본값: 6, brotli도 기본값 6을 사용하며 전달값은 0~11 범위로 보정) */
    compressionLevel?: number;
    /** 체크섬 추가 여부 (CRC32) */
    checksum?: boolean;
    /**
     * 체크섬 계산 범위 (기본값: "output").
     * - `"plaintext"`: 원본 입력 바이트의 CRC32 (레거시 범위). 암호화와 함께 쓰면 평문 CRC가 출력에 노출됩니다.
     * - `"output"`: 인코딩 파이프라인 최종 바이트(압축/암호화 후, 와이어에 실리는 바이트)의 CRC32.
     *   암호화 시 평문 CRC를 노출하지 않고, 복호화 이전에 전송 손상을 감지합니다.
     *
     * `checksum`과 마찬가지로 와이어에 자기기술 플래그가 없으므로 인코딩/디코딩에서 동일하게 지정해야 합니다.
     */
    checksumScope?: "plaintext" | "output";
    /**
     * 암호화 키가 설정된 decoder에서 암호화 footer를 요구합니다.
     * 기본값은 encryptionKey가 있으면 true입니다. 레거시 평문을 같은 인스턴스로
     * 디코딩해야 하면 false 또는 호출별 `requireEncryption: false`를 명시하세요.
     */
    requireEncryption?: boolean;
}
/**
 * 하위호환 별칭. 6.0 이전 코드 및 코어 내부 시그니처가 사용하던 전 기능 런타임 옵션
 * 타입으로, secure 표면 전체(`DduSecureOptions`)와 동일합니다.
 */
type DduOptions = DduSecureOptions;
/** Web Streams 버퍼 제한을 포함한 스트림 전용 옵션 */
interface DduStreamOptions extends DduSecureOptions {
    /** 압축/암호화/체크섬 인코딩 시 메모리에 축적할 최대 입력 바이트 수 */
    maxBufferedBytes?: number;
    /** 디코딩 시 메모리에 축적할 최대 입력 문자 수 */
    maxBufferedChars?: number;
}
/**
 * 기본(Base) 생성자 옵션 — charset/padding/urlSafe 계열과 adapter-free 런타임 옵션을 포함합니다.
 */
interface DduBaseConstructorOptions extends DduBaseOptions {
    /** 미리 정의된 charset 심볼 (enum 멤버 또는 그 문자열 리터럴) */
    dduSetSymbol?: DduSetSymbolInput;
    /** 커스텀 charset 문자 배열 또는 문자열 */
    dduChar?: string[] | string;
    /** 종성 문자 배열 (dduChar × codaChar 조합으로 최종 charset 동적 생성) */
    codaChar?: string[];
    /** 패딩 문자 */
    paddingChar?: string;
    /** 필요 문자 수 */
    requiredLength?: number;
    /** 2의 제곱수 강제 여부 */
    usePowerOfTwo?: boolean;
    /**
     * true이면 초기화 오류 시 throw합니다. false이면 fallback charset으로 대체합니다.
     *
     * ⚠️ 5.0 변경: 기본값이 `false` → `true`로 전환되었습니다. 잘못된 커스텀 charset에
     * 더 엄격하게 동작하며, 레거시의 묵시적 fallback 동작이 필요하면 `false`를 명시하세요.
     * @default true
     */
    throwOnError?: boolean;
    /** URL-Safe 모드 (특수문자를 URL 안전 문자로 변환) */
    urlSafe?: boolean;
    /** 패딩 문자 반복 방식 사용 여부 */
    useRepeatPadding?: boolean;
    /**
     * 난독화 레이어 팩토리 (지연 생성). 코어를 구체 난독화 구현과 분리하기 위한 주입점입니다.
     * `obfuscate`가 실제로 사용될 때만 호출됩니다. 미주입 상태에서 난독화를 요청하면 throw합니다.
     *
     * Ddu64Node/Ddu64Browser가 HangulObfuscationLayer 팩토리를 주입하므로 일반 사용자는
     * 신경 쓸 필요가 없습니다. `@ddunigma/node/core`로 Ddu64Core를 직접 쓰면서 난독화가
     * 필요하면 이 팩토리를 주입하세요(미사용 시 난독화 코드가 번들에서 트리셰이킹됩니다).
     * @internal
     */
    obfuscationLayerFactory?: (alphabet: string[]) => ObfuscationLayer;
}
/**
 * Secure 생성자 옵션 — Base 생성자 옵션 + Secure 런타임 옵션에 암호화 키/어댑터를 더한,
 * 코어와 공개 래퍼가 사용하는 전 기능 생성자 표면입니다.
 */
interface DduSecureConstructorOptions extends DduBaseConstructorOptions, DduSecureOptions {
    /** 암호화 키 (AES-256-GCM) */
    encryptionKey?: string;
    /** 암호화 키 파생 옵션 */
    keyDerivation?: KeyDerivationOptions;
    /** 명시적 플랫폼 어댑터 (자동 감지 대신 사용) */
    adapter?: PlatformAdapter;
    /**
     * 플랫폼 어댑터 팩토리 (지연 생성). `adapter`가 지정되지 않았을 때, 첫 압축/암호화
     * 연산 시점에 한 번 호출되어 어댑터를 생성·캐시합니다. 순수 인코딩/디코딩만 수행하면
     * 어댑터는 생성되지 않습니다.
     *
     * Ddu64Secure/Ddu64SecureBrowser가 각각 NodeAdapter/BrowserAdapter 팩토리를 주입합니다.
     * @internal
     */
    adapterFactory?: () => PlatformAdapter;
}
/**
 * 하위호환 별칭. 6.0 이전 코드 및 코어 내부 시그니처가 사용하던 전 기능 생성자 옵션
 * 타입으로, secure 생성자 표면 전체(`DduSecureConstructorOptions`)와 동일합니다.
 */
type DduConstructorOptions = DduSecureConstructorOptions;
/**
 * 암호화 및 압축 연산을 제공하는 플랫폼 어댑터 인터페이스.
 * 각 런타임(Node.js, 브라우저, 엣지)이 이 인터페이스를 구현합니다.
 *
 * 동기 메서드(`?`로 표시)는 Node.js에서만 사용 가능합니다.
 * 브라우저/엣지 어댑터는 동기 메서드 호출 시 throw합니다.
 */
interface PlatformAdapter {
    /** UTF-8 키 문자열에서 256비트 키를 파생 */
    deriveKey(key: string, options?: KeyDerivationOptions): Promise<Uint8Array>;
    /** 동기적으로 256비트 키를 파생 (Node.js 전용) */
    deriveKeySync?(key: string, options?: KeyDerivationOptions): Uint8Array;
    /** AES-256-GCM으로 데이터를 암호화. IV(12) + authTag(16) + 암호문을 반환 */
    encrypt(data: Uint8Array, keyHash: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
    /** 동기적으로 데이터를 암호화 (Node.js 전용) */
    encryptSync?(data: Uint8Array, keyHash: Uint8Array, aad?: Uint8Array): Uint8Array;
    /** AES-256-GCM 페이로드를 복호화. IV(12) + authTag(16) + 암호문 형식을 기대 */
    decrypt(data: Uint8Array, keyHash: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
    /** 동기적으로 데이터를 복호화 (Node.js 전용) */
    decryptSync?(data: Uint8Array, keyHash: Uint8Array, aad?: Uint8Array): Uint8Array;
    /**
     * 암호학적으로 안전한 랜덤 바이트를 생성하는 편의 메서드.
     *
     * @remarks 코어 인코딩/디코딩 파이프라인은 이 메서드를 호출하지 않습니다(각 어댑터가
     * 암호화 IV를 내부에서 직접 생성). 6.0부터 **선택(optional)** 이므로 커스텀 어댑터는
     * 구현하지 않아도 됩니다. `NodeAdapter`/`BrowserAdapter`는 편의상 계속 제공합니다.
     */
    randomBytes?(length: number): Uint8Array;
    /** deflate 알고리즘으로 데이터를 압축 */
    deflate(data: Uint8Array, level?: number): Promise<Uint8Array>;
    /** 동기적으로 deflate 압축 (Node.js 전용) */
    deflateSync?(data: Uint8Array, level?: number): Uint8Array;
    /** deflate 데이터를 압축 해제 */
    inflate(data: Uint8Array, maxBytes?: number): Promise<Uint8Array>;
    /** 동기적으로 deflate 데이터를 압축 해제 (Node.js 전용) */
    inflateSync?(data: Uint8Array, maxBytes?: number): Uint8Array;
    /** brotli 알고리즘으로 데이터를 압축 (Node.js 전용) */
    brotliCompress?(data: Uint8Array, level?: number): Promise<Uint8Array>;
    /** 동기적으로 brotli 압축 (Node.js 전용) */
    brotliCompressSync?(data: Uint8Array, level?: number): Uint8Array;
    /** brotli 데이터를 압축 해제 (Node.js 전용) */
    brotliDecompress?(data: Uint8Array, maxBytes?: number): Promise<Uint8Array>;
    /** 동기적으로 brotli 데이터를 압축 해제 (Node.js 전용) */
    brotliDecompressSync?(data: Uint8Array, maxBytes?: number): Uint8Array;
    /** 감지된 런타임 환경 */
    readonly runtime: "node" | "browser" | "edge" | "deno" | "bun" | "unknown";
}
/**
 * 한글 음절 난독화 레이어 인터페이스.
 * 암호화된 출력을 자연스러운 한국어 음절 블록으로 변환합니다.
 */
interface ObfuscationLayer {
    /**
     * 암호화된 charset 인코딩 문자열을 자연스러운 한글 음절로 변환합니다.
     * 모든 출력 문자는 U+AC00–U+D7A3 범위에 있습니다.
     * 출력 길이 <= 입력 길이의 1.5배.
     */
    obfuscate(input: string): string;
    /**
     * 난독화를 역변환하여 원본 charset 인코딩 문자열을 복원합니다.
     */
    deobfuscate(input: string): string;
}

/**
 * 플랫폼 독립 Ddu64 인코더/디코더 코어.
 * PlatformAdapter 인터페이스를 통해 암호화 및 압축 연산을 수행하는 전체 인코딩/디코딩 파이프라인을 제공합니다.
 *
 * @module core/Ddu64Core
 */

/**
 * 플랫폼 독립 Ddu64 인코더/디코더.
 *
 * 모든 암호화 및 압축 연산에 PlatformAdapter를 사용합니다.
 */
declare class Ddu64Core {
    /** 인코딩에 사용되는 문자 */
    protected readonly dduChar: string[];
    /** 인코딩 문자의 코드포인트 배열 (String.fromCharCode 배치 호출용) */
    private readonly dduCharCodes;
    /** 패딩 문자 */
    protected readonly paddingChar: string;
    /** 비트 길이 (2의 제곱수 charset의 경우 charset 크기의 log2) */
    protected readonly bitLength: number;
    /** charset 크기가 2의 제곱수인지 여부 */
    protected readonly usePowerOfTwo: boolean;
    /** UTF-16 코드 유닛 → 인덱스 direct lookup (단일 BMP 심볼 전용) */
    private readonly dduCharCodeLookup;
    /** 룩업 테이블 오프셋 (lookup[code - offset]) */
    private readonly dduCharCodeLookupOffset;
    /** 기본 압축 활성화 */
    protected readonly defaultCompress: boolean;
    /** 기본 최대 디코딩 바이트 수 */
    private readonly defaultMaxDecodedBytes;
    /** 기본 최대 인코딩 입력 문자 수 (디코드 전처리 전 선검사) */
    private readonly defaultMaxEncodedChars;
    /** 기본 최대 압축해제 바이트 수 */
    private readonly defaultMaxDecompressedBytes;
    /** URL-Safe 모드 */
    private readonly urlSafe;
    /** 암호화 키 (원시 문자열, 해시 파생용) */
    private readonly encryptionKey;
    /** 암호화 키 파생 옵션 */
    private readonly keyDerivation;
    /** 캐시된 암호화 키 해시 */
    private encryptionKeyHash;
    /** 캐시된 어댑터 게이트웨이 컨텍스트 (호출당 재할당 방지, 해시는 getter로 라이브 조회) */
    private syncGatewayContext;
    /** 기본 체크섬 활성화 */
    private readonly defaultChecksum;
    /** 기본 체크섬 계산 범위 */
    private readonly defaultChecksumScope;
    /** 기본 청크 크기 */
    private readonly defaultChunkSize;
    /** 기본 청크 구분자 */
    private readonly defaultChunkSeparator;
    /** 기본 압축 레벨 */
    private readonly defaultCompressionLevel;
    /** 기본 압축 알고리즘 */
    private readonly defaultCompressionAlgorithm;
    /** 반복 패딩 모드 사용 여부 */
    private readonly useRepeatPadding;
    /** 반복 패딩 시 패딩 문자 1개가 나타내는 비트 수 */
    private readonly bitsPerPadChar;
    /** BitPack 설정 */
    private readonly bitPackConfig;
    /** 표준 Base64 charset에서 네이티브 Base64 fast path 사용 여부 */
    private readonly canUseNativeBase64;
    /** 인코딩/디코딩 payload codec 공유 컨텍스트 */
    private readonly payloadCodecContext;
    /** 플랫폼 어댑터 (동기용 지연 로드 또는 명시적 제공) */
    private adapter;
    /** 어댑터 지연 생성 팩토리 (adapter 미지정 시 첫 암/복호화·압축 시점에 1회 호출) */
    private readonly adapterFactory;
    /** 난독화 레이어 팩토리 (코어-난독화 분리용 주입점) */
    private readonly obfuscationLayerFactory;
    /** 기본 난독화 활성화 */
    private readonly defaultObfuscate;
    /** 기본 진행률 콜백 */
    private readonly defaultOnProgress;
    /** 암호화 키가 설정된 decoder에서 암호화 footer 요구 */
    private readonly defaultRequireEncryption;
    /** 지연 초기화되는 난독화 레이어 */
    private obfuscationLayer;
    /**
     * Ddu64 인코더/디코더를 생성합니다.
     *
     * 권장: 옵션 객체 단일 인자 형태 — `new Ddu64({ dduSetSymbol, compress, ... })`.
     *
     * 위치 인자 형태 `new Ddu64(dduChar, paddingChar, options)`는 커스텀 charset
     * 지정용으로 계속 지원되지만, 가독성을 위해 옵션 객체 형태를 우선 권장합니다.
     * (`new Ddu64(charset, padding, options)` 또는 `new Ddu64({ dduChar, paddingChar, ...options })`)
     *
     * @param dduChar - 커스텀 charset(문자열/배열) 또는 옵션 객체
     * @param paddingChar - 패딩 문자 (커스텀 charset 사용 시 필수)
     * @param dduOptions - 추가 옵션
     */
    constructor(dduChar?: string[] | string | DduConstructorOptions, paddingChar?: string, dduOptions?: DduConstructorOptions);
    /**
     * 입력 데이터를 charset 인코딩 문자열로 인코딩합니다.
     *
     * @param input - 인코딩할 String 또는 Uint8Array
     * @param options - 인코딩 옵션
     * @returns 인코딩된 문자열
     * @throws 동기 암호화/압축이 필요하지만 어댑터가 지원하지 않는 경우
     * @group Sync
     */
    encode(input: Uint8Array | string, options?: DduOptions): string;
    /**
     * 인코딩된 문자열을 UTF-8 문자열로 디코딩합니다.
     *
     * @param input - 디코딩할 인코딩된 문자열
     * @param options - 디코딩 옵션
     * @returns 디코딩된 문자열
     * @group Sync
     */
    decode(input: string, options?: DduOptions): string;
    /**
     * 인코딩된 문자열을 Uint8Array로 디코딩합니다.
     *
     * @param input - 디코딩할 인코딩된 문자열
     * @param options - 디코딩 옵션
     * @returns 디코딩된 바이트
     * @group Sync
     */
    decodeToUint8Array(input: string, options?: DduOptions): Uint8Array;
    private decodeToUint8ArrayInternal;
    /**
     * 비동기 인코딩 - 브라우저를 포함한 모든 런타임에서 동작합니다.
     *
     * @group Async
     */
    encodeAsync(input: Uint8Array | string, options?: DduOptions): Promise<string>;
    private encodeAsyncInternal;
    /**
     * 비동기 디코딩 - 브라우저를 포함한 모든 런타임에서 동작합니다.
     *
     * @group Async
     */
    decodeAsync(input: string, options?: DduOptions): Promise<string>;
    /**
     * 비동기 Uint8Array 디코딩 - 브라우저를 포함한 모든 런타임에서 동작합니다.
     *
     * @group Async
     */
    decodeToUint8ArrayAsync(input: string, options?: DduOptions): Promise<Uint8Array>;
    private decodeToUint8ArrayAsyncInternal;
    /**
     * 동기/비동기 디코딩 파이프라인이 공유하는 기본 컨텍스트를 구성합니다.
     * decrypt/decompress만 동기/비동기 구현에서 각각 덧붙입니다.
     */
    private buildDecodeBaseContext;
    /**
     * charset 정보를 가져옵니다.
     *
     * @group Introspection
     */
    getCharSetInfo(): CharSetInfo;
    /**
     * 인코딩 통계를 가져옵니다.
     *
     * @group Introspection
     */
    getStats(input: Uint8Array | string, options?: DduOptions): DduEncodeStats;
    /**
     * 비동기 인코딩 통계를 가져옵니다.
     *
     * 브라우저/Workers처럼 압축이 비동기 API로만 제공되는 런타임에서는 `compress: true`
     * 통계 계산에 이 메서드를 사용하세요.
     *
     * @group Introspection
     */
    getStatsAsync(input: Uint8Array | string, options?: DduOptions): Promise<DduEncodeStats>;
    private buildEncodeStats;
    /**
     * 통계를 위한 메타데이터 포함 내부 인코딩.
     */
    private encodeInternal;
    /**
     * getStats 전용 인코딩: 실제 AES-GCM 연산을 생략하고 길이만 정확한 더미 암호화를 사용합니다.
     *
     * 암호화 출력 길이는 `평문 + AEAD_OVERHEAD_BYTES`로 결정적이고, 비트팩/푸터/체크섬/난독화/
     * URL-safe/청킹은 모두 입력 바이트 "길이"에만 의존(바이트 "값"과 무관)하므로, 더미 암호문(0으로 채운
     * 동일 길이 버퍼)으로 마무리해도 `encoded.length`는 실제 `encode()` 출력과 바이트 단위로 일치합니다.
     * 압축은 결과 크기와 적용 여부 판단에 필요하므로 실제로 수행합니다.
     *
     * 이 등식(통계 길이 === 실제 encode 길이)은 property test로 고정됩니다.
     */
    private encodeStatsInternal;
    private encodeStatsAsyncInternal;
    /**
     * 동기/비동기 인코딩 파이프라인이 공유하는 기본 컨텍스트를 구성합니다.
     * compress/encrypt만 동기/비동기 구현에서 각각 덧붙입니다.
     */
    private buildEncodeBaseContext;
    /**
     * 인코딩 마무리: 비트팩 인코딩 + 후처리(난독화/체크섬/URL-safe/청킹).
     * 동기/비동기 인코딩에서 공유하는 순수 동기 단계입니다.
     */
    private finalizeEncode;
    /**
     * 인코딩 후처리: 난독화, 체크섬, URL-safe, 청킹을 적용합니다.
     */
    private applyPostEncoding;
    /**
     * 디코딩 전처리: 동기/비동기 디코딩에서 공통으로 쓰는 순수 동기 단계.
     * 청크 제거 → URL-safe 역변환 → 체크섬 추출 → 역난독화 → 푸터 파싱 →
     * 검증(정렬/패딩/크기) → 비트팩 해제까지 수행합니다.
     */
    private decodePrelude;
    private getPayloadCodecContext;
    private reportProgress;
    /**
     * 어댑터를 지연 해석합니다. 명시적 adapter가 없고 adapterFactory가 있으면 첫 호출 시
     * 1회 생성·캐시합니다. 순수 인코딩/디코딩 경로에서는 호출되지 않습니다.
     */
    private getAdapter;
    private getSyncGatewayContext;
    /**
     * 난독화 레이어를 가져오거나 생성합니다 (지연 초기화).
     * 알파벳에는 charset 문자, 패딩 문자, 모든 푸터 마커 문자가 포함됩니다.
     */
    private getObfuscationLayer;
    /**
     * 주어진 호출에 난독화를 적용해야 하는지 결정합니다.
     * 호출별 옵션이 생성자 기본값을 오버라이드합니다.
     * 6.0: 난독화는 암호화와 무관하게 적용됩니다(키 비의존). 키 없이도 난독화가 동작합니다.
     */
    private shouldObfuscate;
    private assertSafeChunkSeparator;
    private isLineBreakSeparator;
}

/**
 * 커스텀 Charset을 쉽게 생성하기 위한 빌더 클래스.
 *
 * @module core/CharsetBuilder
 *
 * @remarks
 * non-BMP 주의: `fromUnicodeRange`/`addUnicodeRange`는 `String.fromCodePoint`로 U+FFFF를
 * 넘는 문자(서로게이트 쌍, `.length === 2`)도 만들 수 있습니다. 그러나 `Ddu64` 생성자에
 * 넘길 charset은 **BMP 단일 UTF-16 코드 유닛** 심볼만 허용하므로, non-BMP를 포함한 `build()`
 * 결과를 charset으로 넘기면 코어가 "Multi-character symbols are not supported"로 거부합니다.
 * 코어 charset 용도라면 BMP(≤ U+FFFF) 범위만 사용하세요.
 *
 * @example
 * const chars = CharsetBuilder
 *   .fromUnicodeRange(0x4E00, 0x4E3F)
 *   .excludeConfusing()
 *   .shuffle()
 *   .build();
 */
declare class CharsetBuilder {
    private chars;
    private constructor();
    /**
     * 빈 빌더를 생성합니다.
     */
    static create(): CharsetBuilder;
    /**
     * 유니코드 범위에서 문자들을 추가합니다.
     *
     * @param start - 시작 유니코드 코드포인트
     * @param end - 끝 유니코드 코드포인트 (포함)
     */
    static fromUnicodeRange(start: number, end: number): CharsetBuilder;
    /**
     * 문자열에서 문자들을 추가합니다.
     *
     * @param chars - 문자열 또는 문자 배열
     */
    static fromString(chars: string | string[]): CharsetBuilder;
    /**
     * Base64 표준 문자셋으로 시작합니다.
     */
    static base64(): CharsetBuilder;
    /**
     * Base32 표준 문자셋으로 시작합니다.
     */
    static base32(): CharsetBuilder;
    /**
     * 영문 대문자만 포함합니다.
     */
    static uppercase(): CharsetBuilder;
    /**
     * 영문 소문자만 포함합니다.
     */
    static lowercase(): CharsetBuilder;
    /**
     * 숫자만 포함합니다.
     */
    static digits(): CharsetBuilder;
    /**
     * 한글 자모를 포함합니다.
     */
    static hangulJamo(): CharsetBuilder;
    /**
     * 유니코드 범위에서 문자들을 추가합니다.
     */
    addUnicodeRange(start: number, end: number): CharsetBuilder;
    /**
     * 문자열에서 문자들을 추가합니다.
     */
    addString(chars: string | string[]): CharsetBuilder;
    /**
     * 특정 문자들을 추가합니다.
     */
    add(...chars: string[]): CharsetBuilder;
    /**
     * 혼동하기 쉬운 문자들을 제거합니다.
     * (0, O, o, 1, l, I, i 등)
     */
    excludeConfusing(): CharsetBuilder;
    /**
     * 특정 문자들을 제거합니다.
     */
    exclude(...chars: string[]): CharsetBuilder;
    /**
     * URL에서 안전하지 않은 문자들을 제거합니다.
     */
    excludeUrlUnsafe(): CharsetBuilder;
    /**
     * 중복 문자를 제거합니다.
     */
    unique(): CharsetBuilder;
    /**
     * 문자셋을 무작위로 섞습니다.
     *
     * ⚠️ 보안 주의: `seed` 없이 호출하면 `Math.random`을 사용하므로 암호학적으로 안전하지
     * 않습니다(예측 가능). charset 순서를 비밀로 취급해 보안 경계로 삼지 마세요. 기밀성이
     * 필요하면 `encryptionKey`(AES-256-GCM)를 사용하세요. `seed`를 주면 결정론적(재현 가능)
     * 셔플이 되며, 이 역시 비밀이 아니라 재현성 용도입니다.
     */
    shuffle(seed?: number): CharsetBuilder;
    /**
     * 시드 기반 난수 생성기 (xorshift32)
     */
    private seededRandom;
    /**
     * 특정 길이로 자릅니다.
     */
    limit(length: number): CharsetBuilder;
    /**
     * 2의 제곱수 길이로 자릅니다.
     */
    limitToPowerOfTwo(): CharsetBuilder;
    /**
     * 문자셋을 정렬합니다.
     */
    sort(): CharsetBuilder;
    /**
     * 역순으로 정렬합니다.
     */
    reverse(): CharsetBuilder;
    /**
     * 현재 문자 수를 반환합니다.
     */
    get length(): number;
    /**
     * 문자셋을 문자열로 빌드합니다.
     */
    buildString(): string;
    /**
     * 문자셋을 배열로 빌드합니다.
     */
    build(): string[];
    /**
     * 문자셋과 패딩 문자를 함께 빌드합니다.
     *
     * @param paddingChar - 패딩 문자 (기본값: charset에서 제외된 첫 번째 문자)
     */
    buildWithPadding(paddingChar?: string): {
        charset: string[];
        padding: string;
    };
}

/**
 * ddunigma custom error hierarchy.
 *
 * Public encode/decode APIs wrap internal/runtime failures in these typed
 * errors so callers can branch on a stable code without parsing messages.
 *
 * @module core/errors
 */
type Ddu64Operation = "construct" | "encode" | "decode" | "compress" | "decompress" | "encrypt" | "decrypt" | "checksum" | "charset" | "adapter" | "obfuscation" | "stream";
declare enum Ddu64ErrorCode {
    EncodeFailed = "DDU64_ENCODE_FAILED",
    DecodeFailed = "DDU64_DECODE_FAILED",
    CompressionFailed = "DDU64_COMPRESSION_FAILED",
    DecompressionFailed = "DDU64_DECOMPRESSION_FAILED",
    EncryptionFailed = "DDU64_ENCRYPTION_FAILED",
    DecryptionFailed = "DDU64_DECRYPTION_FAILED",
    ChecksumMismatch = "DDU64_CHECKSUM_MISMATCH",
    InvalidCharset = "DDU64_INVALID_CHARSET",
    InvalidInput = "DDU64_INVALID_INPUT",
    LimitExceeded = "DDU64_LIMIT_EXCEEDED",
    AdapterUnavailable = "DDU64_ADAPTER_UNAVAILABLE",
    ObfuscationFailed = "DDU64_OBFUSCATION_FAILED",
    StreamFailed = "DDU64_STREAM_FAILED"
}
interface Ddu64ErrorOptions {
    code: Ddu64ErrorCode;
    operation: Ddu64Operation;
    cause?: unknown;
}
declare class Ddu64Error extends Error {
    readonly code: Ddu64ErrorCode;
    readonly operation: Ddu64Operation;
    constructor(message: string, options: Ddu64ErrorOptions);
}
declare class Ddu64EncodeError extends Ddu64Error {
    constructor(message: string, cause?: unknown);
}
declare class Ddu64DecodeError extends Ddu64Error {
    constructor(message: string, cause?: unknown);
}
declare class Ddu64CompressionError extends Ddu64Error {
    constructor(message: string, cause?: unknown);
}
declare class Ddu64DecompressionError extends Ddu64Error {
    constructor(message: string, cause?: unknown);
}
declare class Ddu64EncryptionError extends Ddu64Error {
    constructor(message: string, cause?: unknown);
}
declare class Ddu64DecryptionError extends Ddu64Error {
    constructor(message: string, cause?: unknown);
}
declare class Ddu64ChecksumError extends Ddu64Error {
    constructor(message: string, cause?: unknown);
}
declare class Ddu64CharsetError extends Ddu64Error {
    constructor(message: string, cause?: unknown);
}
declare class Ddu64InvalidInputError extends Ddu64Error {
    constructor(message: string, operation?: Ddu64Operation, cause?: unknown);
}
declare class Ddu64LimitError extends Ddu64Error {
    constructor(message: string, operation: Ddu64Operation, cause?: unknown);
}
declare class Ddu64AdapterError extends Ddu64Error {
    constructor(message: string, operation: Ddu64Operation, cause?: unknown);
}
declare class Ddu64ObfuscationError extends Ddu64Error {
    constructor(message: string, cause?: unknown);
}
declare class Ddu64StreamError extends Ddu64Error {
    constructor(message: string, cause?: unknown);
}
declare function isDdu64Error(error: unknown): error is Ddu64Error;

export { type DduSetSymbolInput as A, isDdu64Error as B, type CharSetConfig as C, Ddu64Core as D, type EncodingProfile as E, type DduConstructorOptions as F, type DduSecureOptions as G, type DduStreamOptions as H, type KeyDerivationOptions as I, type KeyDerivationAlgorithm as K, type ObfuscationLayer as O, type PlatformAdapter as P, type DduSecureConstructorOptions as a, type DduOptions as b, type DduEncodeStats as c, type CharSetInfo as d, CharsetBuilder as e, Ddu64AdapterError as f, Ddu64CharsetError as g, Ddu64ChecksumError as h, Ddu64CompressionError as i, Ddu64DecodeError as j, Ddu64DecompressionError as k, Ddu64DecryptionError as l, Ddu64EncodeError as m, Ddu64EncryptionError as n, Ddu64Error as o, Ddu64ErrorCode as p, type Ddu64ErrorOptions as q, Ddu64InvalidInputError as r, Ddu64LimitError as s, Ddu64ObfuscationError as t, type Ddu64Operation as u, Ddu64StreamError as v, type DduBaseConstructorOptions as w, type DduBaseOptions as x, type DduProgressInfo as y, DduSetSymbol as z };