@iqmo/browser/build/stlite.d.ts

Browser Stlite

import type { IHostConfigResponse } from '@streamlit/connection/src/types';

declare interface CanvasInterface {
    	setCanvas2D(canvas: HTMLCanvasElement): void;
    	getCanvas2D(): HTMLCanvasElement | undefined;
    	setCanvas3D(canvas: HTMLCanvasElement): void;
    	getCanvas3D(): HTMLCanvasElement | undefined;
}

declare interface CodeCompletion {
    name: string;
    type: string;
    docstring: string;
    complete: string;
}

declare type DetailedMountOptions = SimplifiedStliteKernelOptions & MakeToastKernelCallbacksOptions;

declare interface EmscriptenFile {
    data: string | ArrayBufferView;
    opts?: Record<string, string>;
}

declare interface EmscriptenFileUrl {
    url: string;
    opts?: Record<string, string>;
}

declare type FSNode = {
    	timestamp: number;
    	rdev: number;
    	contents: Uint8Array;
    	mode: number;
};

declare type FSStream = {
    	tty?: {
        		ops: object;
        	};
    	seekable?: boolean;
    	stream_ops: FSStreamOps;
    	node: FSNode;
};

declare type FSStreamOps = FSStreamOpsGen<FSStream>;

declare type FSStreamOpsGen<T> = {
    	open: (a: T) => void;
    	close: (a: T) => void;
    	fsync: (a: T) => void;
    	read: (a: T, b: Uint8Array, offset: number, length: number, pos: number) => number;
    	write: (a: T, b: Uint8Array, offset: number, length: number, pos: number) => number;
};

declare interface FSType {
    	unlink: (path: string) => void;
    	mkdirTree: (path: string, mode?: number) => void;
    	chdir: (path: string) => void;
    	symlink: (target: string, src: string) => FSNode;
    	createDevice: ((parent: string, name: string, input?: (() => number | null) | null, output?: ((code: number) => void) | null) => FSNode) & {
        		major: number;
        	};
    	closeStream: (fd: number) => void;
    	open: (path: string, flags: string | number, mode?: number) => FSStream;
    	makedev: (major: number, minor: number) => number;
    	mkdev: (path: string, dev: number) => FSNode;
    	filesystems: any;
    	stat: (path: string, dontFollow?: boolean) => any;
    	readdir: (path: string) => string[];
    	isDir: (mode: number) => boolean;
    	isMountpoint: (mode: FSNode) => boolean;
    	lookupPath: (path: string, options?: {
        		follow_mount?: boolean;
        	}) => {
        		node: FSNode;
        	};
    	isFile: (mode: number) => boolean;
    	writeFile: (path: string, contents: any, o?: {
        		canOwn?: boolean;
        	}) => void;
    	chmod: (path: string, mode: number) => void;
    	utime: (path: string, atime: number, mtime: number) => void;
    	rmdir: (path: string) => void;
    	mount: (type: any, opts: any, mountpoint: string) => any;
    	unmount: (mountpoint: string) => any;
    	write: (stream: FSStream, buffer: any, offset: number, length: number, position?: number) => number;
    	close: (stream: FSStream) => void;
    	ErrnoError: {
        		new (errno: number): Error;
        	};
    	registerDevice<T>(dev: number, ops: FSStreamOpsGen<T>): void;
    	syncfs(dir: boolean, oncomplete: (val: void) => void): void;
}

declare type InFuncType = () => null | undefined | string | ArrayBuffer | Uint8Array | number;

declare type LoadedPackages = Record<string, string>;

/**
 * The type of a package lockfile.
 */
declare interface Lockfile {
    	info: LockfileInfo;
    	packages: Record<string, LockfilePackage>;
}

/**
 * The lockfile platform info. The ``abi_version`` field is used to check if the
 * lockfile is compatible with the interpreter. The remaining fields are
 * informational.
 */
declare interface LockfileInfo {
    	/**
     	 * Machine architecture. At present, only can be wasm32. Pyodide has no wasm64
     	 * build.
     	 */
    	arch: "wasm32";
    	/**
     	 * The ABI version is structured as ``yyyy_patch``. For the lockfile to be
     	 * compatible with the current interpreter this field must match exactly with
     	 * the ABI version of the interpreter.
     	 */
    	abi_version: string;
    	/**
     	 * The Emscripten versions for instance, `emscripten_4_0_9`. Different
     	 * Emscripten versions have different ABIs so if this changes ``abi_version``
     	 * must also change.
     	 */
    	platform: string;
    	/**
     	 * The Pyodide version the lockfile was made with. Informational only, has no
     	 * compatibility implications. May be removed in the future.
     	 */
    	version: string;
    	/**
     	 * The Python version this lock file was made with. If the minor version
     	 * changes (e.g, 3.12 to 3.13) this changes the ABI and the ``abi_version``
     	 * must change too. Patch versions do not imply a change to the
     	 * ``abi_version``.
     	 */
    	python: string;
}

/**
 * A package entry in the lock file.
 */
declare interface LockfilePackage {
    	/**
     	 * The unnormalized name of the package.
     	 */
    	name: string;
    	version: string;
    	/**
     	 * The file name or url of the package wheel. If it's relative, it will be
     	 * resolved with respect to ``packageBaseUrl``. If there is no
     	 * ``packageBaseUrl``, attempting to install a package with a relative
     	 * ``file_name``  will fail.
     	 */
    	file_name: string;
    	package_type: PackageType;
    	/**
     	 * The installation directory. Will be ``site`` except for certain system
     	 * dynamic libraries that need to go on the global LD_LIBRARY_PATH.
     	 */
    	install_dir: "site" | "dynlib";
    	/**
     	 * Integrity. Must be present unless ``checkIntegrity: false`` is passed to
     	 * ``loadPyodide``.
     	 */
    	sha256: string;
    	/**
     	 * The set of imports provided by this package as best we can tell. Used by
     	 * :js:func:`pyodide.loadPackagesFromImports` to work out what packages to
     	 * install.
     	 */
    	imports: string[];
    	/**
     	 * The set of dependencies of this package.
     	 */
    	depends: string[];
}

declare interface MakeToastKernelCallbacksOptions {
    disableProgressToasts?: boolean;
    disableErrorToasts?: boolean;
}

declare interface MicropipInstallOptions {
    keep_going?: boolean;
    deps?: boolean;
    credentials?: string | null;
    pre?: boolean;
    index_urls?: string[] | string | null;
    constraints?: string[] | null;
    reinstall?: boolean;
    verbose?: boolean | number | null;
}

export declare function mount(options: MountOptions, container?: HTMLElement): {
    unmount: () => void;
    install: (requirements: string[], options?: MicropipInstallOptions) => Promise<unknown>;
    writeFile: (path: string, data: string | ArrayBufferView, opts?: Record<string, unknown>) => Promise<unknown>;
    renameFile: (oldPath: string, newPath: string) => Promise<unknown>;
    unlink: (path: string) => Promise<unknown>;
    readFile: (path: string, opts?: Record<string, unknown>) => Promise<unknown>;
    getCodeCompletion: (code: string, position: {
        line: number;
        column: number;
    }) => Promise<CodeCompletion[]>;
};

declare type MountOptions = string | DetailedMountOptions;

declare type NativeFS = {
    	syncfs: () => Promise<void>;
};

declare interface PackageData {
    	name: string;
    	version: string;
    	fileName: string;
    	/** @experimental */
    	packageType: PackageType;
}

declare type PackageType = "package" | "cpython_module" | "shared_library" | "static_library";

declare class PyAsyncGenerator extends PyProxy {
    	/** @private */
    	static [Symbol.hasInstance](obj: any): obj is PyProxy;
}

/** @deprecated Use `import type { PyAsyncGenerator } from "pyodide/ffi"` instead */
declare interface PyAsyncGenerator extends PyAsyncGeneratorMethods {
}

declare class PyAsyncGeneratorMethods {
    	/**
     	 * Throws an exception into the Generator.
     	 *
     	 * See the documentation for :js:meth:`AsyncGenerator.throw`.
     	 *
     	 * @param exc Error The error to throw into the generator. Must be an
     	 * instanceof ``Error``.
     	 * @returns An Object with two properties: ``done`` and ``value``. When the
     	 * generator yields ``some_value``, ``return`` returns ``{done : false, value
     	 * : some_value}``. When the generator raises a
     	 * ``StopIteration(result_value)`` exception, ``return`` returns ``{done :
     	 * true, value : result_value}``.
     	 */
    	throw(exc: any): Promise<IteratorResult<any, any>>;
    	/**
     	 * Throws a :py:exc:`GeneratorExit` into the generator and if the
     	 * :py:exc:`GeneratorExit` is not caught returns the argument value ``{done:
     	 * true, value: v}``. If the generator catches the :py:exc:`GeneratorExit` and
     	 * returns or yields another value the next value of the generator this is
     	 * returned in the normal way. If it throws some error other than
     	 * :py:exc:`GeneratorExit` or :py:exc:`StopAsyncIteration`, that error is
     	 * propagated. See the documentation for :js:meth:`AsyncGenerator.throw`
     	 *
     	 * @param v The value to return from the generator.
     	 * @returns An Object with two properties: ``done`` and ``value``. When the
     	 * generator yields ``some_value``, ``return`` returns ``{done : false, value
     	 * : some_value}``. When the generator raises a :py:exc:`StopAsyncIteration`
     	 * exception, ``return`` returns ``{done : true, value : result_value}``.
     	 */
    	return(v: any): Promise<IteratorResult<any, any>>;
}

declare class PyAsyncIterable extends PyProxy {
    	/** @private */
    	static [Symbol.hasInstance](obj: any): obj is PyProxy;
}

/** @deprecated Use `import type { PyAsyncIterable } from "pyodide/ffi"` instead */
declare interface PyAsyncIterable extends PyAsyncIterableMethods {
}

declare class PyAsyncIterableMethods {
    	/**
     	 * This translates to the Python code ``aiter(obj)``. Return an async iterator
     	 * associated to the proxy. See the documentation for :js:data:`Symbol.asyncIterator`.
     	 *
     	 * This will be used implicitly by ``for(await let x of proxy){}``.
     	 */
    	[Symbol.asyncIterator](): AsyncIterator<any, any, any>;
}

declare class PyAsyncIterator extends PyProxy {
    	/** @private */
    	static [Symbol.hasInstance](obj: any): obj is PyProxy;
}

/** @deprecated Use `import type { PyAsyncIterator } from "pyodide/ffi"` instead */
declare interface PyAsyncIterator extends PyAsyncIteratorMethods {
}

declare class PyAsyncIteratorMethods {
    	/** @private */
    	[Symbol.asyncIterator](): this;
    	/**
     	 * This translates to the Python code ``anext(obj)``. Returns the next value
     	 * of the asynchronous iterator. The argument will be sent to the Python
     	 * iterator (if it's a generator for instance).
     	 *
     	 * This will be used implicitly by ``for(let x of proxy){}``.
     	 *
     	 * @param arg The value to send to a generator. The value will be assigned as
     	 * a result of a yield expression.
     	 * @returns An Object with two properties: ``done`` and ``value``. When the
     	 * iterator yields ``some_value``, ``next`` returns ``{done : false, value :
     	 * some_value}``. When the giterator is done, ``next`` returns
     	 * ``{done : true }``.
     	 */
    	next(arg?: any): Promise<IteratorResult<any, any>>;
}

declare class PyAwaitable extends PyProxy {
    	/** @private */
    	static [Symbol.hasInstance](obj: any): obj is PyProxy;
}

/** @deprecated Use `import type { PyAwaitable } from "pyodide/ffi"` instead */
declare interface PyAwaitable extends Promise<any> {
}

declare class PyBuffer extends PyProxy {
    	/** @private */
    	static [Symbol.hasInstance](obj: any): obj is PyBuffer;
}

/** @deprecated Use `import type { PyBuffer } from "pyodide/ffi"` instead */
declare interface PyBuffer extends PyBufferMethods {
}

declare class PyBufferMethods {
    	/**
     	 * Get a view of the buffer data which is usable from JavaScript. No copy is
     	 * ever performed.
     	 *
     	 * We do not support suboffsets, if the buffer requires suboffsets we will
     	 * throw an error. JavaScript nd array libraries can't handle suboffsets
     	 * anyways. In this case, you should use the :js:meth:`~PyProxy.toJs` api or
     	 * copy the buffer to one that doesn't use suboffsets (using e.g.,
     	 * :py:func:`numpy.ascontiguousarray`).
     	 *
     	 * If the buffer stores big endian data or half floats, this function will
     	 * fail without an explicit type argument. For big endian data you can use
     	 * :js:meth:`~PyProxy.toJs`. :js:class:`DataView` has support for big endian
     	 * data, so you might want to pass ``'dataview'`` as the type argument in that
     	 * case.
     	 *
     	 * @param type The type of the :js:attr:`~pyodide.ffi.PyBufferView.data` field
     	 * in the output. Should be one of: ``"i8"``, ``"u8"``, ``"u8clamped"``,
     	 * ``"i16"``, ``"u16"``, ``"i32"``, ``"u32"``, ``"i32"``, ``"u32"``,
     	 * ``"i64"``, ``"u64"``, ``"f32"``, ``"f64"``, or ``"dataview"``. This argument
     	 * is optional, if absent :js:meth:`~pyodide.ffi.PyBuffer.getBuffer` will try
     	 * to determine the appropriate output type based on the buffer format string
     	 * (see :std:ref:`struct-format-strings`).
     	 */
    	getBuffer(type?: string): PyBufferView;
}

/** @deprecated Use `import type { PyBufferView } from "pyodide/ffi"` instead */
declare class PyBufferView {
    	/**
     	 * The offset of the first entry of the array. For instance if our array
     	 * is 3d, then you will find ``array[0,0,0]`` at
     	 * ``pybuf.data[pybuf.offset]``
     	 */
    	offset: number;
    	/**
     	 * If the data is read only, you should not modify it. There is no way for us
     	 * to enforce this, but it may cause very weird behavior. See
     	 * :py:attr:`memoryview.readonly`.
     	 */
    	readonly: boolean;
    	/**
     	 * The format string for the buffer. See :ref:`struct-format-strings`
     	 * and :py:attr:`memoryview.format`.
     	 */
    	format: string;
    	/**
     	 * How large is each entry in bytes? See :py:attr:`memoryview.itemsize`.
     	 */
    	itemsize: number;
    	/**
     	 * The number of dimensions of the buffer. If ``ndim`` is 0, the buffer
     	 * represents a single scalar or struct. Otherwise, it represents an
     	 * array. See :py:attr:`memoryview.ndim`.
     	 */
    	ndim: number;
    	/**
     	 * The total number of bytes the buffer takes up. This is equal to
     	 * :js:attr:`buff.data.byteLength <TypedArray.byteLength>`. See
     	 * :py:attr:`memoryview.nbytes`.
     	 */
    	nbytes: number;
    	/**
     	 * The shape of the buffer, that is how long it is in each dimension.
     	 * The length will be equal to ``ndim``. For instance, a 2x3x4 array
     	 * would have shape ``[2, 3, 4]``. See :py:attr:`memoryview.shape`.
     	 */
    	shape: number[];
    	/**
     	 * An array of of length ``ndim`` giving the number of elements to skip
     	 * to get to a new element in each dimension. See the example definition
     	 * of a ``multiIndexToIndex`` function above. See :py:attr:`memoryview.strides`.
     	 */
    	strides: number[];
    	/**
     	 * The actual data. A typed array of an appropriate size backed by a segment
     	 * of the WASM memory.
     	 *
     	 * The ``type`` argument of :js:meth:`~pyodide.ffi.PyBuffer.getBuffer` determines
     	 * which sort of :js:class:`TypedArray` or :js:class:`DataView` to return. By
     	 * default :js:meth:`~pyodide.ffi.PyBuffer.getBuffer` will look at the format string
     	 * to determine the most appropriate option. Most often the result is a
     	 * :js:class:`Uint8Array`.
     	 *
     	 * .. admonition:: Contiguity
     	 *    :class: warning
     	 *
     	 *    If the buffer is not contiguous, the :js:attr:`~PyBufferView.readonly`
     	 *    TypedArray will contain data that is not part of the buffer. Modifying
     	 *    this data leads to undefined behavior.
     	 *
     	 * .. admonition:: Read only buffers
     	 *    :class: warning
     	 *
     	 *    If :js:attr:`buffer.readonly <PyBufferView.readonly>` is ``true``, you
     	 *    should not modify the buffer. Modifying a read only buffer leads to
     	 *    undefined behavior.
     	 *
     	 */
    	data: TypedArray;
    	/**
     	 * Is it C contiguous? See :py:attr:`memoryview.c_contiguous`.
     	 */
    	c_contiguous: boolean;
    	/**
     	 * Is it Fortran contiguous? See :py:attr:`memoryview.f_contiguous`.
     	 */
    	f_contiguous: boolean;
    	/**
     	 * @private
     	 */
    	_released: boolean;
    	/**
     	 * @private
     	 */
    	_view_ptr: number;
    	/** @private */
    	constructor();
    	/**
     	 * Release the buffer. This allows the memory to be reclaimed.
     	 */
    	release(): void;
}

declare class PyCallable extends PyProxy {
    	/** @private */
    	static [Symbol.hasInstance](obj: any): obj is PyCallable;
}

/** @deprecated Use `import type { PyCallable } from "pyodide/ffi"` instead */
declare interface PyCallable extends PyCallableMethods {
    	(...args: any[]): any;
}

declare class PyCallableMethods {
    	/**
     	 * The ``apply()`` method calls the specified function with a given this
     	 * value, and arguments provided as an array (or an array-like object). Like
     	 * :js:meth:`Function.apply`.
     	 *
     	 * @param thisArg The ``this`` argument. Has no effect unless the
     	 * :js:class:`~pyodide.ffi.PyCallable` has :js:meth:`captureThis` set. If
     	 * :js:meth:`captureThis` is set, it will be passed as the first argument to
     	 * the Python function.
     	 * @param jsargs The array of arguments
     	 * @returns The result from the function call.
     	 */
    	apply(thisArg: any, jsargs: any): any;
    	/**
     	 * Calls the function with a given this value and arguments provided
     	 * individually. See :js:meth:`Function.call`.
     	 *
     	 * @param thisArg The ``this`` argument. Has no effect unless the
     	 * :js:class:`~pyodide.ffi.PyCallable` has :js:meth:`captureThis` set. If
     	 * :js:meth:`captureThis` is set, it will be passed as the first argument to
     	 * the Python function.
     	 * @param jsargs The arguments
     	 * @returns The result from the function call.
     	 */
    	call(thisArg: any, ...jsargs: any): any;
    	/**
     	 * Call the Python function. The first parameter controls various parameters
     	 * that change the way the call is performed.
     	 *
     	 * @param options
     	 * @param options.kwargs If true, the last argument is treated as a collection
     	 *                       of keyword arguments.
     	 * @param options.promising If true, the call is made with stack switching
     	 *                          enabled. Not needed if the callee is an async
     	 *                          Python function.
     	 * @param options.relaxed If true, extra arguments are ignored instead of
     	 *                        raising a :py:exc:`TypeError`.
     	 * @param jsargs Arguments to the Python function.
     	 * @returns
     	 */
    	callWithOptions({ relaxed, kwargs, promising, }: {
        		relaxed?: boolean;
        		kwargs?: boolean;
        		promising?: boolean;
        	}, ...jsargs: any): any;
    	/**
     	 * Call the function with keyword arguments. The last argument must be an
     	 * object with the keyword arguments.
     	 */
    	callKwargs(...jsargs: any): any;
    	/**
     	 * Call the function in a "relaxed" manner. Any extra arguments will be
     	 * ignored. This matches the behavior of JavaScript functions more accurately.
     	 *
     	 * Any extra arguments will be ignored. This matches the behavior of
     	 * JavaScript functions more accurately. Missing arguments are **NOT** filled
     	 * with `None`. If too few arguments are passed, this will still raise a
     	 * TypeError.
     	 *
     	 * This uses :py:func:`pyodide.code.relaxed_call`.
     	 */
    	callRelaxed(...jsargs: any): any;
    	/**
     	 * Call the function with keyword arguments in a "relaxed" manner. The last
     	 * argument must be an object with the keyword arguments. Any extra arguments
     	 * will be ignored. This matches the behavior of JavaScript functions more
     	 * accurately.
     	 *
     	 * Missing arguments are **NOT** filled with ``None``. If too few arguments are
     	 * passed, this will still raise a :py:exc:`TypeError`. Also, if the same argument is
     	 * passed as both a keyword argument and a positional argument, it will raise
     	 * an error.
     	 *
     	 * This uses :py:func:`pyodide.code.relaxed_call`.
     	 */
    	callKwargsRelaxed(...jsargs: any): any;
    	/**
     	 * Call the function with stack switching enabled. The last argument must be
     	 * an object with the keyword arguments. Functions called this way can use
     	 * :py:meth:`~pyodide.ffi.run_sync` to block until an
     	 * :py:class:`~collections.abc.Awaitable` is resolved. Only works in runtimes
     	 * with JS Promise integration.
     	 *
     	 * .. admonition:: Experimental
     	 *    :class: warning
     	 *
     	 *    This feature is not yet stable.
     	 *
     	 * @experimental
     	 */
    	callPromising(...jsargs: any): Promise<any>;
    	/**
     	 * Call the function with stack switching enabled. The last argument must be
     	 * an object with the keyword arguments. Functions called this way can use
     	 * :py:meth:`~pyodide.ffi.run_sync` to block until an
     	 * :py:class:`~collections.abc.Awaitable` is resolved. Only works in runtimes
     	 * with JS Promise integration.
     	 *
     	 * .. admonition:: Experimental
     	 *    :class: warning
     	 *
     	 *    This feature is not yet stable.
     	 *
     	 * @experimental
     	 */
    	callPromisingKwargs(...jsargs: any): Promise<any>;
    	/**
     	 * The ``bind()`` method creates a new function that, when called, has its
     	 * ``this`` keyword set to the provided value, with a given sequence of
     	 * arguments preceding any provided when the new function is called. See
     	 * :js:meth:`Function.bind`.
     	 *
     	 * If the :js:class:`~pyodide.ffi.PyCallable` does not have
     	 * :js:meth:`captureThis` set, the ``this`` parameter will be discarded. If it
     	 * does have :js:meth:`captureThis` set, ``thisArg`` will be set to the first
     	 * argument of the Python function. The returned proxy and the original proxy
     	 * have the same lifetime so destroying either destroys both.
     	 *
     	 * @param thisArg The value to be passed as the ``this`` parameter to the
     	 * target function ``func`` when the bound function is called.
     	 * @param jsargs Extra arguments to prepend to arguments provided to the bound
     	 * function when invoking ``func``.
     	 * @returns
     	 */
    	bind(thisArg: any, ...jsargs: any): PyProxy;
    	/**
     	 * Returns a :js:class:`~pyodide.ffi.PyProxy` that passes ``this`` as the first argument to the
     	 * Python function. The returned :js:class:`~pyodide.ffi.PyProxy` has the internal ``captureThis``
     	 * property set.
     	 *
     	 * It can then be used as a method on a JavaScript object. The returned proxy
     	 * and the original proxy have the same lifetime so destroying either destroys
     	 * both.
     	 *
     	 * For example:
     	 *
     	 * .. code-block:: pyodide
     	 *
     	 *    let obj = { a : 7 };
     	 *    pyodide.runPython(`
     	 *      def f(self):
     	 *        return self.a
     	 *    `);
     	 *    // Without captureThis, it doesn't work to use f as a method for obj:
     	 *    obj.f = pyodide.globals.get("f");
     	 *    obj.f(); // raises "TypeError: f() missing 1 required positional argument: 'self'"
     	 *    // With captureThis, it works fine:
     	 *    obj.f = pyodide.globals.get("f").captureThis();
     	 *    obj.f(); // returns 7
     	 *
     	 * @returns The resulting :js:class:`~pyodide.ffi.PyProxy`. It has the same lifetime as the
     	 * original :js:class:`~pyodide.ffi.PyProxy` but passes ``this`` to the wrapped function.
     	 *
     	 */
    	captureThis(): PyProxy;
}

declare class PyContainsMethods {
    	/**
     	 * This translates to the Python code ``key in obj``.
     	 *
     	 * @param key The key to check for.
     	 * @returns Is ``key`` present?
     	 */
    	has(key: any): boolean;
}

declare class PyDict extends PyProxy {
    	/** @private */
    	static [Symbol.hasInstance](obj: any): obj is PyProxy;
}

/** @deprecated Use `import type { PyDict } from "pyodide/ffi"` instead */
declare interface PyDict extends PyProxyWithGet, PyProxyWithSet, PyProxyWithHas, PyProxyWithLength, PyIterable {
}

declare class PyGenerator extends PyProxy {
    	/** @private */
    	static [Symbol.hasInstance](obj: any): obj is PyProxy;
}

/** @deprecated Use `import type { PyGenerator } from "pyodide/ffi"` instead */
declare interface PyGenerator extends PyGeneratorMethods {
}

declare class PyGeneratorMethods {
    	/**
     	 * Throws an exception into the Generator.
     	 *
     	 * See the documentation for :js:meth:`Generator.throw`.
     	 *
     	 * @param exc Error The error to throw into the generator. Must be an
     	 * instanceof ``Error``.
     	 * @returns An Object with two properties: ``done`` and ``value``. When the
     	 * generator yields ``some_value``, ``return`` returns ``{done : false, value
     	 * : some_value}``. When the generator raises a
     	 * ``StopIteration(result_value)`` exception, ``return`` returns ``{done :
     	 * true, value : result_value}``.
     	 */
    	throw(exc: any): IteratorResult<any, any>;
    	/**
     	 * Throws a :py:exc:`GeneratorExit` into the generator and if the
     	 * :py:exc:`GeneratorExit` is not caught returns the argument value ``{done:
     	 * true, value: v}``. If the generator catches the :py:exc:`GeneratorExit` and
     	 * returns or yields another value the next value of the generator this is
     	 * returned in the normal way. If it throws some error other than
     	 * :py:exc:`GeneratorExit` or :py:exc:`StopIteration`, that error is propagated. See
     	 * the documentation for :js:meth:`Generator.return`.
     	 *
     	 * @param v The value to return from the generator.
     	 * @returns An Object with two properties: ``done`` and ``value``. When the
     	 * generator yields ``some_value``, ``return`` returns ``{done : false, value
     	 * : some_value}``. When the generator raises a
     	 * ``StopIteration(result_value)`` exception, ``return`` returns ``{done :
     	 * true, value : result_value}``.
     	 */
    	return(v: any): IteratorResult<any, any>;
}

declare class PyGetItemMethods {
    	/**
     	 * This translates to the Python code ``obj[key]``.
     	 *
     	 * @param key The key to look up.
     	 * @returns The corresponding value.
     	 */
    	get(key: any): any;
    	/**
     	 * Returns the object treated as a json adaptor.
     	 *
     	 * With a JsonAdaptor:
     	 *  1. property access / modification / deletion is implemented with
     	 *     :meth:`~object.__getitem__`, :meth:`~object.__setitem__`, and
     	 *     :meth:`~object.__delitem__` respectively.
     	 *  2. If an attribute is accessed and the result implements
     	 *     :meth:`~object.__getitem__` then the result will also be a json
     	 *     adaptor.
     	 *
     	 * For instance, ``JSON.stringify(proxy.asJsJson())`` acts like an
     	 * inverse to Python's :py:func:`json.loads`.
     	 */
    	asJsJson(): PyProxy & {};
}

declare class PyIterable extends PyProxy {
    	/** @private */
    	static [Symbol.hasInstance](obj: any): obj is PyProxy;
}

/** @deprecated Use `import type { PyIterable } from "pyodide/ffi"` instead */
declare interface PyIterable extends PyIterableMethods {
}

declare class PyIterableMethods {
    	/**
     	 * This translates to the Python code ``iter(obj)``. Return an iterator
     	 * associated to the proxy. See the documentation for
     	 * :js:data:`Symbol.iterator`.
     	 *
     	 * This will be used implicitly by ``for(let x of proxy){}``.
     	 */
    	[Symbol.iterator](): Iterator<any, any, any>;
}

declare class PyIterator extends PyProxy {
    	/** @private */
    	static [Symbol.hasInstance](obj: any): obj is PyProxy;
}

/** @deprecated Use `import type { PyIterator } from "pyodide/ffi"` instead */
declare interface PyIterator extends PyIteratorMethods {
}

declare class PyIteratorMethods {
    	/** @private */
    	[Symbol.iterator](): this;
    	/**
     	 * This translates to the Python code ``next(obj)``. Returns the next value of
     	 * the generator. See the documentation for :js:meth:`Generator.next` The
     	 * argument will be sent to the Python generator.
     	 *
     	 * This will be used implicitly by ``for(let x of proxy){}``.
     	 *
     	 * @param arg The value to send to the generator. The value will be assigned
     	 * as a result of a yield expression.
     	 * @returns An Object with two properties: ``done`` and ``value``. When the
     	 * generator yields ``some_value``, ``next`` returns ``{done : false, value :
     	 * some_value}``. When the generator raises a :py:exc:`StopIteration`
     	 * exception, ``next`` returns ``{done : true, value : result_value}``.
     	 */
    	next(arg?: any): IteratorResult<any, any>;
}

declare class PyLengthMethods {
    	/**
     	 * The length of the object.
     	 */
    	get length(): number;
}

declare class PyMutableSequence extends PyProxy {
    	/** @private */
    	static [Symbol.hasInstance](obj: any): obj is PyProxy;
}

/** @deprecated Use `import type { PyMutableSequence } from "pyodide/ffi"` instead */
declare interface PyMutableSequence extends PyMutableSequenceMethods {
}

declare class PyMutableSequenceMethods {
    	/**
     	 * The :js:meth:`Array.reverse` method reverses a :js:class:`PyMutableSequence` in
     	 * place.
     	 * @returns A reference to the same :js:class:`PyMutableSequence`
     	 */
    	reverse(): PyMutableSequence;
    	/**
     	 * The :js:meth:`Array.sort` method sorts the elements of a
     	 * :js:class:`PyMutableSequence` in place.
     	 * @param compareFn A function that defines the sort order.
     	 * @returns A reference to the same :js:class:`PyMutableSequence`
     	 */
    	sort(compareFn?: (a: any, b: any) => number): PyMutableSequence;
    	/**
     	 * The :js:meth:`Array.splice` method changes the contents of a
     	 * :js:class:`PyMutableSequence` by removing or replacing existing elements and/or
     	 * adding new elements in place.
     	 * @param start Zero-based index at which to start changing the
     	 * :js:class:`PyMutableSequence`.
     	 * @param deleteCount An integer indicating the number of elements in the
     	 * :js:class:`PyMutableSequence` to remove from ``start``.
     	 * @param items The elements to add to the :js:class:`PyMutableSequence`, beginning from
     	 * ``start``.
     	 * @returns An array containing the deleted elements.
     	 */
    	splice(start: number, deleteCount?: number, ...items: any[]): any[];
    	/**
     	 * The :js:meth:`Array.push` method adds the specified elements to the end of
     	 * a :js:class:`PyMutableSequence`.
     	 * @param elts The element(s) to add to the end of the :js:class:`PyMutableSequence`.
     	 * @returns The new length property of the object upon which the method was
     	 * called.
     	 */
    	push(...elts: any[]): any;
    	/**
     	 * The :js:meth:`Array.pop` method removes the last element from a
     	 * :js:class:`PyMutableSequence`.
     	 * @returns The removed element from the :js:class:`PyMutableSequence`; undefined if the
     	 * :js:class:`PyMutableSequence` is empty.
     	 */
    	pop(): any;
    	/**
     	 * The :js:meth:`Array.shift` method removes the first element from a
     	 * :js:class:`PyMutableSequence`.
     	 * @returns The removed element from the :js:class:`PyMutableSequence`; undefined if the
     	 * :js:class:`PyMutableSequence` is empty.
     	 */
    	shift(): any;
    	/**
     	 * The :js:meth:`Array.unshift` method adds the specified elements to the
     	 * beginning of a :js:class:`PyMutableSequence`.
     	 * @param elts The elements to add to the front of the :js:class:`PyMutableSequence`.
     	 * @returns The new length of the :js:class:`PyMutableSequence`.
     	 */
    	unshift(...elts: any[]): any;
    	/**
     	 * The :js:meth:`Array.copyWithin` method shallow copies part of a
     	 * :js:class:`PyMutableSequence` to another location in the same :js:class:`PyMutableSequence`
     	 * without modifying its length.
     	 * @param target Zero-based index at which to copy the sequence to.
     	 * @param start Zero-based index at which to start copying elements from.
     	 * @param end Zero-based index at which to end copying elements from.
     	 * @returns The modified :js:class:`PyMutableSequence`.
     	 */
    	copyWithin(target: number, start?: number, end?: number): any;
    	/**
     	 * The :js:meth:`Array.fill` method changes all elements in an array to a
     	 * static value, from a start index to an end index.
     	 * @param value Value to fill the array with.
     	 * @param start Zero-based index at which to start filling. Default 0.
     	 * @param end Zero-based index at which to end filling. Default
     	 * ``list.length``.
     	 * @returns
     	 */
    	fill(value: any, start?: number, end?: number): any;
}

/**
 * The return type of :js:func:`~exports.loadPyodide`. See
 * :ref:`the pyodide api docs <js-api-pyodide>` for more information.
 * @hidetype
 * @docgroup exports
 */
declare type PyodideAPI = typeof PyodideAPI_;

declare class PyodideAPI_ {
    	/** @hidden */
    	static version: string;
    	/** @hidden */
    	static loadPackage: (names: string | PyProxy | Array<string>, options?: {
        		messageCallback?: (message: string) => void;
        		errorCallback?: (message: string) => void;
        		checkIntegrity?: boolean;
        	}) => Promise<PackageData[]>;
    	/** @hidden */
    	static loadedPackages: LoadedPackages;
    	/** @hidden */
    	static ffi: {
        		PyProxy: typeof PyProxy;
        		PyProxyWithLength: typeof PyProxyWithLength;
        		PyProxyWithGet: typeof PyProxyWithGet;
        		PyProxyWithSet: typeof PyProxyWithSet;
        		PyProxyWithHas: typeof PyProxyWithHas;
        		PyDict: typeof PyDict;
        		PyIterable: typeof PyIterable;
        		PyAsyncIterable: typeof PyAsyncIterable;
        		PyIterator: typeof PyIterator;
        		PyAsyncIterator: typeof PyAsyncIterator;
        		PyGenerator: typeof PyGenerator;
        		PyAsyncGenerator: typeof PyAsyncGenerator;
        		PyAwaitable: typeof PyAwaitable;
        		PyCallable: typeof PyCallable;
        		PyBuffer: typeof PyBuffer;
        		PyBufferView: typeof PyBufferView;
        		PythonError: typeof PythonError;
        		PySequence: typeof PySequence;
        		PyMutableSequence: typeof PyMutableSequence;
        	};
    	/** @hidden */
    	static setStdin: typeof setStdin;
    	/** @hidden */
    	static setStdout: typeof setStdout;
    	/** @hidden */
    	static setStderr: typeof setStderr;
    	/**
     	 *
     	 * An alias to the global Python namespace.
     	 *
     	 * For example, to access a variable called ``foo`` in the Python global
     	 * scope, use ``pyodide.globals.get("foo")``
     	 */
    	static globals: PyProxy;
    	/**
     	 * An alias to the `Emscripten File System API
     	 * <https://emscripten.org/docs/api_reference/Filesystem-API.html>`_.
     	 *
     	 * This provides a wide range of POSIX-`like` file/device operations, including
     	 * `mount
     	 * <https://emscripten.org/docs/api_reference/Filesystem-API.html#FS.mount>`_
     	 * which can be used to extend the in-memory filesystem with features like `persistence
     	 * <https://emscripten.org/docs/api_reference/Filesystem-API.html#persistent-data>`_.
     	 *
     	 * While all the file systems implementations are enabled, only the default
     	 * ``MEMFS`` is guaranteed to work in all runtime settings. The implementations
     	 * are available as members of ``FS.filesystems``:
     	 * ``IDBFS``, ``NODEFS``, ``PROXYFS``, ``WORKERFS``.
     	 */
    	static FS: FSType;
    	/**
     	 * An alias to the `Emscripten Path API
     	 * <https://github.com/emscripten-core/emscripten/blob/main/src/library_path.js>`_.
     	 *
     	 * This provides a variety of operations for working with file system paths, such as
     	 * ``dirname``, ``normalize``, and ``splitPath``.
     	 */
    	static PATH: any;
    	/**
     	 * APIs to set a canvas for rendering graphics.
     	 * @summaryLink :ref:`canvas <js-api-pyodide-canvas>`
     	 * @omitFromAutoModule
     	 */
    	static canvas: CanvasInterface;
    	/**
     	 * A map from posix error names to error codes.
     	 */
    	static ERRNO_CODES: {
        		[code: string]: number;
        	};
    	/**
     	 * An alias to the Python :ref:`pyodide <python-api>` package.
     	 *
     	 * You can use this to call functions defined in the Pyodide Python package
     	 * from JavaScript.
     	 */
    	static pyodide_py: PyProxy;
    	/**
     	 * Inspect a Python code chunk and use :js:func:`pyodide.loadPackage` to install
     	 * any known packages that the code chunk imports. Uses the Python API
     	 * :func:`pyodide.code.find\_imports` to inspect the code.
     	 *
     	 * For example, given the following code as input
     	 *
     	 * .. code-block:: python
     	 *
     	 *    import numpy as np
     	 *    x = np.array([1, 2, 3])
     	 *
     	 * :js:func:`loadPackagesFromImports` will call
     	 * ``pyodide.loadPackage(['numpy'])``.
     	 *
     	 * @param code The code to inspect.
     	 * @param options Options passed to :js:func:`pyodide.loadPackage`.
     	 * @param options.messageCallback A callback, called with progress messages
     	 *    (optional)
     	 * @param options.errorCallback A callback, called with error/warning messages
     	 *    (optional)
     	 * @param options.checkIntegrity If true, check the integrity of the downloaded
     	 *    packages (default: true)
     	 */
    	static loadPackagesFromImports(code: string, options?: {
        		messageCallback?: (message: string) => void;
        		errorCallback?: (message: string) => void;
        		checkIntegrity?: boolean;
        	}): Promise<Array<PackageData>>;
    	/**
     	 * Runs a string of Python code from JavaScript, using :py:func:`~pyodide.code.eval_code`
     	 * to evaluate the code. If the last statement in the Python code is an
     	 * expression (and the code doesn't end with a semicolon), the value of the
     	 * expression is returned.
     	 *
     	 * @param code The Python code to run
     	 * @param options
     	 * @param options.globals An optional Python dictionary to use as the globals.
     	 *        Defaults to :js:attr:`pyodide.globals`.
     	 * @param options.locals An optional Python dictionary to use as the locals.
     	 *        Defaults to the same as ``globals``.
     	 * @param options.filename An optional string to use as the file name.
     	 *        Defaults to ``"<exec>"``. If a custom file name is given, the
     	 *        traceback for any exception that is thrown will show source lines
     	 *        (unless the given file name starts with ``<`` and ends with ``>``).
     	 * @returns The result of the Python code translated to JavaScript. See the
     	 *          documentation for :py:func:`~pyodide.code.eval_code` for more info.
     	 * @example
     	 * async function main(){
     	 *   const pyodide = await loadPyodide();
     	 *   console.log(pyodide.runPython("1 + 2"));
     	 *   // 3
     	 *
     	 *   const globals = pyodide.toPy({ x: 3 });
     	 *   console.log(pyodide.runPython("x + 1", { globals }));
     	 *   // 4
     	 *
     	 *   const locals = pyodide.toPy({ arr: [1, 2, 3] });
     	 *   console.log(pyodide.runPython("sum(arr)", { locals }));
     	 *   // 6
     	 * }
     	 * main();
     	 */
    	static runPython(code: string, options?: {
        		globals?: PyProxy;
        		locals?: PyProxy;
        		filename?: string;
        	}): any;
    	/**
     	 * Run a Python code string with top level await using
     	 * :py:func:`~pyodide.code.eval_code_async` to evaluate the code. Returns a promise which
     	 * resolves when execution completes. If the last statement in the Python code
     	 * is an expression (and the code doesn't end with a semicolon), the returned
     	 * promise will resolve to the value of this expression.
     	 *
     	 * For example:
     	 *
     	 * .. code-block:: pyodide
     	 *
     	 *    let result = await pyodide.runPythonAsync(`
     	 *        from js import fetch
     	 *        response = await fetch("./pyodide-lock.json")
     	 *        packages = await response.json()
     	 *        # If final statement is an expression, its value is returned to JavaScript
     	 *        len(packages.packages.object_keys())
     	 *    `);
     	 *    console.log(result); // 79
     	 *
     	 * .. admonition:: Python imports
     	 *    :class: warning
     	 *
     	 *    Since pyodide 0.18.0, you must call :js:func:`loadPackagesFromImports` to
     	 *    import any python packages referenced via ``import`` statements in your
     	 *    code. This function will no longer do it for you.
     	 *
     	 * @param code The Python code to run
     	 * @param options
     	 * @param options.globals An optional Python dictionary to use as the globals.
     	 * Defaults to :js:attr:`pyodide.globals`.
     	 * @param options.locals An optional Python dictionary to use as the locals.
     	 *        Defaults to the same as ``globals``.
     	 * @param options.filename An optional string to use as the file name.
     	 *        Defaults to ``"<exec>"``. If a custom file name is given, the
     	 *        traceback for any exception that is thrown will show source lines
     	 *        (unless the given file name starts with ``<`` and ends with ``>``).
     	 * @returns The result of the Python code translated to JavaScript.
     	 */
    	static runPythonAsync(code: string, options?: {
        		globals?: PyProxy;
        		locals?: PyProxy;
        		filename?: string;
        	}): Promise<any>;
    	/**
     	 * Registers the JavaScript object ``module`` as a JavaScript module named
     	 * ``name``. This module can then be imported from Python using the standard
     	 * Python import system. If another module by the same name has already been
     	 * imported, this won't have much effect unless you also delete the imported
     	 * module from :py:data:`sys.modules`. This calls
     	 * :func:`~pyodide.ffi.register_js_module`.
     	 *
     	 * Any attributes of the JavaScript objects which are themselves objects will
     	 * be treated as submodules:
     	 * ```pyodide
     	 * pyodide.registerJsModule("mymodule", { submodule: { value: 7 } });
     	 * pyodide.runPython(`
     	 *     from mymodule.submodule import value
     	 *     assert value == 7
     	 * `);
     	 * ```
     	 * If you wish to prevent this, try the following instead:
     	 * ```pyodide
     	 * const sys = pyodide.pyimport("sys");
     	 * sys.modules.set("mymodule", { obj: { value: 7 } });
     	 * pyodide.runPython(`
     	 *     from mymodule import obj
     	 *     assert obj.value == 7
     	 *     # attempting to treat obj as a submodule raises ModuleNotFoundError:
     	 *     # "No module named 'mymodule.obj'; 'mymodule' is not a package"
     	 *     from mymodule.obj import value
     	 * `);
     	 * ```
     	 *
     	 * @param name Name of the JavaScript module to add
     	 * @param module JavaScript object backing the module
     	 */
    	static registerJsModule(name: string, module: object): void;
    	/**
     	 * Unregisters a JavaScript module with given name that has been previously
     	 * registered with :js:func:`pyodide.registerJsModule` or
     	 * :func:`~pyodide.ffi.register_js_module`. If a JavaScript module with that
     	 * name does not already exist, will throw an error. Note that if the module has
     	 * already been imported, this won't have much effect unless you also delete the
     	 * imported module from :py:data:`sys.modules`. This calls
     	 * :func:`~pyodide.ffi.unregister_js_module`.
     	 *
     	 * @param name Name of the JavaScript module to remove
     	 */
    	static unregisterJsModule(name: string): void;
    	/**
     	 * Convert a JavaScript object to a Python object as best as possible.
     	 *
     	 * This is similar to :py:meth:`~pyodide.ffi.JsProxy.to_py` but for use from
     	 * JavaScript. If the object is immutable or a :js:class:`~pyodide.ffi.PyProxy`,
     	 * it will be returned unchanged. If the object cannot be converted into Python,
     	 * it will be returned unchanged.
     	 *
     	 * See :ref:`type-translations-jsproxy-to-py` for more information.
     	 *
     	 * @param obj The object to convert.
     	 * @param options
     	 * @returns The object converted to Python.
     	 */
    	static toPy(obj: any, { depth, defaultConverter, }?: {
        		/**
         		 *  Optional argument to limit the depth of the conversion.
         		 */
        		depth: number;
        		/**
         		 * Optional argument to convert objects with no default conversion. See the
         		 * documentation of :py:meth:`~pyodide.ffi.JsProxy.to_py`.
         		 */
        		defaultConverter?: (value: any, converter: (value: any) => any, cacheConversion: (input: any, output: any) => void) => any;
        	}): any;
    	/**
     	 * Imports a module and returns it.
     	 *
     	 * If `name` has no dot in it, then `pyimport(name)` is approximately
     	 * equivalent to:
     	 * ```js
     	 * pyodide.runPython(`import ${name}; ${name}`)
     	 * ```
     	 * except that `name` is not introduced into the Python global namespace. If
     	 * the name has one or more dots in it, say it is of the form `path.name`
     	 * where `name` has no dots but path may have zero or more dots. Then it is
     	 * approximately the same as:
     	 * ```js
     	 * pyodide.runPython(`from ${path} import ${name}; ${name}`);
     	 * ```
     	 *
     	 * @param mod_name The name of the module to import
     	 *
     	 * @example
     	 * pyodide.pyimport("math.comb")(4, 2) // returns 4 choose 2 = 6
     	 */
    	static pyimport(mod_name: string): any;
    	/**
     	 * Unpack an archive into a target directory.
     	 *
     	 * @param buffer The archive as an :js:class:`ArrayBuffer` or :js:class:`TypedArray`.
     	 * @param format The format of the archive. Should be one of the formats
     	 * recognized by :py:func:`shutil.unpack_archive`. By default the options are
     	 * ``'bztar'``, ``'gztar'``, ``'tar'``, ``'zip'``, and ``'wheel'``. Several
     	 * synonyms are accepted for each format, e.g., for ``'gztar'`` any of
     	 * ``'.gztar'``, ``'.tar.gz'``, ``'.tgz'``, ``'tar.gz'`` or ``'tgz'`` are
     	 * considered to be
     	 * synonyms.
     	 *
     	 * @param options
     	 * @param options.extractDir The directory to unpack the archive into. Defaults
     	 * to the working directory.
     	 */
    	static unpackArchive(buffer: TypedArray | ArrayBuffer, format: string, options?: {
        		extractDir?: string;
        	}): void;
    	/**
     	 * Mounts a :js:class:`FileSystemDirectoryHandle` into the target directory.
     	 * Currently it's only possible to acquire a
     	 * :js:class:`FileSystemDirectoryHandle` in Chrome.
     	 *
     	 * @param path The absolute path in the Emscripten file system to mount the
     	 * native directory. If the directory does not exist, it will be created. If
     	 * it does exist, it must be empty.
     	 * @param fileSystemHandle A handle returned by
     	 * :js:func:`navigator.storage.getDirectory() <getDirectory>` or
     	 * :js:func:`window.showDirectoryPicker() <showDirectoryPicker>`.
     	 */
    	static mountNativeFS(path: string, fileSystemHandle: FileSystemDirectoryHandle): Promise<NativeFS>;
    	/**
     	 * Mounts a host directory into Pyodide file system. Only works in node.
     	 *
     	 * @param emscriptenPath The absolute path in the Emscripten file system to
     	 * mount the native directory. If the directory does not exist, it will be
     	 * created. If it does exist, it must be empty.
     	 * @param hostPath The host path to mount. It must be a directory that exists.
     	 */
    	static mountNodeFS(emscriptenPath: string, hostPath: string): void;
    	/**
     	 * Tell Pyodide about Comlink.
     	 * Necessary to enable importing Comlink proxies into Python.
     	 */
    	static registerComlink(Comlink: any): void;
    	/**
     	 * Sets the interrupt buffer to be ``interrupt_buffer``. This is only useful