boom-format 0.9.0

package/dist/index.d.ts

@@ -0,0 +1,779 @@
+/**
+ * BOOM Type Definitions
+ * @module boom-format/types
+ */
+type BoomPrimitive$1 = string | number | boolean | null | bigint;
+type BoomValue$1 = BoomPrimitive$1 | BoomArray$1 | BoomObject$1 | Uint8Array;
+interface BoomArray$1 extends Array<BoomValue$1> {
+}
+interface BoomObject$1 {
+    [key: string]: BoomValue$1;
+}
+interface BoomOptions$1 {
+    /** Maximum nesting depth for arrays/objects (default: 64) */
+    maxDepth?: number;
+    /** Maximum string length in bytes (default: 16MB) */
+    maxStringLength?: number;
+    /** Maximum array/object length (default: 1,000,000) */
+    maxArrayLength?: number;
+    /** Enable string interning for repeated values (default: true) */
+    enableInterning?: boolean;
+    /** Skip BOOM header for compressed transport (default: false) */
+    skipHeader?: boolean;
+    /** Optimize for HTTP compression - disables interning, skips header (default: false) */
+    forCompression?: boolean;
+}
+interface BoomTextOptions$1 extends BoomOptions$1 {
+    /** Use compact single-line format (default: false) */
+    compact?: boolean;
+    /** Indentation string for pretty printing (default: "  ") */
+    indentString?: string;
+}
+interface SmallestEncodeResult$1 {
+    data: Uint8Array | string;
+    format: 'boom' | 'json';
+    savings: number;
+}
+type BoomMode$1 = 'boom-binary' | 'boom-text' | 'json';
+interface BoomThresholdConfig$1 {
+    /** Below this size in bytes, use JSON (default: 1024) */
+    minSize?: number;
+    /** Above this size in bytes, prefer BOOM (default: 10240) */
+    preferSize?: number;
+    /** Above this size in bytes, always use BOOM (default: 102400) */
+    forceSize?: number;
+    /** Enable automatic format detection (default: true) */
+    autoDetect?: boolean;
+    /** Honor client X-Boom-Expected-Size hints (default: true) */
+    respectClientHint?: boolean;
+}
+
+/**
+ * BOOM Error Class
+ * @module boom-format/errors
+ */
+declare class BoomError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * BOOM Varint Utilities
+ * @module boom-format/varint
+ */
+/**
+ * Zigzag encode a signed integer for varint encoding
+ */
+declare function zigzagEncode(value: number): number;
+/**
+ * Zigzag decode a varint back to signed integer
+ */
+declare function zigzagDecode(value: number): number;
+
+/**
+ * BOOM Buffer Utilities
+ * ByteWriter and ByteReader for binary serialization
+ * @module boom-format/buffer
+ */
+/**
+ * Growable byte buffer for writing binary data
+ */
+declare class ByteWriter {
+    buffer: Uint8Array;
+    private view;
+    pos: number;
+    private capacity;
+    constructor(initialCapacity?: number);
+    private grow;
+    write(data: Uint8Array): void;
+    writeByte(value: number): void;
+    writeInt8(value: number): void;
+    writeInt16LE(value: number): void;
+    writeInt32LE(value: number): void;
+    writeBigInt64LE(value: bigint): void;
+    writeBigUInt64LE(value: bigint): void;
+    writeFloat32LE(value: number): void;
+    writeFloat64LE(value: number): void;
+    writeVarint(value: number): void;
+    writeVarintSmall(value: number): void;
+    toUint8Array(): Uint8Array;
+}
+/**
+ * Byte buffer reader for decoding binary data
+ */
+declare class ByteReader {
+    private view;
+    offset: number;
+    private buf;
+    private len;
+    constructor(buffer: Uint8Array);
+    get remaining(): number;
+    get buffer(): Uint8Array;
+    readByte(): number;
+    readBytes(count: number): Uint8Array;
+    readInt8(): number;
+    readInt16LE(): number;
+    readInt32LE(): number;
+    readBigInt64LE(): bigint;
+    readUInt8(): number;
+    readUInt16LE(): number;
+    readUInt32LE(): number;
+    readBigUInt64LE(): bigint;
+    readFloat32LE(): number;
+    readFloat64LE(): number;
+    readVarint(): number;
+}
+
+/**
+ * BOOM - Binary Object Optimised Markup
+ * A compact binary serialisation format with readable debug mode
+ *
+ * @module boom-format
+ * @version 1.0.0
+ * @license MIT
+ */
+
+type BoomPrimitive = string | number | boolean | null | bigint;
+type BoomValue = BoomPrimitive | BoomArray | BoomObject | Uint8Array;
+interface BoomArray extends Array<BoomValue> {
+}
+interface BoomObject {
+    [key: string]: BoomValue;
+}
+interface BoomOptions {
+    /** Maximum nesting depth for arrays/objects (default: 64) */
+    maxDepth?: number;
+    /** Maximum string length in bytes (default: 16MB) */
+    maxStringLength?: number;
+    /** Maximum array/object length (default: 1,000,000) */
+    maxArrayLength?: number;
+    /** Enable string interning for repeated values (default: true) */
+    enableInterning?: boolean;
+    /** Skip BOOM header for compressed transport (default: false) */
+    skipHeader?: boolean;
+    /** Optimize for HTTP compression - disables interning, skips header (default: false) */
+    forCompression?: boolean;
+    /** Use built-in shared dictionary for common strings (default: true) */
+    useBuiltInDictionary?: boolean;
+    /** Custom shared dictionary - array of strings known to both encoder and decoder */
+    sharedDictionary?: string[];
+    /**
+     * Strict binary mode - only accept BOOM binary format, reject text/JSON (default: false)
+     *
+     * Enable this in production to prevent clients from sending unexpected formats.
+     * When true, decode() will throw an error if the input doesn't start with BOOM magic bytes.
+     * This protects against:
+     * - Clients sending JSON instead of BOOM binary
+     * - Clients sending BOOM text format (debug mode)
+     * - Malformed or malicious input that might be parsed differently
+     */
+    strictBinaryMode?: boolean;
+}
+interface BoomTextOptions extends BoomOptions {
+    /** Use compact single-line format (default: false) */
+    compact?: boolean;
+    /** Indentation string for pretty printing (default: "  ") */
+    indentString?: string;
+}
+/**
+ * BOOM Built-in Shared Dictionary v1
+ *
+ * Comprehensive dictionary of common strings used in APIs, AI/LLM, HTTP, and web applications.
+ * This dictionary is shared across ALL BOOM implementations (JS, Go, PHP, Rust, Java, .NET, Swift, C++).
+ *
+ * IMPORTANT: This dictionary is versioned and MUST remain identical across all plugins.
+ * Never modify existing entries - only append new entries to maintain backwards compatibility.
+ *
+ * Organization (optimized for 1-byte varint encoding for indices < 128):
+ * - 0-31: Most common keys (id, name, type, content, data, etc.)
+ * - 32-63: API response fields
+ * - 64-95: AI/LLM streaming fields (OpenAI, Anthropic, etc.)
+ * - 96-127: Status and state values
+ * - 128-159: HTTP and headers
+ * - 160-191: Timestamps and dates
+ * - 192-223: User/auth fields
+ * - 224-255: Data types and formats
+ * - 256-287: Error handling
+ * - 288-319: Collections and pagination
+ * - 320+: Additional common fields
+ */
+declare const BOOM_DICTIONARY_V1: readonly string[];
+/**
+ * Dictionary analysis result showing which strings could benefit from being in the dictionary
+ */
+interface DictionaryAnalysisResult {
+    /** Strings already in the built-in dictionary (with their indices) */
+    inDictionary: {
+        string: string;
+        index: number;
+        count: number;
+    }[];
+    /** Strings NOT in the dictionary that appear frequently (sorted by potential savings) */
+    missingStrings: {
+        string: string;
+        count: number;
+        potentialSavings: number;
+    }[];
+    /** Summary statistics */
+    stats: {
+        totalStrings: number;
+        uniqueStrings: number;
+        dictionaryHits: number;
+        dictionaryMisses: number;
+        dictionaryHitRate: number;
+        potentialSavingsBytes: number;
+    };
+}
+/**
+ * Analyze data to find which strings are in the dictionary and which are missing.
+ * This helps users build custom dictionaries for their specific use cases.
+ *
+ * @param value - The data to analyze
+ * @returns Analysis showing dictionary hits, misses, and potential savings
+ *
+ * @example
+ * ```typescript
+ * const data = [
+ *   { myCustomField: 'value1', status: 'active' },
+ *   { myCustomField: 'value2', status: 'pending' },
+ * ];
+ * const analysis = analyzeDictionary(data);
+ * console.log('Missing strings:', analysis.missingStrings);
+ * // Use this to build a custom dictionary
+ * ```
+ */
+declare function analyzeDictionary(value: BoomValue): DictionaryAnalysisResult;
+/**
+ * Process all <script type="text/boom"> elements in the document
+ * and make their parsed data available via dataset
+ */
+declare function processBoomScripts$1(): Map<string, BoomValue>;
+/**
+ * Get parsed data from a specific BOOM script element
+ */
+declare function getBoomData$1(scriptId: string): BoomValue | undefined;
+/**
+ * Auto-initialise BOOM script processing when DOM is ready
+ */
+declare function autoInit$1(): void;
+/**
+ * Encode a value to BOOM binary format
+ */
+declare function encode(value: BoomValue, options?: BoomOptions): Uint8Array;
+/**
+ * Decode BOOM binary format to a value
+ */
+declare function decode(buffer: Uint8Array, options?: BoomOptions): BoomValue;
+/**
+ * Encode a value to BOOM text format
+ */
+declare function stringify(value: BoomValue, options?: BoomTextOptions): string;
+/**
+ * Parse BOOM text format to a value
+ */
+declare function parseText(input: string, options?: BoomOptions): BoomValue;
+/**
+ * Convert JSON to BOOM binary
+ */
+declare function fromJSON(json: string, options?: BoomOptions): Uint8Array;
+/**
+ * Result from encodeSmallest - includes format indicator
+ */
+interface SmallestEncodeResult {
+    /** The encoded data (BOOM binary or JSON) */
+    data: Uint8Array;
+    /** Format used: 'boom' or 'json' */
+    format: 'boom' | 'json';
+    /** Size comparison info */
+    sizes: {
+        boom: number;
+        json: number;
+    };
+}
+/**
+ * Encode to the smallest format for compressed transport.
+ * Compares BOOM binary vs JSON and returns whichever compresses smaller.
+ * Use this when you need GUARANTEED smallest output over HTTP with compression.
+ *
+ * @param value - Value to encode
+ * @param compress - Compression function to use for comparison (e.g., zlib.brotliCompressSync)
+ * @returns Result with data, format indicator, and size info
+ */
+declare function encodeSmallest(value: BoomValue, compress: (data: Uint8Array) => Uint8Array): SmallestEncodeResult;
+/**
+ * Decode data that was encoded with encodeSmallest
+ */
+declare function decodeSmallest(data: Uint8Array, format: 'boom' | 'json', options?: BoomOptions): BoomValue;
+/**
+ * Direct JSON-to-BOOM streaming parser
+ * Parses JSON directly to BOOM binary without creating intermediate objects
+ * Supports string interning for repeated strings
+ */
+declare function fromJSONDirect(json: string): Uint8Array;
+/**
+ * Convert BOOM binary to JSON
+ */
+declare function toJSON(buffer: Uint8Array, options?: BoomOptions): string;
+/**
+ * Calculate size comparison between JSON and BOOM
+ */
+declare function compare(value: BoomValue): {
+    jsonSize: number;
+    jsonMinSize: number;
+    boomBinarySize: number;
+    boomTextSize: number;
+    boomTextCompactSize: number;
+    savings: {
+        vsJson: string;
+        vsJsonMin: string;
+    };
+};
+/**
+ * Encode a value with 4-byte length prefix for streaming/pipe usage.
+ * Format: [4-byte little-endian length][BOOM data]
+ */
+declare function encodeWithLength(value: BoomValue, options?: BoomOptions): Uint8Array;
+/**
+ * Decode a single length-prefixed message from a buffer.
+ * Returns { value, bytesRead } or null if buffer doesn't have a complete message.
+ */
+declare function decodeFromLengthPrefixed(buffer: Uint8Array, offset?: number, options?: BoomOptions): {
+    value: BoomValue;
+    bytesRead: number;
+} | null;
+/**
+ * Stream decoder for processing length-prefixed BOOM messages from chunks.
+ * Accumulates partial data and yields complete messages.
+ */
+declare class StreamDecoder {
+    private buffer;
+    private writePos;
+    private options;
+    constructor(initialCapacity?: number, options?: BoomOptions);
+    /**
+     * Push a chunk of data and return any complete decoded messages.
+     */
+    push(chunk: Uint8Array): BoomValue[];
+    /**
+     * Check if there's pending partial data.
+     */
+    get hasPending(): boolean;
+    /**
+     * Clear any pending data.
+     */
+    clear(): void;
+}
+type BoomMode = 'boom-binary' | 'boom-text' | 'json';
+/**
+ * HTTP header names for threshold negotiation.
+ * Servers announce their policy, clients can hint expected payload size.
+ */
+declare const BoomHeaders: {
+    /** Server announces minimum payload size for BOOM (below this, JSON is acceptable) */
+    readonly MIN_SIZE: "X-Boom-Min-Size";
+    /** Server announces payload size where BOOM is preferred */
+    readonly PREFER_SIZE: "X-Boom-Prefer-Size";
+    /** Server announces payload size where BOOM is required */
+    readonly FORCE_SIZE: "X-Boom-Force-Size";
+    /** Client hints expected payload size: 'large', 'small', or byte count */
+    readonly EXPECTED_SIZE: "X-Boom-Expected-Size";
+    /** Server response indicates format used */
+    readonly FORMAT: "X-Boom-Format";
+    /** Server explains why format was chosen */
+    readonly REASON: "X-Boom-Reason";
+};
+/**
+ * Default threshold values based on benchmark data:
+ * - Below 1KB: JSON is often faster (native C++ implementation)
+ * - 1KB-10KB: Depends on structure (BOOM better for tabular)
+ * - 10KB-100KB: BOOM consistently faster
+ * - Above 100KB: BOOM significantly faster (40-70% smaller, 2-5x faster decode)
+ */
+declare const DEFAULT_THRESHOLDS: {
+    /** Below this, use JSON (default: 1KB) */
+    readonly minSize: 1024;
+    /** Above this, prefer BOOM (default: 10KB) */
+    readonly preferSize: 10240;
+    /** Above this, always use BOOM (default: 100KB) */
+    readonly forceSize: 102400;
+};
+/**
+ * Configuration for automatic format selection based on payload size.
+ */
+interface BoomThresholdConfig {
+    /** Below this size in bytes, use JSON (default: 1024) */
+    minSize?: number;
+    /** Above this size in bytes, prefer BOOM (default: 10240) */
+    preferSize?: number;
+    /** Above this size in bytes, always use BOOM (default: 102400) */
+    forceSize?: number;
+    /** Enable automatic format detection (default: true) */
+    autoDetect?: boolean;
+    /** Honor client X-Boom-Expected-Size hints (default: true) */
+    respectClientHint?: boolean;
+}
+/**
+ * Set global threshold configuration for automatic format selection.
+ *
+ * @example
+ * ```typescript
+ * setThresholdConfig({
+ *   minSize: 2048,     // Use JSON below 2KB
+ *   forceSize: 50000,  // Force BOOM above 50KB
+ * });
+ * ```
+ */
+declare function setThresholdConfig(config: BoomThresholdConfig): void;
+/**
+ * Get the current global threshold configuration.
+ */
+declare function getThresholdConfig(): Required<BoomThresholdConfig>;
+/**
+ * Select the optimal format based on payload size and configuration.
+ *
+ * @param payloadSize - Size of the payload in bytes
+ * @param config - Optional threshold configuration (uses global if not provided)
+ * @param clientHint - Optional client hint ('large', 'small', or byte count)
+ * @returns The recommended BoomMode and reason
+ *
+ * @example
+ * ```typescript
+ * const { mode, reason } = selectFormat(500);
+ * // mode: 'json', reason: 'size-below-threshold'
+ *
+ * const { mode, reason } = selectFormat(200000);
+ * // mode: 'boom-binary', reason: 'size-above-force'
+ *
+ * const { mode, reason } = selectFormat(500, undefined, 'large');
+ * // mode: 'boom-binary', reason: 'client-hint'
+ * ```
+ */
+declare function selectFormat(payloadSize: number, config?: BoomThresholdConfig, clientHint?: string): {
+    mode: BoomMode;
+    reason: string;
+};
+/**
+ * Estimate the encoded size of a value (for format selection before encoding).
+ * This is a fast approximation - actual encoded size may vary.
+ *
+ * @param value - The value to estimate
+ * @returns Estimated size in bytes
+ */
+declare function estimateSize(value: BoomValue): number;
+/**
+ * Create threshold headers for server responses.
+ * Servers should include these to announce their threshold policy.
+ *
+ * @param config - Optional custom thresholds (uses global if not provided)
+ * @returns Headers object to spread into response
+ *
+ * @example
+ * ```typescript
+ * // Express middleware
+ * app.use((req, res, next) => {
+ *   const headers = createThresholdHeaders();
+ *   Object.entries(headers).forEach(([k, v]) => res.setHeader(k, v));
+ *   next();
+ * });
+ * ```
+ */
+declare function createThresholdHeaders(config?: BoomThresholdConfig): Record<string, string>;
+/**
+ * Parse threshold configuration from response headers.
+ *
+ * @param headers - Response headers (Headers object or plain object)
+ * @returns Parsed threshold config or null if no threshold headers present
+ */
+declare function parseThresholdHeaders(headers: Headers | Record<string, string>): BoomThresholdConfig | null;
+/**
+ * Set the global BOOM mode for all HTTP helpers.
+ * - 'boom-binary': Binary format (smallest, fastest - production)
+ * - 'boom-text': Text format (readable BOOM syntax - debugging)
+ * - 'json': Standard JSON (maximum compatibility - debugging)
+ */
+declare function setBoomMode(mode: BoomMode): void;
+/**
+ * Get the current global BOOM mode.
+ */
+declare function getBoomMode(): BoomMode;
+interface BoomFetchOptions$1 extends Omit<RequestInit, 'body' | 'mode'> {
+    body?: BoomValue;
+    params?: Record<string, string | number | boolean>;
+    /** BOOM mode: 'boom' for binary (production), 'json' for debugging */
+    boomMode?: BoomMode;
+    /** Standard fetch mode (cors, no-cors, same-origin) */
+    mode?: RequestMode;
+    /** Enable auto-format selection based on payload size (default: false for backwards compat) */
+    autoFormat?: boolean;
+    /** Threshold configuration for auto-format selection */
+    threshold?: BoomThresholdConfig;
+    /** Hint to server about expected response size ('large', 'small', or byte count) */
+    expectedSize?: 'large' | 'small' | number;
+}
+/**
+ * Drop-in fetch replacement with automatic BOOM encoding/decoding.
+ * Supports easy switching between JSON (debugging) and BOOM (production).
+ *
+ * @example
+ * ```typescript
+ * // GET request
+ * const users = await boomFetch('/api/users');
+ *
+ * // POST request
+ * const newUser = await boomFetch('/api/users', {
+ *   method: 'POST',
+ *   body: { name: 'Alice', role: 'admin' }
+ * });
+ *
+ * // With query params
+ * const admins = await boomFetch('/api/users', {
+ *   params: { role: 'admin', limit: 10 }
+ * });
+ *
+ * // Force JSON mode for debugging
+ * const data = await boomFetch('/api/users', { boomMode: 'json' });
+ *
+ * // Auto-format selection based on payload size
+ * const largeData = await boomFetch('/api/data', {
+ *   body: hugeDataset,
+ *   autoFormat: true  // Automatically uses BOOM for large payloads
+ * });
+ *
+ * // Hint to server about expected response size
+ * const report = await boomFetch('/api/reports/full', {
+ *   expectedSize: 'large'  // Server will use BOOM format
+ * });
+ * ```
+ */
+declare function boomFetch$1<T = BoomValue>(url: string, options?: BoomFetchOptions$1): Promise<T>;
+interface BoomAxiosConfig$1 {
+    baseURL?: string;
+    headers?: Record<string, string>;
+    boomMode?: BoomMode;
+}
+interface BoomAxiosInstance$1 {
+    get<T = BoomValue>(url: string, config?: {
+        params?: Record<string, string | number | boolean>;
+    }): Promise<{
+        data: T;
+    }>;
+    post<T = BoomValue>(url: string, data?: BoomValue): Promise<{
+        data: T;
+    }>;
+    put<T = BoomValue>(url: string, data?: BoomValue): Promise<{
+        data: T;
+    }>;
+    patch<T = BoomValue>(url: string, data?: BoomValue): Promise<{
+        data: T;
+    }>;
+    delete<T = BoomValue>(url: string): Promise<{
+        data: T;
+    }>;
+    setBoomMode(mode: BoomMode): void;
+}
+/**
+ * Create an axios-like instance with automatic BOOM encoding/decoding.
+ *
+ * @example
+ * ```typescript
+ * const api = createBoomAxios({
+ *   baseURL: 'https://api.example.com',
+ *   boomMode: 'boom-binary'
+ * });
+ *
+ * const { data: users } = await api.get('/users');
+ * const { data: user } = await api.post('/users', { name: 'Alice' });
+ *
+ * // Switch to JSON for debugging
+ * api.setBoomMode('json');
+ * ```
+ */
+declare function createBoomAxios$1(config?: BoomAxiosConfig$1): BoomAxiosInstance$1;
+interface BoomGraphQLConfig$1 {
+    url: string;
+    headers?: Record<string, string>;
+    boomMode?: BoomMode;
+}
+interface BoomGraphQLClient$1 {
+    query<T = Record<string, unknown>>(query: string, variables?: Record<string, unknown>): Promise<T>;
+    mutate<T = Record<string, unknown>>(mutation: string, variables?: Record<string, unknown>): Promise<T>;
+    setBoomMode(mode: BoomMode): void;
+}
+/**
+ * Create a GraphQL client with automatic BOOM encoding/decoding.
+ *
+ * @example
+ * ```typescript
+ * const gql = createBoomGraphQL({
+ *   url: '/graphql',
+ *   boomMode: 'boom-binary'
+ * });
+ *
+ * const { users } = await gql.query(`
+ *   query { users { id name } }
+ * `);
+ *
+ * const { createUser } = await gql.mutate(`
+ *   mutation CreateUser($name: String!) {
+ *     createUser(name: $name) { id name }
+ *   }
+ * `, { name: 'Alice' });
+ * ```
+ */
+declare function createBoomGraphQL$1(config: BoomGraphQLConfig$1): BoomGraphQLClient$1;
+
+/**
+ * BOOM Fetch Adapter
+ * Drop-in fetch replacement with automatic BOOM encoding/decoding
+ * @module boom-format/http/fetch
+ */
+
+interface BoomFetchOptions extends Omit<RequestInit, 'body' | 'mode'> {
+    body?: BoomValue$1;
+    params?: Record<string, string | number | boolean>;
+    boomMode?: BoomMode$1;
+    mode?: RequestMode;
+    autoFormat?: boolean;
+    threshold?: BoomThresholdConfig$1;
+    expectedSize?: 'large' | 'small' | number;
+}
+/**
+ * Drop-in fetch replacement with automatic BOOM encoding/decoding
+ */
+declare function boomFetch<T = BoomValue$1>(url: string, options?: BoomFetchOptions): Promise<T>;
+
+/**
+ * BOOM Axios-like Adapter
+ * Create axios-style instances with automatic BOOM encoding/decoding
+ * @module boom-format/http/axios
+ */
+
+interface BoomAxiosConfig {
+    baseURL?: string;
+    headers?: Record<string, string>;
+    boomMode?: BoomMode$1;
+}
+interface BoomAxiosInstance {
+    get<T = BoomValue$1>(url: string, config?: {
+        params?: Record<string, string | number | boolean>;
+    }): Promise<{
+        data: T;
+    }>;
+    post<T = BoomValue$1>(url: string, data?: BoomValue$1): Promise<{
+        data: T;
+    }>;
+    put<T = BoomValue$1>(url: string, data?: BoomValue$1): Promise<{
+        data: T;
+    }>;
+    patch<T = BoomValue$1>(url: string, data?: BoomValue$1): Promise<{
+        data: T;
+    }>;
+    delete<T = BoomValue$1>(url: string): Promise<{
+        data: T;
+    }>;
+    setBoomMode(mode: BoomMode$1): void;
+}
+/**
+ * Create an axios-like instance with automatic BOOM encoding/decoding
+ */
+declare function createBoomAxios(config?: BoomAxiosConfig): BoomAxiosInstance;
+
+/**
+ * BOOM GraphQL Adapter
+ * GraphQL client with automatic BOOM encoding/decoding
+ * @module boom-format/http/graphql
+ */
+
+interface BoomGraphQLConfig {
+    url: string;
+    headers?: Record<string, string>;
+    boomMode?: BoomMode$1;
+}
+interface BoomGraphQLClient {
+    query<T = Record<string, unknown>>(query: string, variables?: Record<string, unknown>): Promise<T>;
+    mutate<T = Record<string, unknown>>(mutation: string, variables?: Record<string, unknown>): Promise<T>;
+    setBoomMode(mode: BoomMode$1): void;
+}
+/**
+ * Create a GraphQL client with automatic BOOM encoding/decoding
+ */
+declare function createBoomGraphQL(config: BoomGraphQLConfig): BoomGraphQLClient;
+
+/**
+ * BOOM Browser Utilities
+ * DOM integration for script elements with BOOM data
+ * @module boom-format/browser
+ */
+
+/**
+ * Process all <script type="text/boom"> elements in the document
+ * Parses BOOM text format and stores result on the element
+ */
+declare function processBoomScripts(): Map<string, BoomValue$1>;
+/**
+ * Get parsed data from a specific BOOM script element
+ */
+declare function getBoomData(scriptId: string): BoomValue$1 | undefined;
+/**
+ * Auto-initialise BOOM script processing when DOM is ready
+ */
+declare function autoInit(): void;
+
+/**
+ * BOOM Constants
+ * @module boom-format/constants
+ */
+
+declare const MAGIC: Uint8Array<ArrayBuffer>;
+declare const VERSION = 1;
+
+/**
+ * BOOM - Binary Object Optimised Markup
+ * A compact binary serialization format with readable debug mode
+ *
+ * @module boom-format
+ * @version 1.0.0
+ * @license MIT
+ */
+
+declare const _default: {
+    encode: typeof encode;
+    decode: typeof decode;
+    stringify: typeof stringify;
+    parseText: typeof parseText;
+    fromJSON: typeof fromJSON;
+    toJSON: typeof toJSON;
+    compare: typeof compare;
+    encodeWithLength: typeof encodeWithLength;
+    decodeFromLengthPrefixed: typeof decodeFromLengthPrefixed;
+    StreamDecoder: typeof StreamDecoder;
+    processBoomScripts: typeof processBoomScripts$1;
+    getBoomData: typeof getBoomData$1;
+    autoInit: typeof autoInit$1;
+    BoomError: typeof BoomError;
+    setBoomMode: typeof setBoomMode;
+    getBoomMode: typeof getBoomMode;
+    boomFetch: typeof boomFetch$1;
+    createBoomAxios: typeof createBoomAxios$1;
+    createBoomGraphQL: typeof createBoomGraphQL$1;
+    BoomHeaders: {
+        readonly MIN_SIZE: "X-Boom-Min-Size";
+        readonly PREFER_SIZE: "X-Boom-Prefer-Size";
+        readonly FORCE_SIZE: "X-Boom-Force-Size";
+        readonly EXPECTED_SIZE: "X-Boom-Expected-Size";
+        readonly FORMAT: "X-Boom-Format";
+        readonly REASON: "X-Boom-Reason";
+    };
+    DEFAULT_THRESHOLDS: {
+        readonly minSize: 1024;
+        readonly preferSize: 10240;
+        readonly forceSize: 102400;
+    };
+    setThresholdConfig: typeof setThresholdConfig;
+    getThresholdConfig: typeof getThresholdConfig;
+    selectFormat: typeof selectFormat;
+    estimateSize: typeof estimateSize;
+    createThresholdHeaders: typeof createThresholdHeaders;
+    parseThresholdHeaders: typeof parseThresholdHeaders;
+};
+
+export { BOOM_DICTIONARY_V1, VERSION as BOOM_VERSION, type BoomArray$1 as BoomArray, type BoomAxiosConfig, type BoomAxiosInstance, BoomError, type BoomFetchOptions, type BoomGraphQLClient, type BoomGraphQLConfig, BoomHeaders, type BoomMode$1 as BoomMode, type BoomObject$1 as BoomObject, type BoomOptions$1 as BoomOptions, type BoomPrimitive$1 as BoomPrimitive, type BoomTextOptions$1 as BoomTextOptions, type BoomThresholdConfig$1 as BoomThresholdConfig, type BoomValue$1 as BoomValue, ByteReader, ByteWriter, DEFAULT_THRESHOLDS, type DictionaryAnalysisResult, MAGIC, type SmallestEncodeResult$1 as SmallestEncodeResult, StreamDecoder, analyzeDictionary, autoInit, boomFetch, compare, createBoomAxios, createBoomGraphQL, createThresholdHeaders, decode, decodeFromLengthPrefixed, decodeSmallest, _default as default, encode, encodeSmallest, encodeWithLength, estimateSize, fromJSON, fromJSONDirect, getBoomData, getBoomMode, getThresholdConfig, parseText, parseThresholdHeaders, processBoomScripts, selectFormat, setBoomMode, setThresholdConfig, stringify, toJSON, zigzagDecode, zigzagEncode };