@unbound-app/api 0.9.0 → 1.1.0

package/src/metro/stores.d.ts

@@ -1,7 +1,12 @@
 // Auto-generated by generate-plugin-sdk.ts - DO NOT EDIT
 
+/** Discord's `AccessibilityStore` Flux store, holding the user's accessibility settings; found on first access. */
 export declare const Accessibility: any;
+/** Discord's `GuildStore` Flux store, holding the servers the user is in; found on first access. */
 export declare const Guilds: any;
+/** Discord's `ThemeStore` Flux store, holding the theme Discord shows; found on first access. */
+export declare const Theme: any;
+/** Discord's `UserStore` Flux store, holding the users the client knows; found on first access. */
 export declare const Users: any;
 
 export {};

package/src/native.d.ts

@@ -2,51 +2,115 @@
 
 export type {
 	NativeAssociationKey,
+	NativeBatchReference,
+	NativeBatchStep,
 	NativeCallOptions,
+	NativeCancelablePromise,
 	NativeClassHandle,
+	NativeDebugBridge,
+	NativeDebugEnvironment,
+	NativeDebugEvaluation,
 	NativeFFIBridge,
 	NativeFFISignature,
 	NativeFFIType,
 	NativeFFITypeName,
 	NativeFabricBridge,
 	NativeFabricFrame,
+	NativeFabricMountOptions,
 	NativeFabricSize,
 	NativeFabricSurface,
 	NativeHandle,
 	NativeHookContext,
 	NativeHookHandlers,
 	NativeHookOptions,
+	NativeHookPayload,
 	NativeHookToken,
+	NativeJavaArgument,
+	NativeJavaAssociationKey,
+	NativeJavaBatchOperation,
+	NativeJavaBridge,
+	NativeJavaCallPlan,
+	NativeJavaClassDescription,
+	NativeJavaFieldDescription,
+	NativeJavaHandle,
+	NativeJavaHandleValue,
+	NativeJavaHookEvent,
+	NativeJavaHookOptions,
+	NativeJavaHookToken,
+	NativeJavaHooksBridge,
+	NativeJavaMethodDescription,
+	NativeJavaReference,
+	NativeJavaValue,
 	NativeObjCBridge,
+	NativeObjCCallPlan,
 	NativeObjectHandle,
 	NativePlatformBridge,
 	NativePluginBridge,
 	NativePluginCapability,
 	NativePluginError,
 	NativePluginErrorCode,
+	NativePluginPlatform,
 	NativePointer,
+	NativeRuntimeBridge,
+	NativeRuntimeEventName,
+	NativeRuntimeEventToken,
+	NativeSerializableObject,
 	NativeStruct,
 	NativeThreadPolicy,
+	NativeUIArgument,
+	NativeUIBridge,
+	NativeUICallback,
+	NativeUIScope,
+	NativeViewSearchOptions,
+	NativeViewSnapshotNode,
+	NativeViewSnapshotOptions,
 	PluginContext,
 } from './_internal';
-import type { NativePlatformBridge, NativePluginCapability } from './_internal';
+import type {
+	NativePlatformBridge,
+	NativePluginCapability,
+	NativePluginPlatform,
+	NativeResourceCounts,
+} from './_internal';
+import * as React$1 from 'react';
+import { ComponentType } from 'react';
+/** The loader's platform bridge, read from `globalThis.NativePlatform` at import; `undefined` when no loader injected it. */
 declare const NativePlatform$1: NativePlatformBridge | undefined;
 
+/** Thrown when a plugin uses a Capability its manifest does not declare, or declares one that is unknown or the native bridge lacks. */
 export declare class NativePluginCapabilityError extends Error {
+	/** A stable code to match on instead of the message. */
 	readonly code = 'NATIVE_PLUGIN_CAPABILITY_DENIED';
+	/** The Capability that was missing or refused. */
 	readonly capability: NativePluginCapability;
 	constructor(capability: NativePluginCapability);
 }
+/** Thrown when native work is called through a plugin's scope after the scope was disposed, such as after the plugin stopped. */
 export declare class NativePluginDisposedError extends Error {
+	/** A stable code to match on instead of the message. */
 	readonly code = 'NATIVE_PLUGIN_SCOPE_DISPOSED';
 	constructor();
 }
+/** Thrown when the loader does not provide the native plugin bridge, or the part of it a call needs. */
 export declare class NativePluginUnavailableError extends Error {
+	/** A stable code to match on instead of the message. */
 	readonly code = 'NATIVE_PLUGIN_UNAVAILABLE';
 }
+/** Thrown when the host platform is not one the addon runs on, by its manifest or the handlers given to `definePlatform`. */
+export declare class NativePluginUnsupportedPlatformError extends Error {
+	/** A stable code to match on instead of the message. */
+	readonly code = 'NATIVE_PLUGIN_PLATFORM_EXCLUDED';
+	/** The platforms the addon does run on. */
+	readonly platforms: readonly NativePluginPlatform[];
+	constructor(platforms: readonly NativePluginPlatform[], platform: string);
+}
+/** Thrown when the native plugin API is older than the manifest's `minNativePluginApi`. */
 export declare class NativePluginVersionError extends Error {
+	/** A stable code to match on instead of the message. */
 	readonly code = 'NATIVE_PLUGIN_API_VERSION_UNSUPPORTED';
+	/** The native plugin API version the loader provides. */
 	readonly installedApi: string;
+	/** The manifest's `minNativePluginApi`. */
 	readonly requiredApi: string;
 	constructor(requiredApi: string, installedApi: string);
 }
@@ -56,6 +120,13 @@ export declare const BundleInfo: BundleInfoType;
 export declare const BundleManager: DCDBundleManagerType;
 /** The resolved native device module, exposing hardware and OS details. */
 export declare const DeviceInfo: DeviceInfoType;
+/**
+ * @description Selects the Platform handler for the host platform, so an addon branches on the platform in one place.
+ * @template Handler What each platform's handler provides.
+ * @param handlers The handler for each platform the addon runs on.
+ * @returns The host platform's handler.
+ */
+export declare function definePlatform<Handler>(handlers: PlatformHandlers<Handler>): Handler;
 /**
  * @description Resolves the first available native module matching any of the given names, checking both `NativeModules` and the `TurboModuleRegistry`.
  * @template T The type of the resolved native module.
@@ -63,47 +134,81 @@ export declare const DeviceInfo: DeviceInfoType;
  * @returns The first matching native module.
  */
 export declare function getNativeModule<T>(...names: string[]): T;
+/**
+ * @description Reads how many native resources the loader holds: installed hooks, mounted surfaces, cached hook return values and Java handles still referenced from JavaScript.
+ * @returns The counts, or `undefined` when the loader does not report them.
+ */
+export declare function getNativeResources(): NativeResourceCounts | undefined;
 /**
  * @description Reads Hermes' runtime metadata, such as the bytecode version, GC, and build channel.
  * @returns The runtime property map, or an empty object when Hermes internals are unavailable.
  */
 export declare function getRuntimeProperties(): HermesRuntimeProperties;
+/**
+ * @description Checks whether the native bridge on this device provides a capability, so an addon can
+ * fall back when the other platform lacks it.
+ * @param capability The capability to look for.
+ * @returns Whether the bridge provides it.
+ */
+export declare function has(capability: NativePluginCapability): boolean;
 /**
  * @description Persists pending settings to storage, then reloads the native bundle.
  */
 export declare function reload(): Promise<void>;
 /** Build and release metadata reported by the native client info module. */
 export type BundleInfoType = {
+	/** Discord's app version, shown in Unbound's settings beside `Build`. */
 	Version: string;
+	/** The Discord release channel the app was built for. */
 	ReleaseChannel: string;
+	/** Reported by Discord's native client info module; Unbound does not read it. */
 	Manifest: string;
+	/** Discord's build number; Unbound's Metro cache is invalidated when it changes. */
 	Build: string;
+	/** The Sentry DSN Discord reports crashes to. */
 	SentryDsn: string;
+	/** The device's vendor identifier, which Discord sends in its analytics properties. */
 	DeviceVendorID: string;
+	/** The build of the over-the-air JavaScript bundle, reported by Discord's native client info module. */
 	OTABuild: string;
+	/** The Sentry DSN Discord reports crashes to on staff builds. */
 	SentryStaffDsn: string;
+	/** The app's bundle identifier. */
 	Identifier: string;
+	/** The Sentry DSN Discord reports crashes to on alpha and beta builds. */
 	SentryAlphaBetaDsn: string;
 };
 /** The native `BundleUpdaterManager` module surface for OTA updates and reloading the bundle. */
 export type DCDBundleManagerType = {
+	/** Reports whether the first OTA bundle has been downloaded; Discord does not document what it resolves to. */
 	getInitialBundleDownloaded: UndocumentedNativeMethod;
+	/** Reports whether the first OTA update check has run; Discord does not document what it resolves to. */
 	getInitialOtaUpdateChecked: UndocumentedNativeMethod;
+	/** Checks for an OTA bundle update, then reloads the app. */
 	checkForUpdateAndReload(): void;
+	/** Reloads the JavaScript bundle; {@link reload} persists settings first, so prefer it. */
 	reload(): void;
+	/** Reads the directory OTA bundles are stored in; Discord does not document what it resolves to. */
 	getOtaRootPath: UndocumentedNativeMethod;
+	/** Reads the contents of Discord's build override cookie; Discord does not document what it resolves to. */
 	getBuildOverrideCookieContents: UndocumentedNativeMethod;
+	/** Sets the build override cookie header; Discord does not document its argument or result. */
 	setBuildOverrideCookieHeader: UndocumentedNativeMethod;
+	/** Reads the OTA manifest info; Discord does not document what it resolves to. */
 	getManifestInfo: UndocumentedNativeMethod;
+	/** React Native event-emitter hook: tells the native module a listener for `eventName` was added. */
 	addListener(eventName: string): void;
+	/** React Native event-emitter hook: tells the native module `count` listeners were removed. */
 	removeListeners(count: number): void;
 };
 /** The constant directory paths exposed by the native `DCDFileManager`. */
 export type DCDFileManagerConstants = {
+	/** The absolute path to the app's cache directory. */
 	CacheDirPath: string;
+	/** The absolute path to the app's documents directory, where Unbound keeps its files. */
 	DocumentsDirPath: string;
 };
-/** The text encodings accepted by the native `DCDFileManager` read/write operations. */
+/** How the native file manager encodes file contents: UTF-8 text or base64 for binary data. */
 export type DCDFileManagerEncoding = 'utf-8' | 'utf8' | 'base64';
 /** The native `DCDFileManager` module surface for reading, writing, and inspecting files. */
 export type DCDFileManagerType = {
@@ -124,22 +229,37 @@ export type DCDFileManagerType = {
 } & DCDFileManagerConstants;
 /** Hardware and OS details reported by the native device module. */
 export type DeviceInfoType = {
+	/** Whether the system task bar is shown, as Discord's native device module reports it. */
 	isTaskBarEnabled: boolean;
+	/** The maximum CPU frequency as a numeric string; empty when unknown. */
 	maxCpuFreq: string;
+	/** The system-on-chip's name. */
 	socName: string;
+	/** The device model; `iPad` on an iPad, which Discord checks to detect iPadOS. */
 	deviceModel: string;
+	/** Whether the device is a tablet. */
 	isTablet: boolean;
+	/** Whether the system uses gesture navigation instead of navigation buttons. */
 	isGestureNavigationEnabled: boolean;
+	/** The device's product name, as Discord's native device module reports it. */
 	deviceProduct: string;
+	/** The operating system version. */
 	systemVersion: string;
+	/** The device's manufacturer. */
 	deviceManufacturer: string;
+	/** The device's brand. */
 	deviceBrand: string;
+	/** The device's RAM size as a numeric string; empty when unknown. */
 	ramSize: string;
+	/** The device's name, as Discord's native device module reports it. */
 	device: string;
 };
+/** What `HermesInternal.getRuntimeProperties()` reports; empty when the engine is not Hermes. */
 export type HermesRuntimeProperties = ReturnType<HermesInternalObject['getRuntimeProperties']>;
+/** One Platform handler per platform an addon runs on. */
+export type PlatformHandlers<Handler> = Partial<Record<NativePluginPlatform, Handler>>;
+/** A native method Discord exposes without documenting what its promise resolves to. */
 export type UndocumentedNativeMethod = () => Promise<unknown>;
-
 export { NativePlatform$1 as NativePlatform };
 
 export {};

package/src/patcher.d.ts

@@ -1,5 +1,24 @@
 // Auto-generated by generate-plugin-sdk.ts - DO NOT EDIT
 
+import * as React$1 from 'react';
+import { JSXElementConstructor, ReactNode } from 'react';
+
+/** The kinds of patch: before, instead and after. */
+declare const PatchType$1: typeof PatchType;
+declare enum PatchType {
+	Before = 0,
+	Instead = 1,
+	After = 2,
+}
+/** The symbol a patched method carries, pointing at its patch state. */
+export declare const PATCH_SYMBOL: symbol;
+/** Every module the patcher has patched, with its live patches. */
+export declare const patches: PatchedModule[];
+/**
+ * `before`, `instead` and `after` for React components. Each takes a `memo`, `forwardRef` or class component and
+ * finds its render, or the object and key holding any component, which a plain function component needs.
+ */
+export declare const react: ReactPatcher;
 /**
  * @description Runs a callback after a method, which can replace its result by returning a value.
  * @template M The object holding the method.
@@ -10,20 +29,10 @@
  * @param options Patch options.
  * @returns A function removing the patch.
  */
-declare function after$1<M extends PatchParent, P extends PropOf<M>>(
+export declare function after<M extends PatchParent, P extends PropOf<M>>(
 	parent: M,
 	method: P,
-	callback: Parameters<typeof before<M, P>>[2],
-	options?: PatchOptions,
-): () => void;
-declare function after<M extends PatchParent, P extends PropOf<M>>(
-	parent: M,
-	method: P,
-	callback: PatchCallback<
-		M[P] extends (...args: infer Args) => any ? Args : any[],
-		M[P] extends (...args: any[]) => infer Res ? Res : any,
-		unknown extends ThisParameterType<M[P]> ? M : ThisParameterType<M[P]>
-	>,
+	callback: AfterCallback<ArgsOf<M[P]>, ResultOf<M[P]>, SelfOf<M, M[P]>>,
 	options?: PatchOptions,
 ): () => void;
 /**
@@ -36,20 +45,10 @@ declare function after<M extends PatchParent, P extends PropOf<M>>(
  * @param options Patch options.
  * @returns A function removing the patch.
  */
-declare function before$1<M extends PatchParent, P extends PropOf<M>>(
-	parent: M,
-	method: P,
-	callback: Parameters<typeof before<M, P>>[2],
-	options?: PatchOptions,
-): () => void;
-declare function before<M extends PatchParent, P extends PropOf<M>>(
+export declare function before<M extends PatchParent, P extends PropOf<M>>(
 	parent: M,
 	method: P,
-	callback: PatchCallback<
-		M[P] extends (...args: infer Args) => any ? Args : any[],
-		M[P] extends (...args: any[]) => infer Res ? Res : any,
-		unknown extends ThisParameterType<M[P]> ? M : ThisParameterType<M[P]>
-	>,
+	callback: BeforeCallback<ArgsOf<M[P]>, ResultOf<M[P]>, SelfOf<M, M[P]>>,
 	options?: PatchOptions,
 ): () => void;
 /**
@@ -62,36 +61,12 @@ declare function before<M extends PatchParent, P extends PropOf<M>>(
  * @param options Patch options.
  * @returns A function removing the patch.
  */
-declare function instead$1<M extends PatchParent, P extends PropOf<M>>(
+export declare function instead<M extends PatchParent, P extends PropOf<M>>(
 	parent: M,
 	method: P,
-	callback: Parameters<typeof before<M, P>>[2],
+	callback: InsteadCallback<ArgsOf<M[P]>, ResultOf<M[P]>, SelfOf<M, M[P]>>,
 	options?: PatchOptions,
 ): () => void;
-declare function instead<M extends PatchParent, P extends PropOf<M>>(
-	parent: M,
-	method: P,
-	callback: PatchCallback<
-		M[P] extends (...args: infer Args) => any ? Args : any[],
-		M[P] extends (...args: any[]) => infer Res ? Res : any,
-		unknown extends ThisParameterType<M[P]> ? M : ThisParameterType<M[P]>
-	>,
-	options?: PatchOptions,
-): () => void;
-//#region src/patcher.d.ts
-export declare const PATCH_SYMBOL: unique symbol;
-export declare const patches: PatchedModule[];
-export declare enum PatchType {
-	Before = 0,
-	Instead = 1,
-	After = 2,
-}
-/**
- * @description Creates a patcher whose patches share default options, so they can be removed together.
- * @param defaultOptions A caller id, or options merged into every patch; a caller id is generated if missing.
- * @returns The scoped patcher.
- */
-export declare function createPatcher(defaultOptions: string | PatchOptions): PatcherInstance;
 /**
  * @description Removes every patch.
  */
@@ -134,23 +109,205 @@ export interface PatchedModule {
 	original: AnyFunction & AnyConstructor;
 	patches: Record<PatchType, Set<Patch<any, any, any>>>;
 }
-export interface PatcherInstance {
-	instead: typeof instead;
-	before: typeof before;
-	after: typeof after;
-	unpatchAll: () => void;
-}
+/**
+ * An `after` callback, whose return value replaces the result unless it is `undefined`.
+ * @template Args The method's arguments.
+ * @template Res The method's result.
+ * @template Self The method's `this`.
+ */
+export type AfterCallback<Args extends unknown[], Res, Self> = (
+	ctx: AfterContext<Args, Res, Self>,
+) => Res | void;
+/**
+ * The context an `after` callback receives, with the result so far.
+ * @template Args The method's arguments.
+ * @template Res The method's result.
+ * @template Self The method's `this`.
+ */
+export type AfterContext<Args extends unknown[], Res, Self> = BeforeContext<Args, Res, Self> & {
+	result: Res;
+};
 export type AnyConstructor = {
 	new (...args: any): any;
 };
 export type AnyFunction = (...args: any[]) => any;
 export type AnyObject = Record<any, any>;
+/** The arguments a patch receives for method `F`: its parameters, or its constructor's for a class. */
+export type ArgsOf<F> =
+	IsUntyped<F> extends true
+		? F[]
+		: F extends AnyFunction
+			? Parameters<F>
+			: F extends AnyConstructor
+				? ConstructorParameters<F>
+				: never;
+/**
+ * A `before` callback, which can replace the arguments by returning an array.
+ * @template Args The method's arguments.
+ * @template Res The method's result.
+ * @template Self The method's `this`.
+ */
+export type BeforeCallback<Args extends unknown[], Res, Self> = (
+	ctx: BeforeContext<Args, Res, Self>,
+) => [...Args] | void;
+/**
+ * The context a `before` callback receives.
+ * @template Args The method's arguments.
+ * @template Res The method's result.
+ * @template Self The method's `this`.
+ */
+export type BeforeContext<Args extends unknown[], Res, Self> = {
+	/** The arguments of this call; a `before` callback can return a new array to replace them. */
+	args: Args;
+	/** The `this` the method was called with. */
+	this: Self;
+	/** The unpatched method; call it with `ctx.this` and `ctx.args` to run the original behavior. */
+	original: (...args: Args) => Res;
+};
+/**
+ * An `instead` callback, whose return value becomes the result unless it is `undefined`.
+ * @template Args The method's arguments.
+ * @template Res The method's result.
+ * @template Self The method's `this`.
+ */
+export type InsteadCallback<Args extends unknown[], Res, Self> = (
+	ctx: InsteadContext<Args, Res, Self>,
+) => Res | void;
+/**
+ * The context an `instead` callback receives.
+ * @template Args The method's arguments.
+ * @template Res The method's result.
+ * @template Self The method's `this`.
+ */
+export type InsteadContext<Args extends unknown[], Res, Self> = BeforeContext<Args, Res, Self>;
+/** Whether `T` is `any`, so a patch on an untyped method or component keeps loose types. */
+export type IsUntyped<T> = 0 extends 1 & T ? true : false;
 export type PatchMethod = string;
 export type PatchParent = AnyFunction | AnyObject;
 export type PropOf<M> = {
 	[K in keyof M]: M[K] extends AnyFunction | AnyConstructor ? Extract<K, string> : never;
 }[keyof M];
+/**
+ * An `after` callback, whose return value replaces the rendered tree unless it is `undefined`.
+ * @template P The component's props.
+ * @template Self The class instance rendering, or `undefined` for a function component.
+ */
+export type ReactAfterCallback<P, Self> = (ctx: ReactAfterContext<P, Self>) => React$1.ReactNode;
+/**
+ * The context an `after` callback of `patcher.react` receives, with the rendered tree.
+ * @template P The component's props.
+ * @template Self The class instance rendering, or `undefined` for a function component.
+ */
+export type ReactAfterContext<P, Self> = ReactBeforeContext<P, Self> & {
+	/** What the component rendered, after earlier patches. */
+	result: React$1.ReactNode;
+};
+/**
+ * A `before` callback, which can replace a function component's props by returning new ones.
+ * @template P The component's props.
+ * @template Self The class instance rendering, or `undefined` for a function component.
+ */
+export type ReactBeforeCallback<P, Self> = (ctx: ReactBeforeContext<P, Self>) => P | void;
+/**
+ * The context a `patcher.react` callback receives.
+ * @template P The component's props.
+ * @template Self The class instance rendering, or `undefined` for a function component.
+ */
+export type ReactBeforeContext<P, Self> = {
+	/** The props of this render. */
+	props: P;
+	/** The class instance rendering, or `undefined` for a function component. */
+	this: Self;
+	/** Renders the unpatched component; a class component ignores `props`. */
+	original: (props?: P) => React$1.ReactNode;
+};
+/** The callback a React patch of `Kind` takes, typed with the component's props and `this`. */
+export type ReactCallbackOf<Kind extends PatchType, P, Self> = Kind extends PatchType.Before
+	? ReactBeforeCallback<P, Self>
+	: Kind extends PatchType.Instead
+		? ReactInsteadCallback<P, Self>
+		: ReactAfterCallback<P, Self>;
+/**
+ * An `instead` callback, whose return value is rendered in place of the component.
+ * @template P The component's props.
+ * @template Self The class instance rendering, or `undefined` for a function component.
+ */
+export type ReactInsteadCallback<P, Self> = (
+	ctx: ReactInsteadContext<P, Self>,
+) => React$1.ReactNode;
+/**
+ * The context an `instead` callback of `patcher.react` receives.
+ * @template P The component's props.
+ * @template Self The class instance rendering, or `undefined` for a function component.
+ */
+export type ReactInsteadContext<P, Self> = ReactBeforeContext<P, Self>;
+/** One `patcher.react` hook: takes a `memo`, `forwardRef` or class component, or the object and key holding any component. */
+export type ReactPatch<Kind extends PatchType> = {
+	<C extends ReactPatchTarget>(
+		component: C,
+		callback: ReactCallbackOf<Kind, ReactPropsOf<C>, ReactSelfOf<C>>,
+		options?: PatchOptions,
+	): () => void;
+	<M extends PatchParent, K extends Extract<keyof M, string>>(
+		parent: M,
+		key: K,
+		callback: ReactCallbackOf<Kind, ReactPropsOf<M[K]>, ReactSelfOf<M[K]>>,
+		options?: PatchOptions,
+	): () => void;
+};
+/** A component `patcher.react` finds the render of by itself: a `memo`, a `forwardRef` or a class. */
+export type ReactPatchTarget =
+	| React$1.JSXElementConstructor<never>
+	| {
+			$$typeof: symbol;
+	  };
+/** The `patcher.react` namespace: `before`, `instead` and `after` for React components. */
+export type ReactPatcher = {
+	/** Runs a callback before a component renders; it can return new props for a function component. */
+	before: ReactPatch<PatchType.Before>;
+	/** Renders a callback's return value in place of a component; `ctx.original()` renders the component. */
+	instead: ReactPatch<PatchType.Instead>;
+	/** Runs a callback after a component renders; its return value replaces the tree unless it is `undefined`. */
+	after: ReactPatch<PatchType.After>;
+};
+/** The props component `C` renders with. */
+export type ReactPropsOf<C> =
+	IsUntyped<C> extends true
+		? C
+		: C extends React$1.JSXElementConstructor<infer P>
+			? P
+			: C extends {
+						type: infer Inner;
+				  }
+				? ReactPropsOf<Inner>
+				: C extends {
+							render: (props: infer P, ...rest: never[]) => React$1.ReactNode;
+					  }
+					? P
+					: never;
+/** The `this` component `C` renders with: a class component's instance, else `undefined`. */
+export type ReactSelfOf<C> =
+	IsUntyped<C> extends true
+		? C
+		: C extends abstract new (...args: never[]) => infer Instance
+			? Instance
+			: C extends {
+						type: infer Inner;
+				  }
+				? ReactSelfOf<Inner>
+				: undefined;
+/** The result a patch receives for method `F`: its return value, or an instance for a class. */
+export type ResultOf<F> =
+	IsUntyped<F> extends true
+		? F
+		: F extends AnyFunction
+			? ReturnType<F>
+			: F extends AnyConstructor
+				? InstanceType<F>
+				: never;
+/** The `this` a patch receives: the method's declared `this`, else the object `M` holding it. */
+export type SelfOf<M, F> = unknown extends ThisParameterType<F> ? M : ThisParameterType<F>;
 
-export { after$1 as after, before$1 as before, instead$1 as instead };
+export { PatchType$1 as PatchType };
 
 export {};

package/src/plugins.d.ts

@@ -0,0 +1,55 @@
+// Auto-generated by generate-plugin-sdk.ts - DO NOT EDIT
+
+import type { AddonHandle, PushedManifest } from './_internal';
+/** Stops a running plugin without changing its enabled state. */
+declare const stop$1: (id: string) => void | Promise<void>;
+/** Disables a plugin and stops it. */
+export declare const disable: (id: string) => void;
+/** Enables a plugin and starts it. */
+export declare const enable: (id: string) => void | Promise<void>;
+/** Every installed plugin, keyed by id. */
+export declare const entities: ReadonlyMap<PropertyKey, AddonHandle>;
+/** The error each plugin that failed to load or start threw, keyed by id. */
+export declare const errors: ReadonlyMap<PropertyKey, Error>;
+/** Reads one installed plugin by id. */
+export declare const get: (id: string) => AddonHandle | undefined;
+/** Lists every installed plugin. */
+export declare const getAll: () => AddonHandle[];
+/** Installs a plugin from its manifest URL. */
+export declare const install: (url: string, digest?: string) => Promise<AddonHandle | undefined>;
+/** Reports whether a plugin is enabled. */
+export declare const isEnabled: (id: string) => boolean;
+/** Swaps a plugin's bundle in place, keeping its enabled state. */
+export declare const reload: (
+	id: string,
+	bundle: string,
+	manifest: PushedManifest,
+	bytecode?: string,
+) => Promise<ReloadResult>;
+/** Starts a plugin without changing its enabled state. */
+export declare const start: (id: string) => void | Promise<void>;
+/** How long each plugin's last start took, in milliseconds, keyed by id. */
+export declare const startDurations: ReadonlyMap<string, number>;
+/** Enables a disabled plugin, or disables an enabled one. */
+export declare const toggle: (id: string) => void;
+/** Stops and removes an installed plugin. */
+export declare const uninstall: (id: string) => Promise<void>;
+/**
+ * @description Checks for updates, then applies this plugin's pending update.
+ * @param id The plugin's id.
+ * @returns Whether the plugin now runs a newer version.
+ */
+export declare function update(id: string): Promise<boolean>;
+/** The outcome of an addon reload: success, or failure carrying the recorded error. */
+export type ReloadResult =
+	| {
+			ok: true;
+	  }
+	| {
+			ok: false;
+			error: Error;
+	  };
+
+export { stop$1 as stop };
+
+export {};

package/src/settings.d.ts

@@ -2,29 +2,21 @@
 
 export type { SettingsEntry } from './_internal';
 import type { SettingsEntry } from './_internal';
-import * as ReactModule from 'react';
-import { ComponentType } from 'react';
-
-declare const _default: {
-	registerSettings: typeof registerSettings;
-	removeSettings: typeof removeSettings;
-	sections: typeof sections;
-};
+import * as React$1 from 'react';
+import { ComponentType, ReactNode } from 'react';
+/**
+ * @description Returns the current registry of settings entries.
+ * @returns A record of entry key to its {@link SettingsEntry}.
+ */
+export declare function getSections(): Record<string, SettingsEntry>;
 /**
  * @description Registers one or more settings entries into the section registry, warning on key collisions.
  * @param entries The settings entries to register.
  */
-export declare function registerSettings(...entries: SettingsEntry[]): void;
+export declare function registerSection(...entries: SettingsEntry[]): void;
 /**
  * @description Removes one or more settings entries from the section registry by key.
  * @param keys The entry keys to remove.
  */
-export declare function removeSettings(...keys: string[]): void;
-/**
- * @description Returns the current registry of settings entries.
- * @returns A record of entry key to its {@link SettingsEntry}.
- */
-export declare function sections(): Record<string, SettingsEntry>;
-export { _default as default };
-
+export declare function removeSection(...keys: string[]): void;
 export {};