@unicom-cloud/utils 0.1.10 → 0.1.11

package/types/nzh/nzh.d.ts

@@ -0,0 +1,36 @@
+export default Nzh;
+declare function Nzh(lang: any): void;
+declare class Nzh {
+    constructor(lang: any);
+    lang: any;
+    encode: (...args: any[]) => string;
+    decode: (...args: any[]) => string | number;
+    toMoney: (...args: any[]) => string;
+}
+declare namespace Nzh {
+    export { langs };
+    export let cn: {
+        encodeS: (num: any, options: any) => string;
+        encodeB: (num: any, options: any) => string;
+        decodeS: (...args: any[]) => string | number;
+        decodeB: (...args: any[]) => string | number;
+        toMoney: (num: any, options: any) => string;
+    };
+    export let hk: {
+        encodeS: (num: any, options: any) => string;
+        encodeB: (num: any, options: any) => string;
+        decodeS: (...args: any[]) => string | number;
+        decodeB: (...args: any[]) => string | number;
+        toMoney: (num: any, options: any) => string;
+    };
+}
+declare namespace langs {
+    export { cn_s as s };
+    export { cn_b as b };
+    export { hk_s };
+    export { hk_b };
+}
+import cn_s from './src/langs/cn_s';
+import cn_b from './src/langs/cn_b';
+import hk_s from './src/langs/hk_s';
+import hk_b from './src/langs/hk_b';

package/types/nzh/src/autoGet.d.ts

@@ -0,0 +1,8 @@
+export function getNzhObjByLang(lang_s: any, lang_b: any): {
+    encodeS: (num: any, options: any) => string;
+    encodeB: (num: any, options: any) => string;
+    decodeS: (...args: any[]) => string | number;
+    decodeB: (...args: any[]) => string | number;
+    toMoney: (num: any, options: any) => string;
+};
+export default getNzhObjByLang;

package/types/nzh/src/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 阿拉伯数字转中文数字
+ *
+ * @param {String} num 阿拉伯数字/字符串 , 科学记数法字符串
+ * @param {Object} opration 转换配置
+ *                          {
+ *                              ww: {万万化单位 | false}
+ *                              tenMin: {十的口语化 | false}
+ *                          }
+ * @returns String
+ */
+export function CL(num: string, options: any): string;
+/**
+ * 中文数字转阿拉伯数字
+ *
+ * @param {string} cnnumb 中文数字字符串
+ * @returns Number
+ */
+export function unCL(cnnumb: string, options: any): string | number;
+/**
+ * 阿拉伯数字转金额
+ *
+ * @param {String} num 阿拉伯数字/字符串 , 科学记数法字符串
+ * @param {Object} options 转换配置
+ *                         {
+ *                             ww:{万万化开关 | true},
+ *                             unOmitYuan: {整数为0时不省略元| false},
+ *                             complete:{完整金额格式 | false},
+ *                             outSymbol:{是否输出金额符号 | true}
+ *                             forceZheng:{以转换结果加“整” | false}
+ *                         }
+ * @returns String
+ */
+export function toMoney(num: string, options: Object): string;

package/types/nzh/src/langs/cn_b.d.ts

@@ -0,0 +1,10 @@
+export default cn_b;
+declare namespace cn_b {
+    let ch: string;
+    let ch_u: string;
+    let ch_f: string;
+    let ch_d: string;
+    let m_t: string;
+    let m_z: string;
+    let m_u: string;
+}

package/types/nzh/src/langs/cn_s.d.ts

@@ -0,0 +1,7 @@
+export default cn_s;
+declare namespace cn_s {
+    let ch: string;
+    let ch_u: string;
+    let ch_f: string;
+    let ch_d: string;
+}

package/types/nzh/src/langs/hk_b.d.ts

@@ -0,0 +1,10 @@
+export default hk_b;
+declare namespace hk_b {
+    let ch: string;
+    let ch_u: string;
+    let ch_f: string;
+    let ch_d: string;
+    let m_t: string;
+    let m_z: string;
+    let m_u: string;
+}

package/types/nzh/src/langs/hk_s.d.ts

@@ -0,0 +1,7 @@
+export default hk_s;
+declare namespace hk_s {
+    let ch: string;
+    let ch_u: string;
+    let ch_f: string;
+    let ch_d: string;
+}

package/types/nzh/src/utils.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 科学计数法转十进制
+ *
+ * @param {string} num 科学记数法字符串
+ * @returns string
+ */
+export function e2ten(num: string): string;
+/**
+ * 分析数字字符串
+ *
+ * @param {string} num NumberString
+ * @returns object
+ */
+export function getNumbResult(num: string): {
+    int: string;
+    decimal: string;
+    minus: boolean;
+    num: string;
+} | undefined;
+/**
+ * 数组归一 (按索引覆盖合并数组,并清空被合并的数组)
+ *
+ * @param {array} baseArray 基础数组
+ * @param {...array} array1
+ * @returns array
+ */
+export function centerArray(baseArray: array, ...args: array[]): array;
+/**
+ * 检查对像属性 (非原型链)
+ *
+ * @param {object} obj
+ * @param {string} key
+ * @returns
+ */
+export function hasAttr(obj: object, key: string): boolean;
+/**
+ * 扩展对像(浅复制)
+ *
+ * @param {object} obj
+ * @param {object} obj1
+ * @returns
+ */
+export function extend(obj: object, ...args: any[]): any;
+/**
+ * 获取真实数位
+ *
+ * @param {number} index 中文单位的索引
+ */
+export function getDigit(index: number): number;
+/**
+ * 往数组头部插入0
+ *
+ * @param {array} arr
+ * @param {number} n
+ */
+export function unshiftZero(arr: array, n: number): void;
+/**
+ * 清理多余"零"
+ *
+ * @param {any} str
+ * @param {any} zero "零"字符
+ * @param {any} type 清理模式 ^ - 开头, $ - 结尾, nto1 - 多个连续变一个
+ * @returns
+ */
+export function clearZero(str: any, zero: any, type: any): any;

package/types/object-keys-sort/index.d.ts

@@ -0,0 +1,4 @@
+export default objectKeysSort;
+declare function objectKeysSort(params: any): {
+    [k: string]: any;
+};

package/types/random/address.d.ts

@@ -0,0 +1,8 @@
+export default address;
+declare namespace address {
+    function region(): string | undefined;
+    function province(): string;
+    function city(prefix: any): string;
+    function county(prefix: any): string;
+    function zip(len: any): string;
+}

package/types/random/constellation.d.ts

@@ -0,0 +1,2 @@
+export default constellation;
+declare function constellation(): string | undefined;

package/types/random/image.d.ts

@@ -0,0 +1,5 @@
+export function generateImageDataURL(params?: {}): string;
+export default image;
+declare namespace image {
+    export { generateImageDataURL };
+}

package/types/random/index.d.ts

@@ -0,0 +1,40 @@
+declare namespace _default {
+    export { number };
+    export let natural: (min?: number, max?: number) => number;
+    export let integer: (min?: number, max?: number) => number;
+    export let float: (min: any, max: any) => number;
+    export function boolean(): boolean;
+    export function sex(): string;
+    export { sample as pick };
+    export { text };
+    export let ctitle: (min: any, max: any) => string;
+    export let cparagraph: (min: any, max: any) => string;
+    export let csentence: (min: any, max: any) => string;
+    export let cword: (pool: any, min: any, max: any, ...args: any[]) => string;
+    export { name };
+    export let cname: () => string;
+    export { web };
+    export let phone: () => string;
+    export { address };
+    export function county(p: any): string;
+    export function company(): string;
+    export function project(): string;
+    export { time };
+    export { constellation };
+    export { licensePlate };
+    export function uuid(): string;
+    export function id(): number;
+    export function increment(step: any): number;
+    export { image };
+}
+export default _default;
+import number from './number';
+import sample from 'lodash/sample';
+import text from './text';
+import name from './name';
+import web from './web';
+import address from './address';
+import time from './time';
+import constellation from './constellation';
+import licensePlate from './licensePlate';
+import image from './image';

package/types/random/licensePlate.d.ts

@@ -0,0 +1,2 @@
+export default licensePlate;
+declare function licensePlate(): string;

package/types/random/name.d.ts

@@ -0,0 +1,9 @@
+export default name;
+declare namespace name {
+    function first(): string | undefined;
+    function last(): string | undefined;
+    function name(middle: any): string;
+    function cfirst(): string | undefined;
+    function clast(): string | undefined;
+    function cname(): string;
+}

package/types/random/number.d.ts

@@ -0,0 +1,6 @@
+export default number;
+declare namespace number {
+    function natural(min?: number, max?: number): number;
+    function integer(min?: number, max?: number): number;
+    function float(min: any, max: any): number;
+}

package/types/random/text.d.ts

@@ -0,0 +1,13 @@
+export default text;
+declare namespace text {
+    function paragraph(min: any, max: any): string;
+    function cparagraph(min: any, max: any): string;
+    function sentence(min: any, max: any): string;
+    function csentence(min: any, max: any): string;
+    function word(min: any, max: any): string;
+    function cword(pool: any, min: any, max: any, ...args: any[]): string;
+    function title(min: any, max: any): string;
+    function ctitle(min: any, max: any): string;
+    function character(pool: any): any;
+    function string(pool: any, min: any, max: any, ...args: any[]): string;
+}

package/types/random/time.d.ts

@@ -0,0 +1,2 @@
+export default time;
+declare function time(a: any, b: any): string;

package/types/random/web.d.ts

@@ -0,0 +1,11 @@
+export default web;
+declare namespace web {
+    function url(v: any, host: any): string;
+    function protocol(): string | undefined;
+    function domain(v: any): string;
+    function tld(): string | undefined;
+    function email(domain: any): string;
+    function phone(): string;
+    function ip(): string;
+    function port(): number;
+}

package/types/screenfull/index.d.ts

@@ -0,0 +1,10 @@
+export default screenfull;
+declare namespace screenfull {
+    export function request(element: HTMLElement | undefined, options: any): Promise<any>;
+    export function exit(): Promise<any>;
+    export function toggle(element: any, options: any): any;
+    export function on(event: any, callback: any): void;
+    export function off(event: any, callback: any): void;
+    export { nativeAPI as raw };
+}
+declare const nativeAPI: {};

package/types/search-tree/index.d.ts

@@ -0,0 +1,20 @@
+type Primitive = string | number | boolean | symbol | null | undefined;
+type ConditionValue<T = unknown> = Primitive | ((value: T) => boolean) | RegExp;
+interface SearchOptions {
+    strategy?: 'BFS' | 'DFS';
+    childrenKey?: string;
+    strict?: boolean;
+}
+interface TreeNode {
+    [key: string]: unknown;
+    children?: TreeNode[];
+}
+/**
+ * 非递归树搜索算法
+ * @param {TreeNode[]} treeData - 树数据
+ * @param {Record<string, ConditionValue>} searchCondition - 搜索条件对象
+ * @param {SearchOptions} [options={}] - 配置选项
+ * @returns {TreeNode | null} 找到的节点或null
+ */
+declare function searchTree(treeData: TreeNode[], searchCondition: Record<string, ConditionValue>, options?: SearchOptions): TreeNode | null;
+export default searchTree;

package/types/snapdom/index.d.ts

@@ -0,0 +1 @@
+export * from "./src";

package/types/snapdom/src/api/preCache.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Preloads images, background images, and optionally fonts into cache before DOM capture.
+ *
+ * @param {Document|Element} [root=document] - The root node to search for resources
+ * @param {Object} [options={}] - Pre-caching options
+ * @returns {Promise<void>} Resolves when all resources are pre-cached
+ */
+export function preCache(root?: Document | Element, options?: Object): Promise<void>;

package/types/snapdom/src/api/snapdom.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Main entry point: captures a DOM element and returns an object with export methods.
+ *
+ * @param {Element} element - DOM element to capture
+ * @param {Object} [options={}] - Capture options
+ * @returns {Promise<Object>} Object with export methods (toRaw, toImg, toCanvas, etc.)
+ */
+export function snapdom(element: Element, options?: Object): Promise<Object>;
+export namespace snapdom {
+    /**
+     * Captures a DOM element and returns an object with export methods (internal use).
+     *
+     * @param {Element} el - DOM element to capture
+     * @param {Object} [options={}] - Capture options
+     * @returns {Promise<Object>} Object with export methods
+     */
+    function capture(el: Element, options?: Object): Promise<Object>;
+    function toRaw(el: any, options: any): Promise<any>;
+    function toImg(el: any, options: any): Promise<any>;
+    function toCanvas(el: any, options: any): Promise<any>;
+    function toBlob(el: any, options: any): Promise<any>;
+    function toPng(el: any, options: any): Promise<any>;
+    function toJpg(el: any, options: any): Promise<any>;
+    function toWebp(el: any, options: any): Promise<any>;
+    function download(el: any, options?: {}): Promise<any>;
+}

package/types/snapdom/src/core/cache.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Caches for images, backgrounds, resources, and computed styles used during DOM capture.
+ * @module cache
+ */
+export const imageCache: Map<any, any>;
+export const bgCache: Map<any, any>;
+export const resourceCache: Map<any, any>;
+export const defaultStylesCache: Map<any, any>;
+export const baseCSSCache: Map<any, any>;
+export const computedStyleCache: WeakMap<WeakKey, any>;
+export const processedFontURLs: Set<any>;

package/types/snapdom/src/core/capture.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Captures an HTML element as an SVG data URL, inlining styles, images, backgrounds, and optionally fonts.
+ *
+ * @param {Element} element - DOM element to capture
+ * @param {Object} [options={}] - Capture options
+ * @param {boolean} [options.compress=true] - Whether to compress style keys
+ * @param {boolean} [options.embedFonts=false] - Whether to embed custom fonts
+ * @param {boolean} [options.fast=true] - Whether to skip idle delay for faster results
+ * @param {number} [options.scale=1] - Output scale multiplier
+ * @returns {Promise<string>} Promise that resolves to an SVG data URL
+ */
+export function captureDOM(element: Element, options?: {
+    compress?: boolean | undefined;
+    embedFonts?: boolean | undefined;
+    fast?: boolean | undefined;
+    scale?: number | undefined;
+}): Promise<string>;

package/types/snapdom/src/core/clone.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Creates a deep clone of a DOM node, including styles, shadow DOM, and special handling for excluded/placeholder/canvas nodes.
+ *
+ * @param {Node} node - Node to clone
+ * @param {Map} styleMap - Map to store element-to-style-key mappings
+ * @param {WeakMap} styleCache - Cache of computed styles
+ * @param {WeakMap} nodeMap - Map to track original-to-clone node relationships
+ * @param {boolean} compress - Whether to compress style keys
+ * @returns {Node|null} Cloned node with styles and shadow DOM content, or null for empty text nodes
+ */
+export function deepClone(node: Node, styleMap: Map<any, any>, styleCache: WeakMap<any, any>, nodeMap: WeakMap<any, any>, compress: boolean): Node | null;

package/types/snapdom/src/core/prepare.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Prepares a clone of an element for capture, inlining pseudo-elements and generating CSS classes.
+ *
+ * @param {Element} element - Element to clone
+ * @param {boolean} [compress=false] - Whether to compress style keys
+ * @returns {Promise<Object>} Object containing the clone, generated CSS, and style cache
+ */
+export function prepareClone(element: Element, compress?: boolean, embedFonts?: boolean): Promise<Object>;

package/types/snapdom/src/index.browser.d.ts

@@ -0,0 +1 @@
+export {};

package/types/snapdom/src/index.d.ts

@@ -0,0 +1,2 @@
+export { preCache } from "./api/preCache.js";
+export { snapdom } from "./api/snapdom.js";

package/types/snapdom/src/modules/background.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Converts all background images in the cloned element tree to data URLs.
+ *
+ * @param {Element} source - Original element
+ * @param {Element} clone - Cloned element
+ * @param {WeakMap} styleCache - Cache of computed styles
+ * @param {Object} [options={}] - Options for image processing
+ * @returns {Promise<void>} Promise that resolves when all background images are processed
+ */
+export function inlineBackgroundImages(source: Element, clone: Element, styleCache: WeakMap<any, any>, options?: Object): Promise<void>;

package/types/snapdom/src/modules/fonts.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Converts a unicode character from an icon font into a data URL image.
+ *
+ * @export
+ * @param {string} unicodeChar - The unicode character to render
+ * @param {string} fontFamily - The font family name
+ * @param {string|number} fontWeight - The font weight
+ * @param {number} [fontSize=32] - The font size in pixels
+ * @param {string} [color="#000"] - The color to use
+ * @returns {Promise<string>} Data URL of the rendered icon
+ */
+export function iconToImage(unicodeChar: string, fontFamily: string, fontWeight: string | number, fontSize?: number, color?: string): Promise<string>;
+/**
+ * Embeds custom fonts found in the document as data URLs in CSS.
+ *
+ * @export
+ * @param {Object} options
+ * @param {boolean} [options.ignoreIconFonts=true] - Whether to skip icon fonts
+ * @param {boolean} [options.preCached=false] - Whether to use pre-cached resources
+ * @returns {Promise<string>} The inlined CSS for custom fonts
+ */
+export function embedCustomFonts({ ignoreIconFonts, preCached, }?: {
+    ignoreIconFonts?: boolean | undefined;
+    preCached?: boolean | undefined;
+}): Promise<string>;

package/types/snapdom/src/modules/images.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts all <img> elements in the clone to data URLs or replaces them with placeholders if loading fails.
+ *
+ * @param {Element} clone - Clone of the original element
+ * @param {Object} [options={}] - Options for image processing
+ * @returns {Promise<void>} Promise that resolves when all images are processed
+ */
+export function inlineImages(clone: Element, options?: Object): Promise<void>;

package/types/snapdom/src/modules/pseudo.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates elements to represent ::before, ::after, and ::first-letter pseudo-elements, inlining their styles and content.
+ *
+ * @param {Element} source - Original element
+ * @param {Element} clone - Cloned element
+ * @param {Map} styleMap - Map to store element-to-style-key mappings
+ * @param {WeakMap} styleCache - Cache of computed styles
+ * @param {boolean} compress - Whether to compress style keys
+ * @param {boolean} embedFonts - Whether to embed icon fonts as images
+ * @returns {Promise} Promise that resolves when all pseudo-elements are processed
+ */
+export function inlinePseudoElements(source: Element, clone: Element, styleMap: Map<any, any>, styleCache: WeakMap<any, any>, compress: boolean, embedFonts?: boolean): Promise<any>;

package/types/snapdom/src/modules/styles.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Records computed styles for an element to later generate CSS classes.
+ *
+ * @param {Element} source - Original element
+ * @param {Element} clone - Cloned element
+ * @param {Map} styleMap - Map to store element-to-style-key mappings
+ * @param {WeakMap} cache - Cache of computed styles
+ * @param {boolean} compress - Whether to compress style keys
+ */
+export function inlineAllStyles(source: Element, clone: Element, styleMap: Map<any, any>, cache: WeakMap<any, any>, compress: boolean): void;

package/types/snapdom/src/utils/cssTools.d.ts

@@ -0,0 +1,38 @@
+export function precacheCommonTags(): void;
+/**
+ * Retrieves default CSS property values from a temporary element.
+ *
+ * @param {string} tagName - The tag name to get default styles for
+ * @returns {Object} Object containing default values for all CSS properties
+ */
+export function getDefaultStyleForTag(tagName: string): Object;
+/**
+ * Creates a unique key from an element's computed style that differs from defaults.
+ *
+ * @param {Object} snapshot - Computed style snapshot
+ * @param {string} tagName - The tag name of the element
+ * @param {boolean} [compress=false] - Whether to compress style keys
+ * @returns {string} Semi-colon separated list of non-default properties
+ */
+export function getStyleKey(snapshot: Object, tagName: string, compress?: boolean): string;
+/**
+ * Collects all unique tag names used in the DOM tree rooted at the given node.
+ *
+ * @param {Node} root - The root node to search
+ * @returns {string[]} Array of unique tag names
+ */
+export function collectUsedTagNames(root: Node): string[];
+/**
+ * Generates deduplicated base CSS for the given tag names.
+ *
+ * @param {string[]} usedTagNames - Array of tag names
+ * @returns {string} CSS string
+ */
+export function generateDedupedBaseCSS(usedTagNames: string[]): string;
+/**
+ * Generates CSS classes from a style map.
+ *
+ * @param {Map} styleMap - Map of elements to style keys
+ * @returns {Map} Map of style keys to class names
+ */
+export function generateCSSClasses(styleMap: Map<any, any>): Map<any, any>;

package/types/snapdom/src/utils/helpers.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Fetches and inlines a single background-image entry to a data URL (with caching).
+ * - If entry is a gradient or "none", returns unchanged.
+ * - If entry is a url(...), fetches the image as data URL and caches it.
+ *
+ * @param {string} entry - Single background-image entry (e.g., "url(...)").
+ * @param {Object} [options={}] - Options like crossOrigin.
+ * @param {boolean} [options.skipInline=false] - If true, only fetches & caches, doesn't return a replacement.
+ * @returns {Promise<string|void>} - The processed entry (unless skipInline is true).
+ */
+export function inlineSingleBackgroundEntry(entry: string, options?: {
+    skipInline?: boolean | undefined;
+}): Promise<string | void>;
+/**
+ * Creates a promise that resolves after the specified delay
+ * @param {number} [ms=0] - Milliseconds to delay
+ * @returns {Promise<void>} Promise that resolves after the delay
+ */
+export function idle(fn: any, { fast }?: {
+    fast?: boolean | undefined;
+}): Promise<void>;
+/**
+ * Gets the computed style for an element or pseudo-element, with caching.
+ *
+ * @param {Element} el - The element
+ * @param {string|null} [pseudo=null] - The pseudo-element
+ * @returns {CSSStyleDeclaration} The computed style
+ */
+export function getStyle(el: Element, pseudo?: string | null): CSSStyleDeclaration;
+/**
+ * Parses the CSS content property value, handling unicode escapes.
+ *
+ * @param {string} content - The CSS content value
+ * @returns {string} The parsed content
+ */
+export function parseContent(content: string): string;
+/**
+ * Extracts a URL from a CSS value like background-image.
+ *
+ * @param {string} value - The CSS value
+ * @returns {string|null} The extracted URL or null
+ */
+export function extractURL(value: string): string | null;
+/**
+ * Determines if a font family or URL is an icon font.
+ *
+ * @param {string} familyOrUrl - The font family or URL
+ * @returns {boolean} True if it is an icon font
+ */
+export function isIconFont(familyOrUrl: string): boolean;
+/**
+ *
+ *
+ * @export
+ * @param {*} src
+ * @param {number} [timeout=3000]
+ * @return {*}
+ */
+export function fetchImage(src: any, timeout?: number, crossOrigin?: string): any;
+/**
+ *
+ *
+ * @export
+ * @param {*} style
+ * @return {*}
+ */
+export function snapshotComputedStyle(style: any): any;
+export function isSafari(): boolean;
+export function stripTranslate(transform: any): any;
+export function safeEncodeURI(uri: any): any;
+export function splitBackgroundImage(bg: any): any[];

package/types/tree/index.d.ts

@@ -0,0 +1,8 @@
+export function findNodeBy(root: any, key: any, value: any, childrenKey?: string): any;
+export function getItemBy(root: any, key: any, value: any, childrenKey?: string): any;
+export function getItemBy3(root: any, key: any, value: any, childrenKey?: string): any;
+export function getItemByID(root: any, value: any): any;
+export function getLabelFromDictionaryByValue(a: any, value: any, 保底?: boolean): any;
+export function getChildWithParentBy(root: any, key: any, value: any, childrenKey?: string): null | undefined;
+export function getItemBy2(root: any, key: any, value: any, childrenKey?: string): any;
+export default getItemBy;

package/types/turbo-stream/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/turbo-stream";

package/types/turbo-stream/src/decode.d.ts

@@ -0,0 +1,7 @@
+export type DecodePlugin = (type: string, ...data: unknown[]) => {
+    value: unknown;
+} | false | null | undefined;
+export type DecodeOptions = {
+    plugins?: DecodePlugin[];
+};
+export declare function decode<T>(stream: ReadableStream<string>, { plugins }?: DecodeOptions): Promise<T>;