@hot-updater/plugin-remote-config 0.0.0-stage → 1.0.0-rc.42

package/LICENSE

@@ -0,0 +1,33 @@
+MIT License
+
+Copyright (c) 2023 Sungyu Kang 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+ADDITIONAL DISCLAIMER
+
+The authors of this software shall not be held responsible for any legal issues,
+regulatory violations, policy violations, or disputes arising from the use,
+distribution, or integration of this software.
+
+Users are solely responsible for ensuring compliance with all applicable laws,
+regulations, and third-party policies (including but not limited to app store
+policies).

package/README.md

@@ -1,4 +1,24 @@
-# Temporary Holding Version
+# @hot-updater/plugin-remote-config
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
-If no other versions are published within 30 days, this package and version will be deleted.
+Hot Updater's Remote Config plugin. The server plugin stores versioned
+templates of parameters and conditions, and answers each device with the
+values its conditions pick; the client plugin fetches those values in the app
+and reads them synchronously, over in-app defaults.
+
+You don't install it on its own. `@hot-updater/server` and
+`@hot-updater/react-native` depend on it and re-export it:
+
+```ts
+// The server definition
+import { remoteConfig } from "@hot-updater/server/plugins/remote-config";
+
+// The app
+import { HotUpdater, remoteConfig } from "@hot-updater/react-native";
+```
+
+| Entry      | Re-exported as                                                          |
+| ---------- | ----------------------------------------------------------------------- |
+| `./server` | `@hot-updater/server/plugins/remote-config`                             |
+| `./client` | `remoteConfig` and its types from the `@hot-updater/react-native` root |
+
+See [Remote Config](https://hot-updater.dev/docs/guides/remote-config).

package/client/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@hot-updater/plugin-remote-config/client",
+  "private": true,
+  "main": "../dist/client/index.cjs",
+  "module": "../dist/client/index.mjs",
+  "types": "../dist/client/index.d.cts"
+}

package/dist/client/index.cjs

@@ -0,0 +1,208 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_ownEntry = require("../shared/ownEntry.cjs");
+const require_wire = require("../shared/wire.cjs");
+let _hot_updater_protocol = require("@hot-updater/protocol");
+//#region src/client/index.ts
+const DEFAULT_MINIMUM_FETCH_INTERVAL_MS = 432e5;
+const BOOLEAN_TRUTHY_VALUES = /* @__PURE__ */ new Set([
+	"1",
+	"true",
+	"t",
+	"yes",
+	"y",
+	"on"
+]);
+const FETCHED_KEY = "fetched";
+const ACTIVE_KEY = "active";
+const LAST_FETCH_STATUS_KEY = "lastFetchStatus";
+const createValue = (text, source) => Object.freeze({
+	asString: () => text,
+	asNumber: () => {
+		const number = Number(text);
+		return Number.isNaN(number) ? 0 : number;
+	},
+	asBoolean: () => BOOLEAN_TRUTHY_VALUES.has(text.toLowerCase()),
+	getSource: () => source
+});
+const parseStored = (text, extra) => {
+	if (text === null) return null;
+	try {
+		const value = JSON.parse(text);
+		if (typeof value !== "object" || value === null) return null;
+		const record = value;
+		if (require_wire.parseRemoteConfigFetchResponse(record) === null || record.etag !== null && typeof record.etag !== "string" || !extra(record)) return null;
+		return record;
+	} catch {
+		return null;
+	}
+};
+const isFetchStatus = (value) => value === "success" || value === "failure";
+const deviceContext = (context) => ({
+	platform: context.platform,
+	appVersion: context.appVersion,
+	channel: context.getChannel(),
+	cohort: context.getCohort(),
+	fingerprintHash: context.getFingerprintHash()
+});
+/**
+* Remote Config for the app: in-app defaults, values a server running the
+* `remoteConfig()` plugin picks for this device, and a fetch and activate
+* step between them. Add it to `HotUpdater.init`'s `plugins`, and read it
+* from the instance `init` returns, as `hotUpdater.remoteConfig`. It fetches
+* from the `baseURL`, request headers, and timeout configured there.
+*
+* @example
+* ```ts
+* import { HotUpdater, remoteConfig } from "@hot-updater/react-native";
+*
+* export const hotUpdater = HotUpdater.init({
+*   baseURL,
+*   plugins: [
+*     remoteConfig({ defaults: { welcome_message: "Welcome", max_items: 20 } }),
+*   ],
+* });
+*
+* hotUpdater.remoteConfig.fetchAndActivate().catch(() => {});
+* hotUpdater.remoteConfig.getString("welcome_message");
+* ```
+*/
+const remoteConfig = (options = {}) => {
+	const minimumFetchIntervalMs = options.minimumFetchIntervalMs ?? DEFAULT_MINIMUM_FETCH_INTERVAL_MS;
+	if (typeof minimumFetchIntervalMs !== "number" || !Number.isFinite(minimumFetchIntervalMs) || minimumFetchIntervalMs < 0) throw new TypeError("[HotUpdater] remoteConfig({ minimumFetchIntervalMs }) must be a non-negative number.");
+	const defaults = Object.fromEntries(Object.entries(options.defaults ?? {}).map(([key, value]) => [key, String(value)]));
+	return (0, _hot_updater_protocol.defineClientPlugin)({
+		id: "remoteConfig",
+		setup: (context) => ({ api: createRemoteConfigClient(context, {
+			defaults,
+			minimumFetchIntervalMs
+		}) })
+	});
+};
+/** The client a plugin's `setup` creates, over the values stored on the device. */
+const createRemoteConfigClient = (context, { defaults, minimumFetchIntervalMs }) => {
+	let active = parseStored(context.storage.get(ACTIVE_KEY), () => true);
+	let fetched = parseStored(context.storage.get(FETCHED_KEY), (record) => typeof record.context === "string" && typeof record.fetchedAtMs === "number");
+	const storedStatus = context.storage.get(LAST_FETCH_STATUS_KEY);
+	let lastFetchStatus = isFetchStatus(storedStatus) ? storedStatus : fetched === null ? "no-fetch-yet" : "success";
+	let inFlight = null;
+	let snapshot = null;
+	const listeners = /* @__PURE__ */ new Set();
+	const notify = () => {
+		snapshot = null;
+		for (const listener of listeners) try {
+			listener();
+		} catch (error) {
+			console.warn("[HotUpdater] A remoteConfig listener threw.", error);
+		}
+	};
+	const store = (key, value) => {
+		try {
+			context.storage.set(key, value);
+		} catch (error) {
+			console.warn(`[HotUpdater] remoteConfig could not store its ${key} values.`, error);
+		}
+	};
+	const setStatus = (status) => {
+		lastFetchStatus = status;
+		store(LAST_FETCH_STATUS_KEY, status);
+	};
+	const getValue = (key) => {
+		const remote = require_ownEntry.ownEntry(active?.values, key);
+		if (remote !== void 0) return createValue(remote, "remote");
+		const fallback = require_ownEntry.ownEntry(defaults, key);
+		return fallback === void 0 ? null : createValue(fallback, "default");
+	};
+	const fetchFromServer = async (device) => {
+		const contextKey = JSON.stringify(device);
+		let response;
+		try {
+			response = await context.fetch(require_wire.remoteConfigRequestPath(device), { headers: fetched === null || fetched.etag === null ? {} : { "if-none-match": fetched.etag } });
+		} catch (error) {
+			setStatus("failure");
+			throw new Error("[HotUpdater] Remote Config could not be fetched.", { cause: error });
+		}
+		const fetchedAtMs = context.now();
+		if (response.status === 304 && fetched !== null) {
+			fetched = {
+				...fetched,
+				context: contextKey,
+				fetchedAtMs
+			};
+			store(FETCHED_KEY, JSON.stringify(fetched));
+			setStatus("success");
+			return;
+		}
+		if (!response.ok) {
+			setStatus("failure");
+			throw new Error(response.status === 404 ? "[HotUpdater] The server answered 404 to GET /remote-config: it runs without the remoteConfig() plugin." : `[HotUpdater] Remote Config fetch failed with HTTP ${response.status}.`);
+		}
+		const body = require_wire.parseRemoteConfigFetchResponse(await response.json().catch(() => null));
+		if (body === null) {
+			setStatus("failure");
+			throw new Error("[HotUpdater] The server's GET /remote-config answer is not Remote Config values.");
+		}
+		fetched = {
+			version: body.version,
+			values: body.values,
+			etag: response.headers.get("etag"),
+			context: contextKey,
+			fetchedAtMs
+		};
+		store(FETCHED_KEY, JSON.stringify(fetched));
+		setStatus("success");
+	};
+	const fetchValues = (options) => {
+		const device = deviceContext(context);
+		if (options?.force !== true && inFlight === null && fetched !== null && fetched.context === JSON.stringify(device) && context.now() - fetched.fetchedAtMs < minimumFetchIntervalMs) return Promise.resolve();
+		inFlight ??= fetchFromServer(device).finally(() => {
+			inFlight = null;
+		});
+		return inFlight;
+	};
+	const activate = async () => {
+		if (fetched === null) return false;
+		const next = {
+			version: fetched.version,
+			values: fetched.values,
+			etag: fetched.etag
+		};
+		if (active !== null && active.version === next.version && JSON.stringify(active.values) === JSON.stringify(next.values)) return false;
+		active = next;
+		store(ACTIVE_KEY, JSON.stringify(active));
+		notify();
+		return true;
+	};
+	return Object.freeze({
+		getValue,
+		getString: (key) => getValue(key)?.asString() ?? null,
+		getNumber: (key) => getValue(key)?.asNumber() ?? null,
+		getBoolean: (key) => getValue(key)?.asBoolean() ?? null,
+		getAll: () => {
+			snapshot ??= Object.freeze(Object.fromEntries([.../* @__PURE__ */ new Set([...Object.keys(defaults), ...Object.keys(active?.values ?? {})])].map((key) => [key, getValue(key)])));
+			return snapshot;
+		},
+		fetch: (options) => fetchValues(options),
+		activate,
+		fetchAndActivate: async (options) => {
+			await fetchValues(options);
+			return activate();
+		},
+		get lastFetchStatus() {
+			return lastFetchStatus;
+		},
+		get fetchedAtMs() {
+			return fetched?.fetchedAtMs ?? null;
+		},
+		get activeVersion() {
+			return active?.version ?? 0;
+		},
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	});
+};
+//#endregion
+exports.remoteConfig = remoteConfig;

package/dist/client/index.d.cts

@@ -0,0 +1,123 @@
+import { HotUpdaterClientPlugin } from "@hot-updater/protocol";
+//#region src/client/index.d.ts
+/** An in-app default value: text, a number, or a boolean. */
+type RemoteConfigDefaultValue = string | number | boolean;
+type RemoteConfigDefaults = Readonly<Record<string, RemoteConfigDefaultValue>>;
+/**
+ * Where a value comes from: `remote` from the activated values, `default`
+ * from the in-app defaults. A key neither has reads as `null`.
+ */
+type RemoteConfigValueSource = "default" | "remote";
+/** How the last fetch ended: `failure` for any error, a `429` included. */
+type RemoteConfigFetchStatus = "no-fetch-yet" | "success" | "failure";
+/** A parameter's value, read as the type the app expects. */
+interface RemoteConfigValue {
+  /** The text, `""` included. */
+  asString(): string;
+  /** The text as a number, `0` included; 0 for text that is not a number. */
+  asNumber(): number;
+  /** Whether the text is `1`, `true`, `t`, `yes`, `y`, or `on`, in any case. */
+  asBoolean(): boolean;
+  getSource(): RemoteConfigValueSource;
+}
+/** No defaults: every key may read as `null`. */
+type NoDefaults = Record<never, never>;
+interface RemoteConfigOptions<TDefaults extends RemoteConfigDefaults = NoDefaults> {
+  /** Values the app uses until it activates fetched ones, and for keys the template leaves to it. */
+  readonly defaults?: TDefaults;
+  /**
+   * The shortest time between fetches that reach the server; a fetch
+   * sooner keeps the values fetched last. Defaults to 12 hours. A fetch
+   * always reaches the server after the app's channel, version, cohort, or
+   * fingerprint changes.
+   */
+  readonly minimumFetchIntervalMs?: number;
+}
+interface RemoteConfigFetchOptions {
+  /**
+   * Asks the server even within `minimumFetchIntervalMs`, for a moment that
+   * needs fresh values, such as pull to refresh. Each one is a request (a
+   * `304` when nothing changed).
+   */
+  readonly force?: boolean;
+}
+/** A defaults key, with any other key still accepted. */
+type RemoteConfigKey<TDefaults> = (keyof TDefaults & string) | (string & {});
+/**
+ * What a read of `TKey` returns: `T` for a key `defaults` declares, which
+ * always has a value, and `T | null` for any other key. Defaults typed as
+ * a map of any string, such as `RemoteConfigDefaults`, declare no key.
+ */
+type RemoteConfigRead<TDefaults, TKey extends string, T> = string extends keyof TDefaults ? T | null : TKey extends keyof TDefaults ? T : T | null;
+/**
+ * Remote Config on the instance `HotUpdater.init` returns, as
+ * `hotUpdater.remoteConfig`.
+ */
+interface RemoteConfigClient<TDefaults extends RemoteConfigDefaults = NoDefaults> {
+  /**
+   * A parameter's value: the active remote value, else the in-app default,
+   * else `null`. Reads are synchronous; `init` loads the values the app
+   * activated last from the device. `false`, `0`, and `""` are values, not
+   * missing ones.
+   */
+  getValue<TKey extends RemoteConfigKey<TDefaults>>(key: TKey): RemoteConfigRead<TDefaults, TKey, RemoteConfigValue>;
+  getString<TKey extends RemoteConfigKey<TDefaults>>(key: TKey): RemoteConfigRead<TDefaults, TKey, string>;
+  getNumber<TKey extends RemoteConfigKey<TDefaults>>(key: TKey): RemoteConfigRead<TDefaults, TKey, number>;
+  getBoolean<TKey extends RemoteConfigKey<TDefaults>>(key: TKey): RemoteConfigRead<TDefaults, TKey, boolean>;
+  /**
+   * Every key the defaults or the active values have. The object stays the
+   * same until the values change, so it suits `useSyncExternalStore`.
+   */
+  getAll(): Readonly<Record<string, RemoteConfigValue>>;
+  /**
+   * Fetches this device's values from `GET /remote-config` on the
+   * `baseURL` the app configured, with its request headers, and keeps them
+   * for `activate`; active values do not change. Within
+   * `minimumFetchIntervalMs` of the last successful fetch it keeps those
+   * values without a request, unless `force` is set. Rejects when the server
+   * cannot be reached or runs without the `remoteConfig()` plugin.
+   */
+  fetch(options?: RemoteConfigFetchOptions): Promise<void>;
+  /** Makes the fetched values active; true when they replaced other values. */
+  activate(): Promise<boolean>;
+  /**
+   * `fetch(options)`, then `activate()`, for an app that applies new values
+   * as soon as they arrive. Resolves as `activate` does; rejects as `fetch`
+   * does, and the active values stay.
+   */
+  fetchAndActivate(options?: RemoteConfigFetchOptions): Promise<boolean>;
+  readonly lastFetchStatus: RemoteConfigFetchStatus;
+  /** When the last successful fetch ended, in ms since the epoch; `null` before one. */
+  readonly fetchedAtMs: number | null;
+  /** The template version the active values come from; 0 before any. */
+  readonly activeVersion: number;
+  /** Calls `listener` whenever the active values change; returns the unsubscribe. */
+  subscribe(listener: () => void): () => void;
+}
+/** The `remoteConfig()` plugin: it adds `hotUpdater.remoteConfig`. */
+type RemoteConfigPlugin<TDefaults extends RemoteConfigDefaults = NoDefaults> = HotUpdaterClientPlugin<"remoteConfig", RemoteConfigClient<TDefaults>>;
+/**
+ * Remote Config for the app: in-app defaults, values a server running the
+ * `remoteConfig()` plugin picks for this device, and a fetch and activate
+ * step between them. Add it to `HotUpdater.init`'s `plugins`, and read it
+ * from the instance `init` returns, as `hotUpdater.remoteConfig`. It fetches
+ * from the `baseURL`, request headers, and timeout configured there.
+ *
+ * @example
+ * ```ts
+ * import { HotUpdater, remoteConfig } from "@hot-updater/react-native";
+ *
+ * export const hotUpdater = HotUpdater.init({
+ *   baseURL,
+ *   plugins: [
+ *     remoteConfig({ defaults: { welcome_message: "Welcome", max_items: 20 } }),
+ *   ],
+ * });
+ *
+ * hotUpdater.remoteConfig.fetchAndActivate().catch(() => {});
+ * hotUpdater.remoteConfig.getString("welcome_message");
+ * ```
+ */
+declare const remoteConfig: <const TDefaults extends RemoteConfigDefaults = NoDefaults>(options?: RemoteConfigOptions<TDefaults>) => RemoteConfigPlugin<TDefaults>;
+//#endregion
+export { RemoteConfigClient, RemoteConfigDefaultValue, RemoteConfigDefaults, RemoteConfigFetchOptions, RemoteConfigFetchStatus, RemoteConfigKey, RemoteConfigOptions, RemoteConfigPlugin, RemoteConfigRead, RemoteConfigValue, RemoteConfigValueSource, remoteConfig };

package/dist/client/index.d.mts

@@ -0,0 +1,123 @@
+import { HotUpdaterClientPlugin } from "@hot-updater/protocol";
+//#region src/client/index.d.ts
+/** An in-app default value: text, a number, or a boolean. */
+type RemoteConfigDefaultValue = string | number | boolean;
+type RemoteConfigDefaults = Readonly<Record<string, RemoteConfigDefaultValue>>;
+/**
+ * Where a value comes from: `remote` from the activated values, `default`
+ * from the in-app defaults. A key neither has reads as `null`.
+ */
+type RemoteConfigValueSource = "default" | "remote";
+/** How the last fetch ended: `failure` for any error, a `429` included. */
+type RemoteConfigFetchStatus = "no-fetch-yet" | "success" | "failure";
+/** A parameter's value, read as the type the app expects. */
+interface RemoteConfigValue {
+  /** The text, `""` included. */
+  asString(): string;
+  /** The text as a number, `0` included; 0 for text that is not a number. */
+  asNumber(): number;
+  /** Whether the text is `1`, `true`, `t`, `yes`, `y`, or `on`, in any case. */
+  asBoolean(): boolean;
+  getSource(): RemoteConfigValueSource;
+}
+/** No defaults: every key may read as `null`. */
+type NoDefaults = Record<never, never>;
+interface RemoteConfigOptions<TDefaults extends RemoteConfigDefaults = NoDefaults> {
+  /** Values the app uses until it activates fetched ones, and for keys the template leaves to it. */
+  readonly defaults?: TDefaults;
+  /**
+   * The shortest time between fetches that reach the server; a fetch
+   * sooner keeps the values fetched last. Defaults to 12 hours. A fetch
+   * always reaches the server after the app's channel, version, cohort, or
+   * fingerprint changes.
+   */
+  readonly minimumFetchIntervalMs?: number;
+}
+interface RemoteConfigFetchOptions {
+  /**
+   * Asks the server even within `minimumFetchIntervalMs`, for a moment that
+   * needs fresh values, such as pull to refresh. Each one is a request (a
+   * `304` when nothing changed).
+   */
+  readonly force?: boolean;
+}
+/** A defaults key, with any other key still accepted. */
+type RemoteConfigKey<TDefaults> = (keyof TDefaults & string) | (string & {});
+/**
+ * What a read of `TKey` returns: `T` for a key `defaults` declares, which
+ * always has a value, and `T | null` for any other key. Defaults typed as
+ * a map of any string, such as `RemoteConfigDefaults`, declare no key.
+ */
+type RemoteConfigRead<TDefaults, TKey extends string, T> = string extends keyof TDefaults ? T | null : TKey extends keyof TDefaults ? T : T | null;
+/**
+ * Remote Config on the instance `HotUpdater.init` returns, as
+ * `hotUpdater.remoteConfig`.
+ */
+interface RemoteConfigClient<TDefaults extends RemoteConfigDefaults = NoDefaults> {
+  /**
+   * A parameter's value: the active remote value, else the in-app default,
+   * else `null`. Reads are synchronous; `init` loads the values the app
+   * activated last from the device. `false`, `0`, and `""` are values, not
+   * missing ones.
+   */
+  getValue<TKey extends RemoteConfigKey<TDefaults>>(key: TKey): RemoteConfigRead<TDefaults, TKey, RemoteConfigValue>;
+  getString<TKey extends RemoteConfigKey<TDefaults>>(key: TKey): RemoteConfigRead<TDefaults, TKey, string>;
+  getNumber<TKey extends RemoteConfigKey<TDefaults>>(key: TKey): RemoteConfigRead<TDefaults, TKey, number>;
+  getBoolean<TKey extends RemoteConfigKey<TDefaults>>(key: TKey): RemoteConfigRead<TDefaults, TKey, boolean>;
+  /**
+   * Every key the defaults or the active values have. The object stays the
+   * same until the values change, so it suits `useSyncExternalStore`.
+   */
+  getAll(): Readonly<Record<string, RemoteConfigValue>>;
+  /**
+   * Fetches this device's values from `GET /remote-config` on the
+   * `baseURL` the app configured, with its request headers, and keeps them
+   * for `activate`; active values do not change. Within
+   * `minimumFetchIntervalMs` of the last successful fetch it keeps those
+   * values without a request, unless `force` is set. Rejects when the server
+   * cannot be reached or runs without the `remoteConfig()` plugin.
+   */
+  fetch(options?: RemoteConfigFetchOptions): Promise<void>;
+  /** Makes the fetched values active; true when they replaced other values. */
+  activate(): Promise<boolean>;
+  /**
+   * `fetch(options)`, then `activate()`, for an app that applies new values
+   * as soon as they arrive. Resolves as `activate` does; rejects as `fetch`
+   * does, and the active values stay.
+   */
+  fetchAndActivate(options?: RemoteConfigFetchOptions): Promise<boolean>;
+  readonly lastFetchStatus: RemoteConfigFetchStatus;
+  /** When the last successful fetch ended, in ms since the epoch; `null` before one. */
+  readonly fetchedAtMs: number | null;
+  /** The template version the active values come from; 0 before any. */
+  readonly activeVersion: number;
+  /** Calls `listener` whenever the active values change; returns the unsubscribe. */
+  subscribe(listener: () => void): () => void;
+}
+/** The `remoteConfig()` plugin: it adds `hotUpdater.remoteConfig`. */
+type RemoteConfigPlugin<TDefaults extends RemoteConfigDefaults = NoDefaults> = HotUpdaterClientPlugin<"remoteConfig", RemoteConfigClient<TDefaults>>;
+/**
+ * Remote Config for the app: in-app defaults, values a server running the
+ * `remoteConfig()` plugin picks for this device, and a fetch and activate
+ * step between them. Add it to `HotUpdater.init`'s `plugins`, and read it
+ * from the instance `init` returns, as `hotUpdater.remoteConfig`. It fetches
+ * from the `baseURL`, request headers, and timeout configured there.
+ *
+ * @example
+ * ```ts
+ * import { HotUpdater, remoteConfig } from "@hot-updater/react-native";
+ *
+ * export const hotUpdater = HotUpdater.init({
+ *   baseURL,
+ *   plugins: [
+ *     remoteConfig({ defaults: { welcome_message: "Welcome", max_items: 20 } }),
+ *   ],
+ * });
+ *
+ * hotUpdater.remoteConfig.fetchAndActivate().catch(() => {});
+ * hotUpdater.remoteConfig.getString("welcome_message");
+ * ```
+ */
+declare const remoteConfig: <const TDefaults extends RemoteConfigDefaults = NoDefaults>(options?: RemoteConfigOptions<TDefaults>) => RemoteConfigPlugin<TDefaults>;
+//#endregion
+export { RemoteConfigClient, RemoteConfigDefaultValue, RemoteConfigDefaults, RemoteConfigFetchOptions, RemoteConfigFetchStatus, RemoteConfigKey, RemoteConfigOptions, RemoteConfigPlugin, RemoteConfigRead, RemoteConfigValue, RemoteConfigValueSource, remoteConfig };