pyodide 0.23.0-alpha.1 → 0.23.0

package/pyodide.d.ts

@@ -4,11 +4,17 @@
  *
  * The Pyodide version.
  *
- * The version here follows PEP440 which is different from the one in package.json,
- * as we want to compare this with the version of Pyodide Python package without conversion.
+ * The version here is a Python version, following :pep:`440`. This is different
+ * from the version in ``package.json`` which follows the node package manager
+ * version convention.
  */
 export declare const version: string;
-declare function isPyProxy(jsobj: any): jsobj is PyProxy;
+interface CanvasInterface {
+	setCanvas2D(canvas: HTMLCanvasElement): void;
+	getCanvas2D(): HTMLCanvasElement | undefined;
+	setCanvas3D(canvas: HTMLCanvasElement): void;
+	getCanvas3D(): HTMLCanvasElement | undefined;
+}
 declare type PyProxyCache = {
 	cacheId: number;
 	refcnt: number;
@@ -18,7 +24,7 @@ declare type PyProxyProps = {
 	/**
 	 * captureThis tracks whether this should be passed as the first argument to
 	 * the Python function or not. We keep it false by default. To make a PyProxy
-	 * where the `this` argument is included, call the `captureThis` method.
+	 * where the ``this`` argument is included, call the :js:meth:`captureThis` method.
 	 */
 	captureThis: boolean;
 	/**
@@ -26,7 +32,7 @@ declare type PyProxyProps = {
 	 */
 	isBound: boolean;
 	/**
-	 * the `this` value that has been bound to the PyProxy
+	 * the ``this`` value that has been bound to the PyProxy
 	 */
 	boundThis?: any;
 	/**
@@ -36,25 +42,31 @@ declare type PyProxyProps = {
 	boundArgs: any[];
 	roundtrip: boolean;
 };
-export declare type PyProxy = PyProxyClass & {
+/** @deprecated Use `import type { PyProxy } from "pyodide/ffi"` instead */
+interface PyProxy {
 	[x: string]: any;
-};
-declare class PyProxyClass {
+}
+/**
+ * A :js:class:`~pyodide.ffi.PyProxy` is an object that allows idiomatic use of a Python object from
+ * JavaScript. See :ref:`type-translations-pyproxy`.
+ */
+declare class PyProxy {
+	/** @private */
 	$$: {
 		ptr: number;
 		cache: PyProxyCache;
 		destroyed_msg?: string;
 	};
+	/** @private */
 	$$props: PyProxyProps;
+	/** @private */
 	$$flags: number;
 	/**
 	 * @private
 	 * @hideconstructor
 	 */
 	constructor();
-	/**
-	 * @private
-	 */
+	/** @private */
 	get [Symbol.toStringTag](): string;
 	/**
 	 * The name of the type of the object.
@@ -74,11 +86,11 @@ declare class PyProxyClass {
 	get type(): string;
 	toString(): string;
 	/**
-	 * Destroy the ``PyProxy``. This will release the memory. Any further attempt
+	 * Destroy the :js:class:`~pyodide.ffi.PyProxy`. This will release the memory. Any further attempt
 	 * to use the object will raise an error.
 	 *
 	 * In a browser supporting :js:data:`FinalizationRegistry`, Pyodide will
-	 * automatically destroy the ``PyProxy`` when it is garbage collected, however
+	 * automatically destroy the :js:class:`~pyodide.ffi.PyProxy` when it is garbage collected, however
 	 * there is no guarantee that the finalizer will be run in a timely manner so
 	 * it is better to destroy the proxy explicitly.
 	 *
@@ -92,12 +104,12 @@ declare class PyProxyClass {
 		destroyRoundtrip?: boolean;
 	}): void;
 	/**
-	 * Make a new PyProxy pointing to the same Python object.
-	 * Useful if the PyProxy is destroyed somewhere else.
+	 * Make a new :js:class:`~pyodide.ffi.PyProxy` pointing to the same Python object.
+	 * Useful if the :js:class:`~pyodide.ffi.PyProxy` is destroyed somewhere else.
 	 */
 	copy(): PyProxy;
 	/**
-	 * Converts the ``PyProxy`` into a JavaScript object as best as possible. By
+	 * Converts the :js:class:`~pyodide.ffi.PyProxy` into a JavaScript object as best as possible. By
 	 * default does a deep conversion, if a shallow conversion is desired, you can
 	 * use ``proxy.toJs({depth : 1})``. See :ref:`Explicit Conversion of PyProxy
 	 * <type-translations-pyproxy-to-js>` for more info.
@@ -108,16 +120,18 @@ declare class PyProxyClass {
 		/** How many layers deep to perform the conversion. Defaults to infinite */
 		depth?: number;
 		/**
-		 * If provided, ``toJs`` will store all PyProxies created in this list. This
-		 * allows you to easily destroy all the PyProxies by iterating the list
-		 * without having to recurse over the generated structure. The most common
-		 * use case is to create a new empty list, pass the list as `pyproxies`, and
-		 * then later iterate over `pyproxies` to destroy all of created proxies.
+		 * If provided, :js:meth:`toJs` will store all PyProxies created in this
+		 * list. This allows you to easily destroy all the PyProxies by iterating
+		 * the list without having to recurse over the generated structure. The most
+		 * common use case is to create a new empty list, pass the list as
+		 * ``pyproxies``, and then later iterate over ``pyproxies`` to destroy all of
+		 * created proxies.
 		 */
 		pyproxies?: PyProxy[];
 		/**
-		 * If false, ``toJs`` will throw a :py:exc:`~pyodide.ffi.ConversionError` rather than
-		 * producing a ``PyProxy``.
+		 * If false, :js:meth:`toJs` will throw a
+		 * :py:exc:`~pyodide.ffi.ConversionError` rather than producing a
+		 * :js:class:`~pyodide.ffi.PyProxy`.
 		 */
 		create_pyproxies?: boolean;
 		/**
@@ -139,81 +153,105 @@ declare class PyProxyClass {
 		default_converter?: (obj: PyProxy, convert: (obj: PyProxy) => any, cacheConversion: (obj: PyProxy, result: any) => void) => any;
 	}): any;
 	/**
-	 * Check whether the :any:`PyProxy.length` getter is available on this PyProxy. A
-	 * Typescript type guard.
+	 * Check whether the :js:class:`~pyodide.ffi.PyProxy` is a :js:class:`~pyodide.ffi.PyProxyWithLength`.
+	 * @deprecated Use ``obj instanceof pyodide.ffi.PyProxyWithLength`` instead.
 	 */
 	supportsLength(): this is PyProxyWithLength;
 	/**
-	 * Check whether the :any:`PyProxy.get` method is available on this PyProxy. A
-	 * Typescript type guard.
+	 * Check whether the :js:class:`~pyodide.ffi.PyProxy` is a :js:class:`~pyodide.ffi.PyProxyWithGet`.
+	 * @deprecated Use ``obj instanceof pyodide.ffi.PyProxyWithGet`` instead.
 	 */
 	supportsGet(): this is PyProxyWithGet;
 	/**
-	 * Check whether the :any:`PyProxy.set` method is available on this PyProxy. A
-	 * Typescript type guard.
+	 * Check whether the :js:class:`~pyodide.ffi.PyProxy` is a :js:class:`~pyodide.ffi.PyProxyWithSet`.
+	 * @deprecated Use ``obj instanceof pyodide.ffi.PyProxyWithSet`` instead.
 	 */
 	supportsSet(): this is PyProxyWithSet;
 	/**
-	 * Check whether the :any:`PyProxy.has` method is available on this PyProxy. A
-	 * Typescript type guard.
+	 * Check whether the :js:class:`~pyodide.ffi.PyProxy` is a :js:class:`~pyodide.ffi.PyProxyWithHas`.
+	 * @deprecated Use ``obj instanceof pyodide.ffi.PyProxyWithHas`` instead.
 	 */
 	supportsHas(): this is PyProxyWithHas;
 	/**
-	 * Check whether the PyProxy is :term:`iterable`. A Typescript type guard for
-	 * :any:`PyProxy.[iterator]`.
+	 * Check whether the :js:class:`~pyodide.ffi.PyProxy` is a
+	 * :js:class:`~pyodide.ffi.PyIterable`.
+	 * @deprecated Use ``obj instanceof pyodide.ffi.PyIterable`` instead.
 	 */
-	isIterable(): this is PyProxyIterable;
+	isIterable(): this is PyIterable;
 	/**
-	 * Check whether the PyProxy is :term:`iterable`. A Typescript type guard for
-	 * :any:`PyProxy.next`.
+	 * Check whether the :js:class:`~pyodide.ffi.PyProxy` is a
+	 * :js:class:`~pyodide.ffi.PyIterator`
+	 * @deprecated Use ``obj instanceof pyodide.ffi.PyIterator`` instead.
 	 */
-	isIterator(): this is PyProxyIterator;
+	isIterator(): this is PyIterator;
 	/**
-	 * Check whether the PyProxy is :ref:`awaitable <asyncio-awaitables>`. A Typescript type guard, if this
-	 * function returns true Typescript considers the PyProxy to be a ``Promise``.
+	 * Check whether the :js:class:`~pyodide.ffi.PyProxy` is a :js:class:`~pyodide.ffi.PyAwaitable`
+	 * @deprecated Use :js:class:`obj instanceof pyodide.ffi.PyAwaitable <pyodide.ffi.PyAwaitable>` instead.
 	 */
-	isAwaitable(): this is PyProxyAwaitable;
+	isAwaitable(): this is PyAwaitable;
 	/**
-	 * Check whether the PyProxy implements the :external:doc:`c-api/buffer`. A Typescript type guard for
-	 * :any:`PyProxy.getBuffer`.
+	 * Check whether the :js:class:`~pyodide.ffi.PyProxy` is a :js:class:`~pyodide.ffi.PyBuffer`.
+	 * @deprecated Use ``obj instanceof pyodide.ffi.PyBuffer`` instead.
 	 */
-	isBuffer(): this is PyProxyBuffer;
+	isBuffer(): this is PyBuffer;
 	/**
-	 * Check whether the PyProxy is :std:term:`callable`. A Typescript type guard,
-	 * if this returns true then Typescript considers the Proxy to be callable of
-	 * signature ``(args... : any[]) => PyProxy | number | bigint | string |
-	 * boolean | undefined``.
+	 * Check whether the :js:class:`~pyodide.ffi.PyProxy` is a :js:class:`~pyodide.ffi.PyCallable`.
+	 * @deprecated ``obj instanceof pyodide.ffi.PyCallable`` instead.
 	 */
-	isCallable(): this is PyProxyCallable;
+	isCallable(): this is PyCallable;
+}
+/**
+ * A :js:class:`~pyodide.ffi.PyProxy` whose proxied Python object has a :meth:`~object.__len__`
+ * method.
+ */
+declare class PyProxyWithLength extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyProxy;
 }
-export declare type PyProxyWithLength = PyProxy & PyProxyLengthMethods;
-declare class PyProxyLengthMethods {
+/** @deprecated Use `import type { PyProxyWithLength } from "pyodide/ffi"` instead */
+interface PyProxyWithLength extends PyLengthMethods {
+}
+declare class PyLengthMethods {
 	/**
 	 * The length of the object.
-	 *
-	 * Present only if the proxied Python object has a :meth:`~object.__len__` method.
 	 */
 	get length(): number;
 }
-export declare type PyProxyWithGet = PyProxy & PyProxyGetItemMethods;
-declare class PyProxyGetItemMethods {
+/**
+ * A :js:class:`~pyodide.ffi.PyProxy` whose proxied Python object has a
+ * :meth:`~object.__getitem__` method.
+ */
+declare class PyProxyWithGet extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyProxy;
+}
+/** @deprecated Use `import type { PyProxyWithGet } from "pyodide/ffi"` instead */
+interface PyProxyWithGet extends PyGetItemMethods {
+}
+declare class PyGetItemMethods {
 	/**
 	 * This translates to the Python code ``obj[key]``.
 	 *
-	 * Present only if the proxied Python object has a :meth:`~object.__getitem__` method.
-	 *
 	 * @param key The key to look up.
 	 * @returns The corresponding value.
 	 */
 	get(key: any): any;
 }
-export declare type PyProxyWithSet = PyProxy & PyProxySetItemMethods;
-declare class PyProxySetItemMethods {
+/**
+ * A :js:class:`~pyodide.ffi.PyProxy` whose proxied Python object has a
+ * :meth:`~object.__setitem__` or :meth:`~object.__delitem__` method.
+ */
+declare class PyProxyWithSet extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyProxy;
+}
+/** @deprecated Use `import type { PyProxyWithSet } from "pyodide/ffi"` instead */
+interface PyProxyWithSet extends PySetItemMethods {
+}
+declare class PySetItemMethods {
 	/**
 	 * This translates to the Python code ``obj[key] = value``.
 	 *
-	 * Present only if the proxied Python object has a :meth:`~object.__setitem__` method.
-	 *
 	 * @param key The key to set.
 	 * @param value The value to set it to.
 	 */
@@ -221,40 +259,75 @@ declare class PyProxySetItemMethods {
 	/**
 	 * This translates to the Python code ``del obj[key]``.
 	 *
-	 * Present only if the proxied Python object has a :meth:`~object.__delitem__` method.
-	 *
 	 * @param key The key to delete.
 	 */
 	delete(key: any): void;
 }
-export declare type PyProxyWithHas = PyProxy & PyProxyContainsMethods;
-declare class PyProxyContainsMethods {
+/**
+ * A :js:class:`~pyodide.ffi.PyProxy` whose proxied Python object has a
+ * :meth:`~object.__contains__` method.
+ */
+declare class PyProxyWithHas extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyProxy;
+}
+/** @deprecated Use `import type { PyProxyWithHas } from "pyodide/ffi"` instead */
+interface PyProxyWithHas extends PyContainsMethods {
+}
+declare class PyContainsMethods {
 	/**
 	 * This translates to the Python code ``key in obj``.
 	 *
-	 * Present only if the proxied Python object has a :meth:`~object.__contains__` method.
-	 *
 	 * @param key The key to check for.
 	 * @returns Is ``key`` present?
 	 */
 	has(key: any): boolean;
 }
-export declare type PyProxyIterable = PyProxy & PyProxyIterableMethods;
-declare class PyProxyIterableMethods {
+declare class PyIterable extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyProxy;
+}
+/** @deprecated Use `import type { PyIterable } from "pyodide/ffi"` instead */
+interface PyIterable extends PyIterableMethods {
+}
+/** @deprecated Use :js:class:`pyodide.ffi.PyIterable` instead. */
+export declare type PyProxyIterable = PyIterable;
+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`
-	 *
-	 * Present only if the proxied Python object is :std:term:`iterable` (i.e.,
-	 * has an :meth:`~object.__iter__` method).
+	 * :js:data:`Symbol.iterator`.
 	 *
 	 * This will be used implicitly by ``for(let x of proxy){}``.
 	 */
 	[Symbol.iterator](): Iterator<any, any, any>;
 }
-export declare type PyProxyIterator = PyProxy & PyProxyIteratorMethods;
-declare class PyProxyIteratorMethods {
+declare class PyAsyncIterable extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyProxy;
+}
+/** @deprecated Use `import type { PyAsyncIterable } from "pyodide/ffi"` instead */
+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 PyIterator extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyProxy;
+}
+/** @deprecated Use `import type { PyIterator } from "pyodide/ffi"` instead */
+interface PyIterator extends PyIteratorMethods {
+}
+/** @deprecated Use :js:class:`pyodide.ffi.PyIterator` instead. */
+export declare type PyProxyIterator = PyIterator;
+declare class PyIteratorMethods {
 	/** @private */
 	[Symbol.iterator](): this;
 	/**
@@ -264,32 +337,151 @@ declare class PyProxyIteratorMethods {
 	 *
 	 * This will be used implicitly by ``for(let x of proxy){}``.
 	 *
-	 * Present only if the proxied Python object is an :term:`iterator` (i.e.,
-	 * has a :meth:`~generator.send` or :meth:`~iterator.__next__` method).
-	 *
 	 * @param any 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 :any:`StopIteration`
+	 * some_value}``. When the generator raises a :py:exc:`StopIteration`
 	 * exception, ``next`` returns ``{done : true, value : result_value}``.
 	 */
 	next(arg?: any): IteratorResult<any, any>;
 }
-export declare type PyProxyAwaitable = PyProxy & Promise<any>;
-export declare type PyProxyCallable = PyProxy & PyProxyCallableMethods & ((...args: any[]) => any);
-declare class PyProxyCallableMethods {
+declare class PyGenerator extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyProxy;
+}
+/** @deprecated Use `import type { PyGenerator } from "pyodide/ffi"` instead */
+interface PyGenerator extends PyGeneratorMethods {
+}
+declare class PyGeneratorMethods {
+	/**
+	 * Throws an exception into the Generator.
+	 *
+	 * See the documentation for :js:meth:`Generator.throw`.
+	 *
+	 * @param exception 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 any 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 PyAsyncIterator extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyProxy;
+}
+/** @deprecated Use `import type { PyAsyncIterator } from "pyodide/ffi"` instead */
+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 any 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 PyAsyncGenerator extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyProxy;
+}
+/** @deprecated Use `import type { PyAsyncGenerator } from "pyodide/ffi"` instead */
+interface PyAsyncGenerator extends PyAsyncGeneratorMethods {
+}
+declare class PyAsyncGeneratorMethods {
+	/**
+	 * Throws an exception into the Generator.
+	 *
+	 * See the documentation for :js:meth:`AsyncGenerator.throw`.
+	 *
+	 * @param exception 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 any 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 PyAwaitable extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyProxy;
+}
+/** @deprecated Use `import type { PyAwaitable } from "pyodide/ffi"` instead */
+interface PyAwaitable extends Promise<any> {
+}
+/** @deprecated Use :js:class:`pyodide.ffi.PyAwaitable` instead. */
+export declare type PyProxyAwaitable = PyAwaitable;
+declare class PyCallable extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyCallable;
+}
+/**
+ * @deprecated Use :js:class:`pyodide.ffi.PyCallable` instead.
+ */
+export declare type PyProxyCallable = PyCallable;
+/** @deprecated Use `import type { PyCallable } from "pyodide/ffi"` instead */
+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`.
 	 *
-	 * Present only if the proxied Python object is :std:term:`callable` (i.e., has a
-	 * :meth:`~object.__call__` method).
-	 *
 	 * @param thisArg The ``this`` argument. Has no effect unless the
-	 * :any:`PyProxy` has :any:`captureThis` set. If :any:`captureThis` is set, it
-	 * will be passed as the first argument to the Python function.
+	 * :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.
 	 */
@@ -298,20 +490,17 @@ declare class PyProxyCallableMethods {
 	 * Calls the function with a given this value and arguments provided
 	 * individually. See :js:meth:`Function.call`.
 	 *
-	 * Present only if the proxied Python object is :term:`callable` (i.e., has a
-	 * :meth:`~object.__call__` method).
-	 *
 	 * @param thisArg The ``this`` argument. Has no effect unless the
-	 * :any:`PyProxy` has :any:`captureThis` set. If :any:`captureThis` is set, it
-	 * will be passed as the first argument to the Python function.
+	 * :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 function with key word arguments. The last argument must be an
-	 * object with the keyword arguments. Present only if the proxied Python
-	 * object is :term:`callable` (i.e., has a :meth:`~object.__call__` method).
+	 * object with the keyword arguments.
 	 */
 	callKwargs(...jsargs: any): any;
 	/**
@@ -320,14 +509,11 @@ declare class PyProxyCallableMethods {
 	 * arguments preceding any provided when the new function is called. See
 	 * :js:meth:`Function.bind`.
 	 *
-	 * If the `PyProxy` does not have :any:`captureThis` set, the ``this``
-	 * parameter will be discarded. If it does have :any:`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.
-	 *
-	 * Present only if the proxied Python object is :term:`callable` (i.e., has a
-	 * :meth:`~object.__call__` method)
+	 * 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.
@@ -337,8 +523,8 @@ declare class PyProxyCallableMethods {
 	 */
 	bind(thisArg: any, ...jsargs: any): PyProxy;
 	/**
-	 * Returns a ``PyProxy`` that passes ``this`` as the first argument to the
-	 * Python function. The returned ``PyProxy`` has the internal ``captureThis``
+	 * 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
@@ -347,112 +533,72 @@ declare class PyProxyCallableMethods {
 	 *
 	 * For example:
 	 *
-	 * .. code-block:: js
+	 * .. 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`:
+	 *    // 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 ``PyProxy``. It has the same lifetime as the
-	 * original ``PyProxy`` but passes ``this`` to the wrapped function.
+	 * @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;
 }
-export declare type PyProxyBuffer = PyProxy & PyProxyBufferMethods;
-declare class PyProxyBufferMethods {
+declare class PyBuffer extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyBuffer;
+}
+/** @deprecated Use `import type { PyBuffer } from "pyodide/ffi"` instead */
+interface PyBuffer extends PyBufferMethods {
+}
+declare class PyBufferMethods {
 	/**
 	 * Get a view of the buffer data which is usable from JavaScript. No copy is
 	 * ever performed.
 	 *
-	 * Present only if the proxied Python object supports the Python
-	 * :external:doc:`c-api/buffer`.
-	 *
 	 * 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 :any:`toJs` api or copy the
-	 * buffer to one that doesn't use suboffets (using e.g.,
+	 * 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
-	 * ``toJs``. :js:class:`DataView` has support for big endian data, so you
-	 * might want to pass ``'dataview'`` as the type argument in that case.
+	 * :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.PyBuffer.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 ``getBuffer`` will try to determine the appropriate
-	 * output type based on the buffer format string (see
-	 * :std:ref:`struct-format-strings`).
-	 * @returns :js:class:`~pyodide.PyBuffer`
+	 * @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): PyBuffer;
+	getBuffer(type?: string): PyBufferView;
 }
 export declare type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;
-export declare type PyProxyDict = PyProxyWithGet & PyProxyWithSet & PyProxyWithHas;
-/**
- * A class to allow access to a Python data buffers from JavaScript. These are
- * produced by :js:func:`PyProxy.getBuffer` and cannot be constructed directly.
- * When you are done, release it with the :js:func:`~PyBuffer.release` method.
- * See the Python :external:doc:`c-api/buffer` documentation for more
- * information.
- *
- * To find the element ``x[a_1, ..., a_n]``, you could use the following code:
- *
- * .. code-block:: js
- *
- *    function multiIndexToIndex(pybuff, multiIndex){
- *       if(multindex.length !==pybuff.ndim){
- *          throw new Error("Wrong length index");
- *       }
- *       let idx = pybuff.offset;
- *       for(let i = 0; i < pybuff.ndim; i++){
- *          if(multiIndex[i] < 0){
- *             multiIndex[i] = pybuff.shape[i] - multiIndex[i];
- *          }
- *          if(multiIndex[i] < 0 || multiIndex[i] >= pybuff.shape[i]){
- *             throw new Error("Index out of range");
- *          }
- *          idx += multiIndex[i] * pybuff.stride[i];
- *       }
- *       return idx;
- *    }
- *    console.log("entry is", pybuff.data[multiIndexToIndex(pybuff, [2, 0, -1])]);
- *
- * .. admonition:: Converting between TypedArray types
- *    :class: warning
- *
- *    The following naive code to change the type of a typed array does not
- *    work:
- *
- *    .. code-block:: js
- *
- *        // Incorrectly convert a TypedArray.
- *        // Produces a Uint16Array that points to the entire WASM memory!
- *        let myarray = new Uint16Array(buffer.data.buffer);
- *
- *    Instead, if you want to convert the output TypedArray, you need to say:
- *
- *    .. code-block:: js
- *
- *        // Correctly convert a TypedArray.
- *        let myarray = new Uint16Array(
- *            buffer.data.buffer,
- *            buffer.data.byteOffset,
- *            buffer.data.byteLength
- *        );
- */
-export declare class PyBuffer {
+declare class PyDict extends PyProxy {
+	/** @private */
+	static [Symbol.hasInstance](obj: any): obj is PyProxy;
+}
+/** @deprecated Use `import type { PyDict } from "pyodide/ffi"` instead */
+interface PyDict extends PyProxyWithGet, PyProxyWithSet, PyProxyWithHas, PyProxyWithLength, PyIterable {
+}
+/** @deprecated Use :js:class:`pyodide.ffi.PyDict` instead. */
+export declare type PyProxyDict = PyDict;
+/** @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
@@ -460,7 +606,7 @@ export declare class PyBuffer {
 	 */
 	offset: number;
 	/**
-	 * If the data is readonly, you should not modify it. There is no way for us
+	 * 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`.
 	 */
@@ -471,7 +617,7 @@ export declare class PyBuffer {
 	 */
 	format: string;
 	/**
-	 * How large is each entry (in bytes)? See :any:`memoryview.itemsize`.
+	 * How large is each entry in bytes? See :py:attr:`memoryview.itemsize`.
 	 */
 	itemsize: number;
 	/**
@@ -482,7 +628,7 @@ export declare class PyBuffer {
 	ndim: number;
 	/**
 	 * The total number of bytes the buffer takes up. This is equal to
-	 * ``buff.data.byteLength``. See :py:attr:`memoryview.nbytes`.
+	 * :js:attr:`buff.data.byteLength <TypedArray.byteLength>`. See :py:attr:`memoryview.nbytes`.
 	 */
 	nbytes: number;
 	/**
@@ -501,45 +647,41 @@ export declare class PyBuffer {
 	 * The actual data. A typed array of an appropriate size backed by a segment
 	 * of the WASM memory.
 	 *
-	 * The ``type`` argument of :any:`PyProxy.getBuffer` determines which sort of
-	 * :js:class:`TypedArray` or :js:class:`DataView` to return. By default
-	 * :any:`PyProxy.getBuffer` will look at the format string to determine the
-	 * most appropriate option. Most often the result is a :js:class:`Uint8Array`.
+	 * 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 ``data`` TypedArray will contain
-	 *    data that is not part of the buffer. Modifying this data leads to
-	 *    undefined behavior.
+	 *    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:: Readonly buffers
+	 * .. admonition:: Read only buffers
 	 *    :class: warning
 	 *
-	 *    If ``buffer.readonly`` is ``true``, you should not modify the buffer.
-	 *    Modifying a readonly buffer leads to undefined behavior.
+	 *    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 :any:`memoryview.c_contiguous`.
+	 * Is it C contiguous? See :py:attr:`memoryview.c_contiguous`.
 	 */
 	c_contiguous: boolean;
 	/**
-	 * Is it Fortran contiguous? See :any:`memoryview.f_contiguous`.
+	 * Is it Fortran contiguous? See :py:attr:`memoryview.f_contiguous`.
 	 */
 	f_contiguous: boolean;
-	/**
-	 * @private
-	 */
+	/** @private */
 	_released: boolean;
-	/**
-	 * @private
-	 */
+	/** @private */
 	_view_ptr: number;
-	/**
-	 * @private
-	 */
+	/** @private */
 	constructor();
 	/**
 	 * Release the buffer. This allows the memory to be reclaimed.
@@ -551,9 +693,6 @@ declare function loadPackage(names: string | PyProxy | Array<string>, options?:
 	errorCallback?: (message: string) => void;
 	checkIntegrity?: boolean;
 }, errorCallbackDeprecated?: (message: string) => void): Promise<void>;
-declare let loadedPackages: {
-	[key: string]: string;
-};
 declare class PythonError extends Error {
 	/**
 	 * The address of the error we are wrapping. We may later compare this
@@ -564,13 +703,13 @@ declare class PythonError extends Error {
 	 */
 	__error_address: number;
 	/**
-	 * The name of the Python error class, e.g, :any:`RuntimeError` or
-	 * :any:`KeyError`.
+	 * The name of the Python error class, e.g, :py:exc:`RuntimeError` or
+	 * :py:exc:`KeyError`.
 	 */
 	type: string;
 	constructor(type: string, message: string, error_address: number);
 }
-declare type InFuncType = () => null | undefined | string | ArrayBuffer | ArrayBufferView | number;
+declare type InFuncType = () => null | undefined | string | ArrayBuffer | Uint8Array | number;
 declare function setStdin(options?: {
 	stdin?: InFuncType;
 	error?: boolean;
@@ -587,76 +726,361 @@ declare function setStderr(options?: {
 	raw?: (a: number) => void;
 	isatty?: boolean;
 }): void;
-declare let pyodide_py: PyProxy;
-declare let globals: PyProxy;
-declare function runPython(code: string, options?: {
-	globals?: PyProxy;
-}): any;
-declare function loadPackagesFromImports(code: string, options?: {
-	messageCallback?: (message: string) => void;
-	errorCallback?: (message: string) => void;
-	checkIntegrity?: boolean;
-}, errorCallbackDeprecated?: (message: string) => void): Promise<void>;
-declare function runPythonAsync(code: string, options?: {
-	globals?: PyProxy;
-}): Promise<any>;
-declare function registerJsModule(name: string, module: object): void;
-declare function registerComlink(Comlink: any): void;
-declare function unregisterJsModule(name: string): void;
-declare function 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 :any:`JsProxy.to_py`.
-	 */
-	defaultConverter?: (value: any, converter: (value: any) => any, cacheConversion: (input: any, output: any) => void) => any;
-}): any;
-declare function pyimport(mod_name: string): PyProxy;
-declare function unpackArchive(buffer: TypedArray | ArrayBuffer, format: string, options?: {
-	extractDir?: string;
-}): void;
 declare type NativeFS = {
-	syncfs: Function;
-};
-declare function mountNativeFS(path: string, fileSystemHandle: FileSystemDirectoryHandle): Promise<NativeFS>;
-declare function setInterruptBuffer(interrupt_buffer: TypedArray): void;
-declare function checkInterrupt(): void;
-export declare type PyodideInterface = {
-	globals: typeof globals;
-	FS: typeof FS;
-	PATH: typeof PATH;
-	ERRNO_CODES: typeof ERRNO_CODES;
-	pyodide_py: typeof pyodide_py;
-	version: typeof version;
-	loadPackage: typeof loadPackage;
-	loadPackagesFromImports: typeof loadPackagesFromImports;
-	loadedPackages: typeof loadedPackages;
-	isPyProxy: typeof isPyProxy;
-	runPython: typeof runPython;
-	runPythonAsync: typeof runPythonAsync;
-	registerJsModule: typeof registerJsModule;
-	unregisterJsModule: typeof unregisterJsModule;
-	setInterruptBuffer: typeof setInterruptBuffer;
-	checkInterrupt: typeof checkInterrupt;
-	toPy: typeof toPy;
-	pyimport: typeof pyimport;
-	unpackArchive: typeof unpackArchive;
-	mountNativeFS: typeof mountNativeFS;
-	registerComlink: typeof registerComlink;
-	PythonError: typeof PythonError;
-	PyBuffer: typeof PyBuffer;
-	setStdin: typeof setStdin;
-	setStdout: typeof setStdout;
-	setStderr: typeof setStderr;
-};
-declare let FS: any;
-declare let PATH: any;
-declare let ERRNO_CODES: {
-	[code: string]: number;
+	syncfs: () => Promise<void>;
 };
+declare class PyodideAPI {
+	/** @hidden */
+	static version: string;
+	/** @hidden */
+	static loadPackage: typeof loadPackage;
+	/** @hidden */
+	static loadedPackages: {
+		[key: string]: string;
+	};
+	/** @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;
+	};
+	/** @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: any;
+	/**
+	 * 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;
+	/**
+	 * This provides APIs to set a canvas for rendering graphics.
+	 *
+	 * For example, you need to set a canvas if you want to use the
+	 * SDL library. See :ref:`using-sdl` for more information.
+	 */
+	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)
+	 * @param errorCallbackDeprecated @ignore
+	 * @async
+	 */
+	static loadPackagesFromImports(code: string, options?: {
+		messageCallback?: (message: string) => void;
+		errorCallback?: (message: string) => void;
+		checkIntegrity?: boolean;
+	}, errorCallbackDeprecated?: (message: string) => void): Promise<void>;
+	/**
+	 * 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 Python code to evaluate
+	 * @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``.
+	 * @returns The result of the Python code translated to JavaScript. See the
+	 *          documentation for :py:func:`~pyodide.code.eval_code` for more info.
+	 */
+	static runPython(code: string, options?: {
+		globals?: PyProxy;
+		locals?: PyProxy;
+	}): 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("./repodata.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 Python code to evaluate
+	 * @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``.
+	 * @returns The result of the Python code translated to JavaScript.
+	 * @async
+	 */
+	static runPythonAsync(code: string, options?: {
+		globals?: PyProxy;
+		locals?: PyProxy;
+	}): 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`.
+	 *
+	 * @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.
+	 *
+	 * .. admonition:: Warning
+	 *    :class: warning
+	 *
+	 *    This function has a completely different behavior than the old removed pyimport function!
+	 *
+	 *    ``pyimport`` is roughly equivalent to:
+	 *
+	 *    .. code-block:: js
+	 *
+	 *      pyodide.runPython(`import ${pkgname}; ${pkgname}`);
+	 *
+	 *    except that the global namespace will not change.
+	 *
+	 *    Example:
+	 *
+	 *    .. code-block:: js
+	 *
+	 *      let sysmodule = pyodide.pyimport("sys");
+	 *      let recursionLimit = sysmodule.getrecursionlimit();
+	 *
+	 * @param mod_name The name of the module to import
+	 * @returns A PyProxy for the imported module
+	 */
+	static pyimport(mod_name: string): PyProxy;
+	/**
+	 * 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.
+	 *
+	 * @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 ``navigator.storage.getDirectory()``
+	 * or ``window.showDirectoryPicker()``.
+	 */
+	static mountNativeFS(path: string, fileSystemHandle: FileSystemDirectoryHandle): Promise<NativeFS>;
+	/**
+	 * 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
+	 * when Pyodide is used in a webworker. The buffer should be a
+	 * :js:class:`SharedArrayBuffer` shared with the main browser thread (or another
+	 * worker). In that case, signal ``signum`` may be sent by writing ``signum``
+	 * into the interrupt buffer. If ``signum`` does not satisfy 0 < ``signum`` < 65
+	 * it will be silently ignored.
+	 *
+	 * You can disable interrupts by calling ``setInterruptBuffer(undefined)``.
+	 *
+	 * If you wish to trigger a :py:exc:`KeyboardInterrupt`, write ``SIGINT`` (a 2)
+	 * into the interrupt buffer.
+	 *
+	 * By default ``SIGINT`` raises a :py:exc:`KeyboardInterrupt` and all other signals
+	 * are ignored. You can install custom signal handlers with the signal module.
+	 * Even signals that normally have special meaning and can't be overridden like
+	 * ``SIGKILL`` and ``SIGSEGV`` are ignored by default and can be used for any
+	 * purpose you like.
+	 */
+	static setInterruptBuffer(interrupt_buffer: TypedArray): void;
+	/**
+	 * Throws a :py:exc:`KeyboardInterrupt` error if a :py:exc:`KeyboardInterrupt` has
+	 * been requested via the interrupt buffer.
+	 *
+	 * This can be used to enable keyboard interrupts during execution of JavaScript
+	 * code, just as :c:func:`PyErr_CheckSignals` is used to enable keyboard interrupts
+	 * during execution of C code.
+	 */
+	static checkInterrupt(): void;
+	/**
+	 * Is ``jsobj`` a :js:class:`~pyodide.ffi.PyProxy`?
+	 * @deprecated Use :js:class:`obj instanceof pyodide.ffi.PyProxy <pyodide.ffi.PyProxy>` instead.
+	 * @param jsobj Object to test.
+	 */
+	static isPyProxy(jsobj: any): jsobj is PyProxy;
+	/**
+	 * An alias for :js:class:`pyodide.ffi.PyBufferView`.
+	 *
+	 * @hidetype
+	 * @alias
+	 * @doc_kind class
+	 * @deprecated
+	 */
+	static get PyBuffer(): typeof PyBufferView;
+	/**
+	 * An alias for :js:class:`pyodide.ffi.PyBuffer`.
+	 *
+	 * @hidetype
+	 * @alias
+	 * @doc_kind class
+	 * @deprecated
+	 */
+	static get PyProxyBuffer(): typeof PyBuffer;
+	/**
+	 * An alias for :js:class:`pyodide.ffi.PyBuffer`.
+	 *
+	 * @hidetype
+	 * @alias
+	 * @doc_kind class
+	 * @deprecated
+	 */
+	static get PythonError(): typeof PythonError;
+}
+/** @hidetype */
+export declare type PyodideInterface = typeof PyodideAPI;
 export declare type Py2JsResult = any;
 /**
  * See documentation for loadPyodide.
@@ -667,6 +1091,7 @@ export declare type ConfigType = {
 	lockFileURL: string;
 	homedir: string;
 	fullStdLib?: boolean;
+	stdLibURL?: string;
 	stdin?: () => string;
 	stdout?: (msg: string) => void;
 	stderr?: (msg: string) => void;
@@ -693,7 +1118,7 @@ export declare function loadPyodide(options?: {
 	indexURL?: string;
 	/**
 	 * The URL from which Pyodide will load the Pyodide ``repodata.json`` lock
-	 * file. You can produce custom lock files with :any:`micropip.freeze`.
+	 * file. You can produce custom lock files with :py:func:`micropip.freeze`.
 	 * Default: ```${indexURL}/repodata.json```
 	 */
 	lockFileURL?: string;
@@ -708,6 +1133,14 @@ export declare function loadPyodide(options?: {
 	 * Default: ``false``
 	 */
 	fullStdLib?: boolean;
+	/**
+	 * The URL from which to load the standard library ``python_stdlib.zip``
+	 * file. This URL includes the most of the Python stadard library. Some
+	 * stdlib modules were unvendored, and can be loaded separately
+	 * with ``fullStdLib=true`` option or by their package name.
+	 * Default: ```${indexURL}/python_stdlib.zip```
+	 */
+	stdLibURL?: string;
 	/**
 	 * Override the standard input callback. Should ask the user for one line of
 	 * input.
@@ -739,4 +1172,10 @@ export declare function loadPyodide(options?: {
 	_node_mounts?: string[];
 }): Promise<PyodideInterface>;
 
-export {};
+export type {
+	PyBuffer as PyProxyBuffer,
+	PyBufferView as PyBuffer,
+};
+
+export type {};
+export type {PyProxy, PyProxyWithGet, PyProxyWithHas, PyProxyWithLength, PyProxyWithSet};