@structured-world/structured-zstd 0.0.32 → 0.0.34

package/scalar/structured_zstd_wasm.d.ts

@@ -1,11 +1,31 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * How the decoder treats a frame's optional content checksum. Mirrors the
+ * core `structured_zstd::decoding::ContentChecksum`.
+ */
+export enum ContentChecksum {
+    /**
+     * Skip the XXH64 pass entirely (fastest; no verification).
+     */
+    None = 0,
+    /**
+     * Compute the checksum and expose it via accessors; does not error on a mismatch.
+     */
+    EmitOnly = 1,
+    /**
+     * Compute and verify; a mismatch throws on decode.
+     */
+    Verify = 2,
+}
+
 /**
  * Incremental streaming compressor: feed plaintext chunks via
  * [`ZstdCompressStream::push`] and receive complete compressed blocks as the
  * matcher window fills, then [`ZstdCompressStream::finish`] to seal the frame
- * (final block + content checksum). Peak working set is O(window), not
+ * (final block, plus the XXH64 trailer only when `checksum` was enabled).
+ * Peak working set is O(window), not
  * O(input) — emitted blocks are flushed to the caller while only the matcher
  * window is retained — so a large payload never has to be buffered whole. The
  * produced frame omits `Frame_Content_Size` (the total is unknown while
@@ -22,14 +42,26 @@ export class ZstdCompressStream {
     finish(): Uint8Array;
     /**
      * Open a streaming compressor at `level` (zstd scale: `1..=22`, negatives
-     * for the ultra-fast tier).
+     * for the ultra-fast tier). `checksum` is optional (default `false`,
+     * matching libzstd's `ZSTD_c_checksumFlag = 0`): pass `true` to seal the
+     * frame with a trailing content checksum.
      */
-    constructor(level: number);
+    constructor(level: number, checksum?: boolean | null);
     /**
      * Feed more plaintext; returns whatever compressed bytes are now complete
      * (possibly empty while the current block is still filling).
      */
     push(chunk: Uint8Array): Uint8Array;
+    /**
+     * Open a streaming compressor at `level` seeded with a raw zstd dictionary
+     * blob (e.g. from `zstd --train`), mirroring `ZSTD_CCtx_loadDictionary` on
+     * a streaming context: the dictionary primes the matcher and seeds the
+     * first block's entropy + repeat offsets, and its ID is written into the
+     * frame header. Decode the produced frames with [`ZstdDecompressStream`]
+     * opened via its matching `withDictionary` constructor (or the one-shot
+     * `decompressUsingDict`). Throws if the dictionary is invalid.
+     */
+    static withDictionary(level: number, dict: Uint8Array, checksum?: boolean | null): ZstdCompressStream;
 }
 
 /**
@@ -42,17 +74,44 @@ export class ZstdCompressStream {
 export class ZstdDecompressStream {
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * The XXH64 digest the decoder computed over the output (low 32 bits), or
+     * `undefined` when the mode is `None` or the frame carried no checksum.
+     * Meaningful after [`Self::finish`]; lets callers verify manually under
+     * `EmitOnly` without enabling the throwing `Verify` mode.
+     */
+    calculatedChecksum(): number | undefined;
     /**
      * Signal end of input; returns the final decompressed bytes. Throws if the
-     * stream ended before the frame completed.
+     * stream ended before the frame completed, or (in `Verify` mode) if the
+     * content checksum does not match.
      */
     finish(): Uint8Array;
-    constructor();
+    /**
+     * `checksum` is optional (default `None` — skip the XXH64 pass, matching
+     * the one-shot `decompress` default) and applies to the whole stream, so
+     * set it here rather than mid-stream: `Verify` validates the content
+     * checksum at [`Self::finish`], `EmitOnly` computes it without erroring.
+     */
+    constructor(checksum?: ContentChecksum | null);
     /**
      * Feed more compressed bytes; returns whatever decompressed output is now
      * available (possibly empty while a block is still incomplete).
      */
     push(chunk: Uint8Array): Uint8Array;
+    /**
+     * The content checksum stored in the frame's 4-byte trailer, or
+     * `undefined` if the frame carried none. Meaningful after [`Self::finish`].
+     */
+    storedChecksum(): number | undefined;
+    /**
+     * Open a streaming decompressor primed with a raw zstd dictionary blob
+     * (`ZSTD_DCtx_loadDictionary`): `dict` must be the same dictionary the
+     * frame was compressed with (e.g. via [`ZstdCompressStream`]'s
+     * `withDictionary`). `checksum` behaves as in [`Self::new`]. Throws if the
+     * dictionary is malformed.
+     */
+    static withDictionary(dict: Uint8Array, checksum?: ContentChecksum | null): ZstdDecompressStream;
 }
 
 /**
@@ -61,8 +120,12 @@ export class ZstdDecompressStream {
  * `level` follows the zstd scale: `1..=22` (higher = smaller/slower) and
  * negative levels (`-7..=-1`) for the ultra-fast tier. The returned frame
  * decodes in any compliant zstd decoder, including the native C library.
+ *
+ * `checksum` is optional (default `false`, matching libzstd's
+ * `ZSTD_c_checksumFlag = 0`): pass `true` to append the trailing XXH64 content
+ * checksum.
  */
-export function compress(data: Uint8Array, level: number): Uint8Array;
+export function compress(data: Uint8Array, level: number, checksum?: boolean | null): Uint8Array;
 
 /**
  * Compress `data` against a raw Zstandard dictionary at compression `level`.
@@ -70,15 +133,22 @@ export function compress(data: Uint8Array, level: number): Uint8Array;
  * Mirrors C `ZSTD_compress_usingDict`: the dictionary primes the encoder so
  * small, similar payloads compress far better. The dictionary is the raw
  * zstd dictionary blob (e.g. from `zstd --train`). Throws if it is invalid.
+ *
+ * `checksum` is optional (default `false`, matching libzstd's
+ * `ZSTD_c_checksumFlag = 0`); pass `true` to append the XXH64 trailer.
  */
-export function compressUsingDict(data: Uint8Array, dict: Uint8Array, level: number): Uint8Array;
+export function compressUsingDict(data: Uint8Array, dict: Uint8Array, level: number, checksum?: boolean | null): Uint8Array;
 
 /**
  * Decompress a complete Zstandard frame back into its original bytes.
  *
- * Throws a JavaScript `Error` if the input is not a valid, complete frame.
+ * Throws a JavaScript `Error` if the input is not a valid, complete frame,
+ * or (when `checksum` is `Verify`) if the content checksum does not match.
+ * `checksum` is optional (default `None` — skip the XXH64 pass for speed);
+ * pass `ContentChecksum.Verify` to validate, or `EmitOnly` to compute without
+ * erroring on mismatch.
  */
-export function decompress(data: Uint8Array): Uint8Array;
+export function decompress(data: Uint8Array, checksum?: ContentChecksum | null): Uint8Array;
 
 /**
  * Decompress a dictionary-encoded Zstandard frame.
@@ -87,7 +157,7 @@ export function decompress(data: Uint8Array): Uint8Array;
  * dictionary the frame was compressed with. Throws on a malformed frame or a
  * dictionary mismatch.
  */
-export function decompressUsingDict(data: Uint8Array, dict: Uint8Array): Uint8Array;
+export function decompressUsingDict(data: Uint8Array, dict: Uint8Array, checksum?: ContentChecksum | null): Uint8Array;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
@@ -95,16 +165,20 @@ export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_zstdcompressstream_free: (a: number, b: number) => void;
     readonly __wbg_zstddecompressstream_free: (a: number, b: number) => void;
-    readonly compress: (a: number, b: number, c: number) => [number, number];
-    readonly compressUsingDict: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
-    readonly decompress: (a: number, b: number) => [number, number, number, number];
-    readonly decompressUsingDict: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly compress: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly compressUsingDict: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
+    readonly decompress: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly decompressUsingDict: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
     readonly zstdcompressstream_finish: (a: number) => [number, number, number, number];
-    readonly zstdcompressstream_new: (a: number) => number;
+    readonly zstdcompressstream_new: (a: number, b: number) => number;
     readonly zstdcompressstream_push: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly zstdcompressstream_withDictionary: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly zstddecompressstream_calculatedChecksum: (a: number) => number;
     readonly zstddecompressstream_finish: (a: number) => [number, number, number, number];
-    readonly zstddecompressstream_new: () => number;
+    readonly zstddecompressstream_new: (a: number) => number;
     readonly zstddecompressstream_push: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly zstddecompressstream_storedChecksum: (a: number) => number;
+    readonly zstddecompressstream_withDictionary: (a: number, b: number, c: number) => [number, number, number];
     readonly __wbindgen_externrefs: WebAssembly.Table;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_free: (a: number, b: number, c: number) => void;

package/scalar/structured_zstd_wasm.js

@@ -1,10 +1,31 @@
 /* @ts-self-types="./structured_zstd_wasm.d.ts" */
 
+/**
+ * How the decoder treats a frame's optional content checksum. Mirrors the
+ * core `structured_zstd::decoding::ContentChecksum`.
+ * @enum {0 | 1 | 2}
+ */
+export const ContentChecksum = Object.freeze({
+    /**
+     * Skip the XXH64 pass entirely (fastest; no verification).
+     */
+    None: 0, "0": "None",
+    /**
+     * Compute the checksum and expose it via accessors; does not error on a mismatch.
+     */
+    EmitOnly: 1, "1": "EmitOnly",
+    /**
+     * Compute and verify; a mismatch throws on decode.
+     */
+    Verify: 2, "2": "Verify",
+});
+
 /**
  * Incremental streaming compressor: feed plaintext chunks via
  * [`ZstdCompressStream::push`] and receive complete compressed blocks as the
  * matcher window fills, then [`ZstdCompressStream::finish`] to seal the frame
- * (final block + content checksum). Peak working set is O(window), not
+ * (final block, plus the XXH64 trailer only when `checksum` was enabled).
+ * Peak working set is O(window), not
  * O(input) — emitted blocks are flushed to the caller while only the matcher
  * window is retained — so a large payload never has to be buffered whole. The
  * produced frame omits `Frame_Content_Size` (the total is unknown while
@@ -12,6 +33,12 @@
  * [`ZstdDecompressStream`], making the wasm streaming API symmetric.
  */
 export class ZstdCompressStream {
+    static __wrap(ptr) {
+        const obj = Object.create(ZstdCompressStream.prototype);
+        obj.__wbg_ptr = ptr;
+        ZstdCompressStreamFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -38,11 +65,14 @@ export class ZstdCompressStream {
     }
     /**
      * Open a streaming compressor at `level` (zstd scale: `1..=22`, negatives
-     * for the ultra-fast tier).
+     * for the ultra-fast tier). `checksum` is optional (default `false`,
+     * matching libzstd's `ZSTD_c_checksumFlag = 0`): pass `true` to seal the
+     * frame with a trailing content checksum.
      * @param {number} level
+     * @param {boolean | null} [checksum]
      */
-    constructor(level) {
-        const ret = wasm.zstdcompressstream_new(level);
+    constructor(level, checksum) {
+        const ret = wasm.zstdcompressstream_new(level, isLikeNone(checksum) ? 0xFFFFFF : checksum ? 1 : 0);
         this.__wbg_ptr = ret;
         ZstdCompressStreamFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -64,6 +94,28 @@ export class ZstdCompressStream {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v2;
     }
+    /**
+     * Open a streaming compressor at `level` seeded with a raw zstd dictionary
+     * blob (e.g. from `zstd --train`), mirroring `ZSTD_CCtx_loadDictionary` on
+     * a streaming context: the dictionary primes the matcher and seeds the
+     * first block's entropy + repeat offsets, and its ID is written into the
+     * frame header. Decode the produced frames with [`ZstdDecompressStream`]
+     * opened via its matching `withDictionary` constructor (or the one-shot
+     * `decompressUsingDict`). Throws if the dictionary is invalid.
+     * @param {number} level
+     * @param {Uint8Array} dict
+     * @param {boolean | null} [checksum]
+     * @returns {ZstdCompressStream}
+     */
+    static withDictionary(level, dict, checksum) {
+        const ptr0 = passArray8ToWasm0(dict, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.zstdcompressstream_withDictionary(level, ptr0, len0, isLikeNone(checksum) ? 0xFFFFFF : checksum ? 1 : 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ZstdCompressStream.__wrap(ret[0]);
+    }
 }
 if (Symbol.dispose) ZstdCompressStream.prototype[Symbol.dispose] = ZstdCompressStream.prototype.free;
 
@@ -75,6 +127,12 @@ if (Symbol.dispose) ZstdCompressStream.prototype[Symbol.dispose] = ZstdCompressS
  * buffered — a surface the common npm wasm zstd packages do not offer.
  */
 export class ZstdDecompressStream {
+    static __wrap(ptr) {
+        const obj = Object.create(ZstdDecompressStream.prototype);
+        obj.__wbg_ptr = ptr;
+        ZstdDecompressStreamFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -85,9 +143,21 @@ export class ZstdDecompressStream {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_zstddecompressstream_free(ptr, 0);
     }
+    /**
+     * The XXH64 digest the decoder computed over the output (low 32 bits), or
+     * `undefined` when the mode is `None` or the frame carried no checksum.
+     * Meaningful after [`Self::finish`]; lets callers verify manually under
+     * `EmitOnly` without enabling the throwing `Verify` mode.
+     * @returns {number | undefined}
+     */
+    calculatedChecksum() {
+        const ret = wasm.zstddecompressstream_calculatedChecksum(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * Signal end of input; returns the final decompressed bytes. Throws if the
-     * stream ended before the frame completed.
+     * stream ended before the frame completed, or (in `Verify` mode) if the
+     * content checksum does not match.
      * @returns {Uint8Array}
      */
     finish() {
@@ -99,8 +169,15 @@ export class ZstdDecompressStream {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
-    constructor() {
-        const ret = wasm.zstddecompressstream_new();
+    /**
+     * `checksum` is optional (default `None` — skip the XXH64 pass, matching
+     * the one-shot `decompress` default) and applies to the whole stream, so
+     * set it here rather than mid-stream: `Verify` validates the content
+     * checksum at [`Self::finish`], `EmitOnly` computes it without erroring.
+     * @param {ContentChecksum | null} [checksum]
+     */
+    constructor(checksum) {
+        const ret = wasm.zstddecompressstream_new(isLikeNone(checksum) ? 3 : checksum);
         this.__wbg_ptr = ret;
         ZstdDecompressStreamFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -122,6 +199,34 @@ export class ZstdDecompressStream {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v2;
     }
+    /**
+     * The content checksum stored in the frame's 4-byte trailer, or
+     * `undefined` if the frame carried none. Meaningful after [`Self::finish`].
+     * @returns {number | undefined}
+     */
+    storedChecksum() {
+        const ret = wasm.zstddecompressstream_storedChecksum(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * Open a streaming decompressor primed with a raw zstd dictionary blob
+     * (`ZSTD_DCtx_loadDictionary`): `dict` must be the same dictionary the
+     * frame was compressed with (e.g. via [`ZstdCompressStream`]'s
+     * `withDictionary`). `checksum` behaves as in [`Self::new`]. Throws if the
+     * dictionary is malformed.
+     * @param {Uint8Array} dict
+     * @param {ContentChecksum | null} [checksum]
+     * @returns {ZstdDecompressStream}
+     */
+    static withDictionary(dict, checksum) {
+        const ptr0 = passArray8ToWasm0(dict, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.zstddecompressstream_withDictionary(ptr0, len0, isLikeNone(checksum) ? 3 : checksum);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ZstdDecompressStream.__wrap(ret[0]);
+    }
 }
 if (Symbol.dispose) ZstdDecompressStream.prototype[Symbol.dispose] = ZstdDecompressStream.prototype.free;
 
@@ -131,14 +236,19 @@ if (Symbol.dispose) ZstdDecompressStream.prototype[Symbol.dispose] = ZstdDecompr
  * `level` follows the zstd scale: `1..=22` (higher = smaller/slower) and
  * negative levels (`-7..=-1`) for the ultra-fast tier. The returned frame
  * decodes in any compliant zstd decoder, including the native C library.
+ *
+ * `checksum` is optional (default `false`, matching libzstd's
+ * `ZSTD_c_checksumFlag = 0`): pass `true` to append the trailing XXH64 content
+ * checksum.
  * @param {Uint8Array} data
  * @param {number} level
+ * @param {boolean | null} [checksum]
  * @returns {Uint8Array}
  */
-export function compress(data, level) {
+export function compress(data, level, checksum) {
     const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.compress(ptr0, len0, level);
+    const ret = wasm.compress(ptr0, len0, level, isLikeNone(checksum) ? 0xFFFFFF : checksum ? 1 : 0);
     var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v2;
@@ -150,17 +260,21 @@ export function compress(data, level) {
  * Mirrors C `ZSTD_compress_usingDict`: the dictionary primes the encoder so
  * small, similar payloads compress far better. The dictionary is the raw
  * zstd dictionary blob (e.g. from `zstd --train`). Throws if it is invalid.
+ *
+ * `checksum` is optional (default `false`, matching libzstd's
+ * `ZSTD_c_checksumFlag = 0`); pass `true` to append the XXH64 trailer.
  * @param {Uint8Array} data
  * @param {Uint8Array} dict
  * @param {number} level
+ * @param {boolean | null} [checksum]
  * @returns {Uint8Array}
  */
-export function compressUsingDict(data, dict, level) {
+export function compressUsingDict(data, dict, level, checksum) {
     const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray8ToWasm0(dict, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.compressUsingDict(ptr0, len0, ptr1, len1, level);
+    const ret = wasm.compressUsingDict(ptr0, len0, ptr1, len1, level, isLikeNone(checksum) ? 0xFFFFFF : checksum ? 1 : 0);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
@@ -172,14 +286,19 @@ export function compressUsingDict(data, dict, level) {
 /**
  * Decompress a complete Zstandard frame back into its original bytes.
  *
- * Throws a JavaScript `Error` if the input is not a valid, complete frame.
+ * Throws a JavaScript `Error` if the input is not a valid, complete frame,
+ * or (when `checksum` is `Verify`) if the content checksum does not match.
+ * `checksum` is optional (default `None` — skip the XXH64 pass for speed);
+ * pass `ContentChecksum.Verify` to validate, or `EmitOnly` to compute without
+ * erroring on mismatch.
  * @param {Uint8Array} data
+ * @param {ContentChecksum | null} [checksum]
  * @returns {Uint8Array}
  */
-export function decompress(data) {
+export function decompress(data, checksum) {
     const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.decompress(ptr0, len0);
+    const ret = wasm.decompress(ptr0, len0, isLikeNone(checksum) ? 3 : checksum);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
@@ -196,14 +315,15 @@ export function decompress(data) {
  * dictionary mismatch.
  * @param {Uint8Array} data
  * @param {Uint8Array} dict
+ * @param {ContentChecksum | null} [checksum]
  * @returns {Uint8Array}
  */
-export function decompressUsingDict(data, dict) {
+export function decompressUsingDict(data, dict, checksum) {
     const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray8ToWasm0(dict, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.decompressUsingDict(ptr0, len0, ptr1, len1);
+    const ret = wasm.decompressUsingDict(ptr0, len0, ptr1, len1, isLikeNone(checksum) ? 3 : checksum);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
@@ -214,11 +334,11 @@ export function decompressUsingDict(data, dict) {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_ef53bc310eb298a0: function(arg0, arg1) {
+        __wbg_Error_9dc85fe1bc224456: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+        __wbg___wbindgen_throw_bbadd78c1bac3a77: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
         __wbindgen_init_externref_table: function() {
@@ -261,6 +381,10 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);

package/scalar/structured_zstd_wasm_bg.wasm.d.ts

@@ -3,16 +3,20 @@
 export const memory: WebAssembly.Memory;
 export const __wbg_zstdcompressstream_free: (a: number, b: number) => void;
 export const __wbg_zstddecompressstream_free: (a: number, b: number) => void;
-export const compress: (a: number, b: number, c: number) => [number, number];
-export const compressUsingDict: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
-export const decompress: (a: number, b: number) => [number, number, number, number];
-export const decompressUsingDict: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const compress: (a: number, b: number, c: number, d: number) => [number, number];
+export const compressUsingDict: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
+export const decompress: (a: number, b: number, c: number) => [number, number, number, number];
+export const decompressUsingDict: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
 export const zstdcompressstream_finish: (a: number) => [number, number, number, number];
-export const zstdcompressstream_new: (a: number) => number;
+export const zstdcompressstream_new: (a: number, b: number) => number;
 export const zstdcompressstream_push: (a: number, b: number, c: number) => [number, number, number, number];
+export const zstdcompressstream_withDictionary: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const zstddecompressstream_calculatedChecksum: (a: number) => number;
 export const zstddecompressstream_finish: (a: number) => [number, number, number, number];
-export const zstddecompressstream_new: () => number;
+export const zstddecompressstream_new: (a: number) => number;
 export const zstddecompressstream_push: (a: number, b: number, c: number) => [number, number, number, number];
+export const zstddecompressstream_storedChecksum: (a: number) => number;
+export const zstddecompressstream_withDictionary: (a: number, b: number, c: number) => [number, number, number];
 export const __wbindgen_externrefs: WebAssembly.Table;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_free: (a: number, b: number, c: number) => void;