pythonlib 1.0.2 → 2.0.1

package/dist/set-JQbLAq8B.d.ts

@@ -0,0 +1,592 @@
+/**
+ * Core Python operations for TypeScript
+ * Arithmetic operations with Python semantics, slicing, etc.
+ */
+/**
+ * Floor division (Python //)
+ * Always rounds towards negative infinity, unlike Math.floor for negatives
+ */
+declare function floorDiv(a: number, b: number): number;
+/**
+ * Power operator (Python **)
+ */
+declare function pow(base: number, exp: number): number;
+/**
+ * Modulo (Python %)
+ * Python's % always returns a result with the same sign as the divisor
+ */
+declare function mod(a: number, b: number): number;
+/**
+ * Python divMod()
+ */
+declare function divMod(a: number, b: number): [number, number];
+/**
+ * Python %-style string formatting
+ * Handles %s, %d, %i, %f, %r, %x, %o, etc.
+ */
+declare function sprintf(template: string, args: unknown): string;
+/**
+ * Python str.format() style string formatting
+ * Handles {} positional and {name} named placeholders
+ */
+declare function strFormat(template: string, ...args: unknown[]): string;
+/**
+ * Python-style slice operation
+ * Supports negative indices and step
+ */
+declare function slice<T>(obj: string | T[], start?: number, stop?: number, step?: number): string | T[];
+/**
+ * Python-style index access with support for negative indices
+ */
+declare function at<T>(obj: string | T[], index: number): T | string;
+/**
+ * Python-style string/array repetition
+ */
+declare function repeat<T>(obj: string | T[], count: number): string | T[];
+/**
+ * Python 'in' operator
+ */
+declare function contains<T>(item: T, container: Iterable<T> | string | Map<T, unknown> | Set<T>): boolean;
+/**
+ * Python 'is' operator (identity comparison)
+ */
+declare function is(a: unknown, b: unknown): boolean;
+
+/**
+ * Python built-in functions for TypeScript
+ *
+ * Provides core Python built-in functions like len, range, enumerate, sorted, min, max, etc.
+ *
+ * @see {@link https://docs.python.org/3/library/functions.html | Python built-in functions documentation}
+ */
+/**
+ * Return a sequence of numbers from start to stop (exclusive) by step.
+ *
+ * @param startOrStop - If only one argument, this is stop (start defaults to 0). Otherwise, this is start.
+ * @param stop - The end value (exclusive)
+ * @param step - The increment (default: 1)
+ * @returns An iterable of numbers
+ * @see {@link https://docs.python.org/3/library/functions.html#func-range | Python range()}
+ */
+declare function range(startOrStop: number, stop?: number, step?: number): Iterable<number>;
+/**
+ * Return an iterable of tuples containing (index, value) pairs.
+ *
+ * @param iterable - The sequence to enumerate
+ * @param start - The starting index (default: 0)
+ * @returns An iterable of [index, value] tuples
+ * @see {@link https://docs.python.org/3/library/functions.html#enumerate | Python enumerate()}
+ */
+declare function enumerate<T>(iterable: Iterable<T>, start?: number): Iterable<[number, T]>;
+/**
+ * Iterate over multiple iterables in parallel, yielding tuples.
+ *
+ * Stops when the shortest iterable is exhausted.
+ *
+ * @param iterables - The iterables to zip together
+ * @returns An iterable of tuples containing elements from each input
+ * @see {@link https://docs.python.org/3/library/functions.html#zip | Python zip()}
+ */
+declare function zip<T extends unknown[][]>(...iterables: {
+    [K in keyof T]: Iterable<T[K]>;
+}): Iterable<T>;
+/**
+ * Return an iterator object for the given iterable.
+ *
+ * For objects without Symbol.iterator, returns the object's keys.
+ *
+ * @param obj - The object to iterate over
+ * @returns An iterable
+ * @see {@link https://docs.python.org/3/library/functions.html#iter | Python iter()}
+ */
+declare function iter<T>(obj: Iterable<T> | Record<string, unknown> | null | undefined): Iterable<T> | string[];
+/**
+ * Return a reversed iterator over the values of the given sequence.
+ *
+ * Uses ES2023 Array.prototype.toReversed() for immutable reversal.
+ *
+ * @param iterable - The sequence to reverse
+ * @returns An iterable yielding elements in reverse order
+ * @see {@link https://docs.python.org/3/library/functions.html#reversed | Python reversed()}
+ */
+declare function reversed<T>(iterable: Iterable<T>): Iterable<T>;
+/**
+ * Return a new sorted list from the items in the iterable.
+ *
+ * Uses ES2023 Array.prototype.toSorted() for immutable sorting.
+ *
+ * @param iterable - The sequence to sort
+ * @param options - Sorting options: key function and/or reverse flag
+ * @returns A new sorted array
+ * @see {@link https://docs.python.org/3/library/functions.html#sorted | Python sorted()}
+ */
+declare function sorted<T>(iterable: Iterable<T>, options?: {
+    key?: (x: T) => unknown;
+    reverse?: boolean;
+}): T[];
+/**
+ * Apply a function to every item of the iterable and yield the results.
+ *
+ * Uses ES2024 Iterator.prototype.map() for lazy evaluation.
+ *
+ * @param fn - The function to apply to each element
+ * @param iterable - The input iterable
+ * @returns An iterable of transformed values
+ * @see {@link https://docs.python.org/3/library/functions.html#map | Python map()}
+ */
+declare function map<T, U>(fn: (x: T) => U, iterable: Iterable<T>): Iterable<U>;
+/**
+ * Return an iterable yielding items where the function returns true.
+ *
+ * If function is null, return items that are truthy.
+ * Uses ES2024 Iterator.prototype.filter() for lazy evaluation.
+ *
+ * @param fn - The predicate function (or null for truthiness check)
+ * @param iterable - The input iterable
+ * @returns An iterable of filtered values
+ * @see {@link https://docs.python.org/3/library/functions.html#filter | Python filter()}
+ */
+declare function filter<T>(fn: ((x: T) => boolean) | null, iterable: Iterable<T>): Iterable<T>;
+/**
+ * Create an immutable tuple (frozen array).
+ *
+ * @param items - The elements to include in the tuple
+ * @returns A frozen (readonly) array
+ * @see {@link https://docs.python.org/3/library/functions.html#func-tuple | Python tuple()}
+ */
+declare function tuple<T extends unknown[]>(...items: T): Readonly<T>;
+/**
+ * Return the number of items in an object.
+ *
+ * Works with strings, arrays, Maps, Sets, and objects with a length property.
+ *
+ * @param obj - The object to measure
+ * @returns The number of items
+ * @see {@link https://docs.python.org/3/library/functions.html#len | Python len()}
+ */
+declare function len(obj: string | unknown[] | Map<unknown, unknown> | Set<unknown> | {
+    length: number;
+}): number;
+/**
+ * Return the absolute value of a number.
+ *
+ * @param x - The number
+ * @returns The absolute value
+ * @see {@link https://docs.python.org/3/library/functions.html#abs | Python abs()}
+ */
+declare function abs(x: number): number;
+/**
+ * Return the smallest item in an iterable or the smallest of two or more arguments.
+ *
+ * @param args - An iterable, or multiple values to compare
+ * @returns The minimum value
+ * @see {@link https://docs.python.org/3/library/functions.html#min | Python min()}
+ */
+declare function min<T>(...args: T[] | [Iterable<T>]): T;
+/**
+ * Return the largest item in an iterable or the largest of two or more arguments.
+ *
+ * @param args - An iterable, or multiple values to compare
+ * @returns The maximum value
+ * @see {@link https://docs.python.org/3/library/functions.html#max | Python max()}
+ */
+declare function max<T>(...args: T[] | [Iterable<T>]): T;
+/**
+ * Return the sum of all items in the iterable plus an optional start value.
+ *
+ * @param iterable - The numbers to sum
+ * @param start - The initial value (default: 0)
+ * @returns The sum
+ * @see {@link https://docs.python.org/3/library/functions.html#sum | Python sum()}
+ */
+declare function sum(iterable: Iterable<number>, start?: number): number;
+/**
+ * Return True if all elements of the iterable are truthy (or if empty).
+ *
+ * @param iterable - The elements to test
+ * @returns True if all elements are truthy
+ * @see {@link https://docs.python.org/3/library/functions.html#all | Python all()}
+ */
+declare function all(iterable: Iterable<unknown>): boolean;
+/**
+ * Return True if any element of the iterable is truthy.
+ *
+ * @param iterable - The elements to test
+ * @returns True if any element is truthy
+ * @see {@link https://docs.python.org/3/library/functions.html#any | Python any()}
+ */
+declare function any(iterable: Iterable<unknown>): boolean;
+/**
+ * Round a number to a given precision in decimal digits.
+ *
+ * Uses banker's rounding (round half to even) for values exactly halfway.
+ *
+ * @param number - The number to round
+ * @param ndigits - Number of decimal places (default: 0)
+ * @returns The rounded number
+ * @see {@link https://docs.python.org/3/library/functions.html#round | Python round()}
+ */
+declare function round(number: number, ndigits?: number): number;
+/**
+ * Return the Unicode code point for a one-character string.
+ *
+ * @param char - A single character
+ * @returns The Unicode code point
+ * @see {@link https://docs.python.org/3/library/functions.html#ord | Python ord()}
+ */
+declare function ord(char: string): number;
+/**
+ * Return the string representing a character at the given Unicode code point.
+ *
+ * @param code - The Unicode code point
+ * @returns A single-character string
+ * @see {@link https://docs.python.org/3/library/functions.html#chr | Python chr()}
+ */
+declare function chr(code: number): string;
+/**
+ * Convert an integer to a lowercase hexadecimal string prefixed with "0x".
+ *
+ * @param x - The integer to convert
+ * @returns Hexadecimal string (e.g., "0xff")
+ * @see {@link https://docs.python.org/3/library/functions.html#hex | Python hex()}
+ */
+declare function hex(x: number): string;
+/**
+ * Convert an integer to an octal string prefixed with "0o".
+ *
+ * @param x - The integer to convert
+ * @returns Octal string (e.g., "0o17")
+ * @see {@link https://docs.python.org/3/library/functions.html#oct | Python oct()}
+ */
+declare function oct(x: number): string;
+/**
+ * Convert an integer to a binary string prefixed with "0b".
+ *
+ * @param x - The integer to convert
+ * @returns Binary string (e.g., "0b1010")
+ * @see {@link https://docs.python.org/3/library/functions.html#bin | Python bin()}
+ */
+declare function bin(x: number): string;
+/**
+ * Convert a value to an integer.
+ *
+ * Truncates floats toward zero. Parses strings in the given base.
+ *
+ * @param x - The value to convert
+ * @param base - The base for string conversion (default: 10)
+ * @returns The integer value
+ * @see {@link https://docs.python.org/3/library/functions.html#int | Python int()}
+ */
+declare function int(x: string | number | boolean, base?: number): number;
+/**
+ * Convert a value to a floating-point number.
+ *
+ * @param x - The value to convert
+ * @returns The float value
+ * @see {@link https://docs.python.org/3/library/functions.html#float | Python float()}
+ */
+declare function float(x: string | number): number;
+/**
+ * Convert a value to its string representation.
+ *
+ * Uses Python-style formatting for booleans (True/False), None, and collections.
+ *
+ * @param x - The value to convert
+ * @returns The string representation
+ * @see {@link https://docs.python.org/3/library/functions.html#func-str | Python str()}
+ */
+declare function str(x: unknown): string;
+/**
+ * Return a string containing a printable representation of an object.
+ *
+ * Strings are quoted, other types use str() representation.
+ *
+ * @param x - The value to represent
+ * @returns A printable representation
+ * @see {@link https://docs.python.org/3/library/functions.html#repr | Python repr()}
+ */
+declare function repr(x: unknown): string;
+/**
+ * Convert a value to a boolean using Python's truthiness rules.
+ *
+ * False values: null, undefined, false, 0, empty strings, empty arrays, empty Maps/Sets.
+ *
+ * @param x - The value to convert
+ * @returns The boolean value
+ * @see {@link https://docs.python.org/3/library/functions.html#bool | Python bool()}
+ */
+declare function bool(x: unknown): boolean;
+/**
+ * Return a string containing a printable ASCII representation.
+ *
+ * Non-ASCII characters are escaped using \\xhh, \\uhhhh, or \\Uhhhhhhhh.
+ *
+ * @param x - The value to represent
+ * @returns ASCII-safe printable representation
+ * @see {@link https://docs.python.org/3/library/functions.html#ascii | Python ascii()}
+ */
+declare function ascii(x: unknown): string;
+/**
+ * Return True if the object is an instance of the specified class.
+ *
+ * Supports JavaScript constructors (Number, String, etc.) and Python type names.
+ *
+ * @param obj - The object to check
+ * @param classInfo - The class or type name to check against
+ * @returns True if obj is an instance of classInfo
+ * @see {@link https://docs.python.org/3/library/functions.html#isinstance | Python isinstance()}
+ */
+declare function isinstance(obj: unknown, classInfo: unknown): boolean;
+/**
+ * Return the type name of an object as a string.
+ *
+ * Returns Python-style type names: 'int', 'float', 'str', 'bool', 'list', 'dict', 'set'.
+ *
+ * @param obj - The object to check
+ * @returns The type name
+ * @see {@link https://docs.python.org/3/library/functions.html#type | Python type()}
+ */
+declare function type(obj: unknown): string;
+/**
+ * Read a line of input from the user.
+ *
+ * Note: This function requires async implementation in JavaScript environments.
+ *
+ * @param prompt - Optional prompt string to display
+ * @returns The input string
+ * @see {@link https://docs.python.org/3/library/functions.html#input | Python input()}
+ */
+declare function input(prompt?: string): string;
+/**
+ * Convert a value to a formatted representation using a format specification.
+ *
+ * Supports Python format spec mini-language for numbers and strings.
+ *
+ * @param value - The value to format
+ * @param spec - The format specification string
+ * @returns The formatted string
+ * @see {@link https://docs.python.org/3/library/functions.html#format | Python format()}
+ */
+declare function format(value: unknown, spec: string): string;
+/**
+ * Python getattr() function - get an attribute from an object
+ *
+ * @param obj - The object to get the attribute from
+ * @param name - The name of the attribute
+ * @param defaultValue - Optional default value if attribute doesn't exist
+ * @returns The attribute value or default value
+ */
+declare function getattr<T>(obj: unknown, name: string, defaultValue?: T): T | undefined;
+/**
+ * Python hasattr() function - check if an object has an attribute
+ *
+ * @param obj - The object to check
+ * @param name - The name of the attribute
+ * @returns True if the attribute exists, false otherwise
+ */
+declare function hasattr(obj: unknown, name: string): boolean;
+/**
+ * Python setattr() function - set an attribute on an object
+ *
+ * @param obj - The object to set the attribute on
+ * @param name - The name of the attribute
+ * @param value - The value to set
+ */
+declare function setattr(obj: unknown, name: string, value: unknown): void;
+
+/**
+ * Python list methods for TypeScript
+ * Usage: py.list.remove(), py.list.sort(), etc.
+ */
+declare const list: {
+    /**
+     * Python list.append() - modifies array in place
+     */
+    append<T>(arr: T[], item: T): void;
+    /**
+     * Python list.extend() - modifies array in place
+     */
+    extend<T>(arr: T[], items: Iterable<T>): void;
+    /**
+     * Python list.insert() - modifies array in place
+     */
+    insert<T>(arr: T[], index: number, item: T): void;
+    /**
+     * Python list.remove() - removes first occurrence, modifies in place
+     */
+    remove<T>(arr: T[], value: T): void;
+    /**
+     * Python list.pop() - removes and returns item at index
+     */
+    pop<T>(arr: T[], index?: number): T;
+    /**
+     * Python list.clear() - removes all items
+     */
+    clear(arr: unknown[]): void;
+    /**
+     * Python list.index() - finds first occurrence
+     */
+    index<T>(arr: T[], value: T, start?: number, end?: number): number;
+    /**
+     * Python list.count() - counts occurrences
+     */
+    count<T>(arr: T[], value: T): number;
+    /**
+     * Python list.sort() with key function - modifies in place
+     */
+    sort<T>(arr: T[], options?: {
+        key?: (x: T) => unknown;
+        reverse?: boolean;
+    }): void;
+    /**
+     * Python list.reverse() - reverses in place
+     */
+    reverse(arr: unknown[]): void;
+    /**
+     * Python list.copy() - shallow copy
+     */
+    copy<T>(arr: T[]): T[];
+    /**
+     * Python slice assignment: arr[start:end:step] = values
+     * Replaces a slice of the array with new values, modifying in place
+     */
+    sliceAssign<T>(arr: T[], start: number | undefined, end: number | undefined, step: number | undefined, values: T[]): void;
+};
+
+/**
+ * Python dict methods for TypeScript
+ * Usage: py.dict.get(), py.dict.keys(), etc.
+ */
+declare const dict: {
+    /**
+     * Python dict.get() - get value with optional default
+     */
+    get<K extends string | number | symbol, V>(obj: Record<K, V>, key: K, defaultValue?: V): V | undefined;
+    /**
+     * Python dict.setDefault() - get value or set default
+     */
+    setDefault<K extends string | number | symbol, V>(obj: Record<K, V>, key: K, defaultValue: V): V;
+    /**
+     * Python dict.pop() - remove and return value
+     */
+    pop<K extends string | number | symbol, V>(obj: Record<K, V>, key: K, defaultValue?: V): V | undefined;
+    /**
+     * Python dict.popItem() - remove and return last item
+     */
+    popItem<K extends string | number | symbol, V>(obj: Record<K, V>): [K, V];
+    /**
+     * Python dict.update() - update with another dict
+     */
+    update<K extends string | number | symbol, V>(obj: Record<K, V>, other: Record<K, V> | Iterable<[K, V]>): void;
+    /**
+     * Python dict.clear() - remove all items
+     */
+    clear<K extends string | number | symbol, V>(obj: Record<K, V>): void;
+    /**
+     * Python dict.copy() - shallow copy
+     */
+    copy<K extends string | number | symbol, V>(obj: Record<K, V>): Record<K, V>;
+    /**
+     * Python dict.keys() - returns iterable of keys
+     */
+    keys<K extends string | number | symbol, V>(obj: Record<K, V>): K[];
+    /**
+     * Python dict.values() - returns iterable of values
+     */
+    values<K extends string | number | symbol, V>(obj: Record<K, V>): V[];
+    /**
+     * Python dict.items() - returns iterable of [key, value] pairs
+     */
+    items<K extends string | number | symbol, V>(obj: Record<K, V>): [K, V][];
+    /**
+     * Python dict.fromKeys() - create dict from keys
+     */
+    fromKeys<K extends string | number | symbol, V>(keys: K[], value?: V): Record<K, V | undefined>;
+};
+
+/**
+ * Python set methods for TypeScript
+ * Usage: py.set.intersection(), py.set.union(), etc.
+ *
+ * Uses ES2024 native Set methods where available for optimal performance.
+ */
+declare const set: {
+    /**
+     * Python set.add() - add element
+     */
+    add<T>(s: Set<T>, item: T): void;
+    /**
+     * Python set.remove() - remove element, raises error if not found
+     */
+    remove<T>(s: Set<T>, item: T): void;
+    /**
+     * Python set.discard() - remove element if present
+     */
+    discard<T>(s: Set<T>, item: T): void;
+    /**
+     * Python set.pop() - remove and return arbitrary element
+     */
+    pop<T>(s: Set<T>): T;
+    /**
+     * Python set.clear() - remove all elements
+     */
+    clear<T>(s: Set<T>): void;
+    /**
+     * Python set.copy() - shallow copy
+     */
+    copy<T>(s: Set<T>): Set<T>;
+    /**
+     * Python set.update() - add elements from iterable
+     */
+    update<T>(s: Set<T>, ...iterables: Iterable<T>[]): void;
+    /**
+     * Python set.union() - returns new set with all elements
+     * Uses ES2024 Set.prototype.union()
+     */
+    union<T>(a: Set<T>, ...others: Iterable<T>[]): Set<T>;
+    /**
+     * Python set.intersection() - returns new set with common elements
+     * Uses ES2024 Set.prototype.intersection()
+     */
+    intersection<T>(a: Set<T>, b: Set<T>): Set<T>;
+    /**
+     * Python set.intersection_update() - keep only common elements
+     */
+    intersectionUpdate<T>(a: Set<T>, b: Set<T>): void;
+    /**
+     * Python set.difference() - returns new set with elements in a but not in b
+     * Uses ES2024 Set.prototype.difference()
+     */
+    difference<T>(a: Set<T>, b: Set<T>): Set<T>;
+    /**
+     * Python set.difference_update() - remove elements found in b
+     */
+    differenceUpdate<T>(a: Set<T>, b: Set<T>): void;
+    /**
+     * Python set.symmetric_difference() - returns new set with elements in either but not both
+     * Uses ES2024 Set.prototype.symmetricDifference()
+     */
+    symmetricDifference<T>(a: Set<T>, b: Set<T>): Set<T>;
+    /**
+     * Python set.symmetric_difference_update() - update with symmetric difference
+     * Uses ES2024 Set.prototype.symmetricDifference()
+     */
+    symmetricDifferenceUpdate<T>(a: Set<T>, b: Set<T>): void;
+    /**
+     * Python set.isSubset() - test if all elements are in other
+     * Uses ES2024 Set.prototype.isSubsetOf()
+     */
+    isSubset<T>(a: Set<T>, b: Set<T>): boolean;
+    /**
+     * Python set.isSuperset() - test if all other elements are in this set
+     * Uses ES2024 Set.prototype.isSupersetOf()
+     */
+    isSuperset<T>(a: Set<T>, b: Set<T>): boolean;
+    /**
+     * Python set.isDisjoint() - test if no common elements
+     * Uses ES2024 Set.prototype.isDisjointFrom()
+     */
+    isDisjoint<T>(a: Set<T>, b: Set<T>): boolean;
+};
+
+export { all as A, any as B, round as C, ord as D, chr as E, hex as F, oct as G, bin as H, int as I, float as J, str as K, repr as L, bool as M, ascii as N, isinstance as O, type as P, input as Q, format as R, getattr as S, hasattr as T, setattr as U, repeat as V, pow as W, divMod as a, sprintf as b, strFormat as c, dict as d, slice as e, floorDiv as f, at as g, contains as h, is as i, enumerate as j, iter as k, list as l, mod as m, reversed as n, sorted as o, map as p, filter as q, range as r, set as s, tuple as t, len as u, abs as v, min as w, max as x, sum as y, zip as z };

package/dist/shutil.browser-Ck5oWhnP.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Python shutil module for TypeScript - Browser version
+ *
+ * Browser stub - file operations are not available.
+ *
+ * @see {@link https://docs.python.org/3/library/shutil.html | Python shutil documentation}
+ * @module
+ */
+/**
+ * Copy file from src to dst.
+ * Browser stub - throws error.
+ */
+declare function copy(_src: string, _dst: string): Promise<string>;
+/**
+ * Copy file with metadata from src to dst.
+ * Browser stub - throws error.
+ */
+declare function copy2(_src: string, _dst: string): Promise<string>;
+/**
+ * Copy an entire directory tree.
+ * Browser stub - throws error.
+ */
+declare function copytree(_src: string, _dst: string, _options?: {
+    symlinks?: boolean;
+    ignore?: (dir: string, files: string[]) => string[];
+    copyFunction?: (src: string, dst: string) => Promise<string>;
+    dirsExist_ok?: boolean;
+}): Promise<string>;
+/**
+ * Move a file or directory.
+ * Browser stub - throws error.
+ */
+declare function move(_src: string, _dst: string): Promise<string>;
+/**
+ * Remove a directory tree.
+ * Browser stub - throws error.
+ */
+declare function rmtree(_path: string, _ignoreErrors?: boolean): Promise<void>;
+/**
+ * Find an executable in PATH.
+ * Browser stub - returns null.
+ */
+declare function which(_cmd: string, _mode?: number, _path?: string): Promise<string | null>;
+/**
+ * Return disk usage statistics.
+ * Browser stub - throws error.
+ */
+declare function diskUsage(_path: string): Promise<{
+    total: number;
+    used: number;
+    free: number;
+}>;
+/**
+ * Copy file permission bits.
+ * Browser stub - no-op.
+ */
+declare function copyMode(_src: string, _dst: string): Promise<void>;
+/**
+ * Copy file stat info.
+ * Browser stub - no-op.
+ */
+declare function copyStat(_src: string, _dst: string): Promise<void>;
+/**
+ * Copy file without metadata.
+ * Browser stub - throws error.
+ */
+declare function copyFile(_src: string, _dst: string): Promise<string>;
+/**
+ * Copy file object.
+ * Browser stub - throws error.
+ */
+declare function copyFileObj(_fsrc: {
+    read: (size: number) => Promise<Uint8Array | null>;
+}, _fdst: {
+    write: (data: Uint8Array) => Promise<number>;
+}, _length?: number): Promise<void>;
+/**
+ * Get terminal size.
+ */
+declare function getTerminalSize(fallback?: [number, number]): {
+    columns: number;
+    lines: number;
+};
+/**
+ * Make an archive file.
+ * Browser stub - throws error.
+ */
+declare function makeArchive(_baseName: string, _format: string, _rootDir: string): string;
+/**
+ * Unpack an archive file.
+ * Browser stub - throws error.
+ */
+declare function unpackArchive(_filename: string, _extractDir?: string): void;
+
+declare const shutilModule_copy: typeof copy;
+declare const shutilModule_copy2: typeof copy2;
+declare const shutilModule_copyFile: typeof copyFile;
+declare const shutilModule_copyFileObj: typeof copyFileObj;
+declare const shutilModule_copyMode: typeof copyMode;
+declare const shutilModule_copyStat: typeof copyStat;
+declare const shutilModule_copytree: typeof copytree;
+declare const shutilModule_diskUsage: typeof diskUsage;
+declare const shutilModule_getTerminalSize: typeof getTerminalSize;
+declare const shutilModule_makeArchive: typeof makeArchive;
+declare const shutilModule_move: typeof move;
+declare const shutilModule_rmtree: typeof rmtree;
+declare const shutilModule_unpackArchive: typeof unpackArchive;
+declare const shutilModule_which: typeof which;
+declare namespace shutilModule {
+  export { shutilModule_copy as copy, shutilModule_copy2 as copy2, shutilModule_copyFile as copyFile, shutilModule_copyFileObj as copyFileObj, shutilModule_copyMode as copyMode, shutilModule_copyStat as copyStat, shutilModule_copytree as copytree, shutilModule_diskUsage as diskUsage, shutilModule_getTerminalSize as getTerminalSize, shutilModule_makeArchive as makeArchive, shutilModule_move as move, shutilModule_rmtree as rmtree, shutilModule_unpackArchive as unpackArchive, shutilModule_which as which };
+}
+
+export { copy2 as a, copytree as b, copy as c, diskUsage as d, copyMode as e, copyStat as f, copyFile as g, copyFileObj as h, getTerminalSize as i, makeArchive as j, move as m, rmtree as r, shutilModule as s, unpackArchive as u, which as w };