app-settings-js 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+All notable changes to this package are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] — 2026-09-12
+
+First release.
+
+### Added
+
+- `AppSettingsClient`, covering every route the API exposes: resolution,
+  setting definitions, values in all three layers, groups and membership,
+  roles, platforms, environments, and API keys.
+- `SettingsSnapshot`, an immutable view over a resolution with typed accessors
+  (`boolean`, `number`, `string`, `date`, `list`, `json`) and override helpers
+  (`isEnforced`, `visibleOverride`, `editable`).
+- `createSettingsStore`, a framework-agnostic reactive store exposing the
+  `subscribe` / `getSnapshot` / `getServerSnapshot` trio that React's
+  `useSyncExternalStore` consumes directly, with optimistic writes, rollback
+  on rejection, and server-rendered hydration through `initialData`.
+- Datetime helpers for the API's strict RFC 3339 rules: `toInstant`,
+  `localToInstant`, `parseInstant`, `toDateTimeLocal`, `isInstant`.
+- A single `AppSettingsError` carrying the server's `code`, `status` and
+  `requestId`, with `isNotFound` / `isForbidden` / `isConflict` guards.
+- Automatic retries with jittered exponential backoff on network errors, 5xx
+  and 429, honouring `Retry-After` and never retrying a `POST`.
+
+[Unreleased]: https://github.com/connordoman/app-settings/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/connordoman/app-settings/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Connor Doman
+
+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.

package/README.md

@@ -0,0 +1,335 @@
+# app-settings-js
+
+A TypeScript SDK for the [App Settings](../README.md) API.
+
+- **No dependencies.** Nothing but the platform's own `fetch`.
+- **Runs anywhere.** Browsers, Node 18+, Bun, Deno, and edge runtimes. ESM and CJS.
+- **React-ready, React-free.** No React import anywhere in this package. The
+  store exposes the `subscribe` / `getSnapshot` pair `useSyncExternalStore`
+  wants, so React is three lines away — and so are Vue, Svelte and Solid.
+
+```sh
+bun add app-settings-js   # or npm / pnpm / yarn
+```
+
+## Quick start
+
+```ts
+import { AppSettingsClient } from "app-settings-js";
+
+const client = new AppSettingsClient({
+  baseUrl: "https://settings.example.com",
+  apiKey: process.env.SETTINGS_API_KEY!,
+  environment: "production",
+});
+
+const settings = await client.resolveUser("alice");
+
+settings.boolean("dark_mode");          // false
+settings.number("page_size", 25);       // 25 if unset
+settings.string("theme");
+settings.date("digest_at");             // a Date
+settings.json<Limits>("rate_limits");
+```
+
+`resolveUser` returns a [`SettingsSnapshot`](#the-snapshot): every setting the
+user can see, already collapsed to one effective value each. That is the call a
+product backend makes, and usually the only one it needs.
+
+> **Where this runs.** The API key is a server credential. Settings are meant to
+> be read through your own backend, which authenticates the user first. Putting
+> a key in a browser bundle hands every visitor whatever that key can reach.
+> Front ends should call your server, and hydrate a store from what it returns —
+> see [Server rendering](#server-rendering).
+
+## The snapshot
+
+A snapshot is immutable, and its identity changes only when the data does, which
+is what lets a UI framework skip a re-render.
+
+```ts
+settings.has("dark_mode");          // is it visible to this role at all?
+settings.isSet("dark_mode");        // did any layer, or the default, supply a value?
+settings.source("dark_mode");       // "PERSONAL" | "SERVER" | "DEFAULT" | ...
+settings.get("dark_mode");          // the whole ResolvedSetting
+settings.toObject();                // { dark_mode: false, page_size: 25, ... }
+
+for (const setting of settings) { /* iterable, in the server's order */ }
+```
+
+Typed accessors return the fallback when a setting is unset or invisible to the
+role, and **throw** when the setting exists but holds another type — which can
+only mean the wrong name was asked for:
+
+```ts
+settings.string("dark_mode");
+// AppSettingsError: setting "dark_mode" is declared BOOLEAN and holds a boolean, not a string
+```
+
+`list()` covers `SELECT`, returning a single choice as a one-element array so no
+caller has to branch on `multiple`:
+
+```ts
+settings.list<string>("tags");   // ["a", "b"]
+settings.options("tags");        // [["A", "a"], ["B", "b"]] for a picker
+```
+
+### Overrides
+
+A group override is either **advisory** (a group-wide default the user's own
+value beats) or **enforced** (a policy that beats it). Orthogonally, an override
+may be marked invisible, meaning the user is not meant to observe it.
+
+```ts
+settings.isEnforced("retention_days");     // disable the control
+settings.visibleOverride("retention_days"); // the override you may tell them about
+settings.override("retention_days");        // the raw one, visible or not
+settings.editable();                        // personal scope, not enforced
+```
+
+`visibleOverride` is the accessor a UI should reach for: it withholds an
+override the server marked `visible: false`, so a snapshot cannot leak one by
+accident.
+
+## The store
+
+`createSettingsStore` keeps one resolution current and tells subscribers when it
+changes. It handles the parts that are tedious to get right: no fetch until
+something is listening, one request shared between concurrent refreshes, stale
+responses dropped, and the last good snapshot kept when a refresh fails.
+
+```ts
+import { createSettingsStore } from "app-settings-js";
+
+const store = createSettingsStore(client, {
+  userId: "alice",
+  refreshIntervalMs: 60_000,
+  revalidateOnFocus: true,
+});
+
+store.subscribe(() => console.log(store.getSnapshot().snapshot?.toObject()));
+await store.set("dark_mode", true);   // optimistic, rolled back if rejected
+await store.clear("dark_mode");       // fall back to the layer beneath
+```
+
+`getSnapshot()` returns a `SettingsState`:
+
+| Field | Meaning |
+| --- | --- |
+| `status` | `idle` before the first load, then `loading`, `ready` or `error` |
+| `snapshot` | the current `SettingsSnapshot`, or `null` before the first one |
+| `error` | why the last load failed; cleared by a successful one |
+| `isValidating` | a request is in flight, including a background refresh |
+| `updatedAt` | when the current snapshot arrived |
+
+`refresh()` never rejects — the failure lands in `error` — so a caller needs no
+`try`/`catch`. `set()` and `clear()` do reject, because a rejected write is
+something the caller has to react to.
+
+### React
+
+There is no React module here, and there does not need to be one. Paste this
+into your app:
+
+```tsx
+import { useSyncExternalStore } from "react";
+import { createSettingsStore, type SettingsStore } from "app-settings-js";
+
+const store = createSettingsStore(client, { userId: currentUserId });
+
+function useSettings(store: SettingsStore) {
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot);
+}
+
+function DarkModeToggle() {
+  const { snapshot, status } = useSettings(store);
+  if (!snapshot) return status === "error" ? <Failed /> : <Spinner />;
+
+  return (
+    <label>
+      <input
+        type="checkbox"
+        checked={snapshot.boolean("dark_mode")}
+        disabled={snapshot.isEnforced("dark_mode")}
+        onChange={(event) => store.set("dark_mode", event.target.checked)}
+      />
+      Dark mode
+      {snapshot.visibleOverride("dark_mode") && <Badge>Set by your team</Badge>}
+    </label>
+  );
+}
+```
+
+`getSnapshot` returns the same object until something actually changes, which is
+exactly the contract `useSyncExternalStore` enforces, and `getServerSnapshot`
+makes the store safe to render on a server.
+
+The same two functions adapt anywhere: Svelte's `readable`, Vue's
+`shallowRef` plus `onScopeDispose`, or a Solid signal.
+
+### Server rendering
+
+Resolve on the server, serialise the response into the page, and hand it to the
+store so the first render already has data and no request is made:
+
+```ts
+// server
+const settings = await client.resolveUser(userId);
+return { props: { settings: settings.toJSON() } };
+
+// client
+const store = createSettingsStore(client, { userId, initialData: props.settings });
+```
+
+## Writing values
+
+Each layer has its own namespace, mirroring the API's routes:
+
+```ts
+await client.values.server.set(settingId, true);
+await client.values.personal.set(settingId, "alice", "solarized");
+await client.values.group.set(settingId, groupId, false, {
+  enforced: true,   // beats the user's own value
+  visible: false,   // the user is not meant to observe it
+});
+
+await client.values.personal.clear(settingId, "alice");
+```
+
+`undefined` is refused before a request is made — clearing a value is `clear()`,
+which is a `DELETE`. `null` goes through, because it is a legitimate JSON value.
+
+## Definitions, groups, taxonomy and keys
+
+```ts
+await client.settings.list({ scope: "PERSONAL" });
+await client.settings.create({
+  name: "page_size",
+  type: "NUMBER",
+  scope: "PERSONAL",
+  platform: "web",
+  typeConfig: { min: 10, max: 100, integer: true },
+  defaultValue: 25,
+});
+await client.settings.delete(id, { cascade: true });   // required if values exist
+
+await client.groups.create({ name: "beta", members: ["alice"], priority: 10 });
+await client.groups.addMembers(groupId, ["bob"]);
+
+await client.taxonomy.roles();
+await client.taxonomy.upsertRole("auditor", { rank: 25 });
+
+const minted = await client.keys.create({ name: "web backend", scopes: ["resolve"] });
+minted.token;   // the only time it is ever available
+```
+
+## Datetimes
+
+`DATETIME` accepts only a strict RFC 3339 value with an offset, because an
+offset is what makes a value an instant rather than a wall-clock reading. A
+`Date` satisfies that automatically; `<input type="datetime-local">` does not.
+
+```ts
+import { localToInstant, parseInstant, toDateTimeLocal, toInstant } from "app-settings-js";
+
+toInstant(new Date());                              // "2026-01-02T20:04:05.250Z"
+toInstant("2026-01-02T15:04:05-05:00");             // "2026-01-02T20:04:05.000Z"
+toInstant("2026-01-02T15:04");                      // throws, naming the problem
+
+localToInstant("2026-01-02T15:04", "America/New_York");  // "2026-01-02T20:04:00.000Z"
+toDateTimeLocal(value, "America/New_York");              // back into the input
+parseInstant(settings.value("digest_at"));               // a Date
+```
+
+Passing the timezone to `localToInstant` is the point: the same reading is a
+different moment in every zone, so the SDK makes you say which one rather than
+guessing. `store.set()` converts a `Date` for you.
+
+## Errors
+
+Everything throws one class. Branch on `code`, which is stable, not on the
+message, which is written for a human.
+
+```ts
+import { AppSettingsError, isNotFound, isForbidden } from "app-settings-js";
+
+try {
+  await client.settings.get(id);
+} catch (error) {
+  if (isNotFound(error)) return null;
+  if (isForbidden(error)) throw new Error("this key is fenced out of that environment");
+  if (AppSettingsError.is(error)) {
+    error.code;       // "not_found" | "forbidden" | "network_error" | "timeout" | ...
+    error.status;     // 404
+    error.requestId;  // the server's X-Request-ID, worth quoting in a bug report
+    error.retryable;
+  }
+  throw error;
+}
+```
+
+A key fenced out of an environment gets `not_found` rather than `forbidden` for
+a setting inside it — the server declines to reveal that it exists.
+
+Failed requests are retried automatically on network errors, 5xx and 429, with
+exponential backoff and jitter, honouring `Retry-After`. `POST` is never
+retried, being the only non-idempotent method in the API. Tune it per client:
+
+```ts
+new AppSettingsClient({ baseUrl, apiKey, retries: 5, retryDelayMs: 100, timeoutMs: 5_000 });
+```
+
+Every call also takes `{ signal, timeoutMs, headers }` for a one-off override.
+
+## Testing against it
+
+The client takes any `fetch`, so tests need no network and no mocking library:
+
+```ts
+const client = new AppSettingsClient({
+  baseUrl: "https://settings.test",
+  apiKey: "as_test",
+  environment: "test",
+  fetch: async () => new Response(JSON.stringify(fixture), { status: 200 }),
+});
+```
+
+## Requirements
+
+Any runtime with a global `fetch`: **Node 18+**, Bun, Deno, or a browser. Pass
+your own `fetch` for anything older. TypeScript is optional; when used, the
+declarations are checked against **TypeScript 5.9 and 7.x**.
+
+## Development
+
+```sh
+just            # list every recipe
+just check      # typecheck + test
+just build      # ESM, CJS and declarations into dist/
+just test       # bun test
+```
+
+From the repository root, `just sdk <recipe>` reaches these, and `just
+check-all` runs the server's checks and the SDK's together.
+
+### Releasing
+
+```sh
+just version 0.2.0   # bump, then write the CHANGELOG entry
+just preflight       # tests, build, and the packaging checks below
+just publish         # bun publish; prepublishOnly re-runs the gate
+```
+
+`just verify` runs [`@arethetypeswrong/cli`](https://arethetypeswrong.github.io)
+and [`publint`](https://publint.dev) against the real tarball, which is what
+catches the two failure modes this package is shaped around:
+
+- **The `require` path needs its own declarations.** `package.json` is
+  `type: module`, so a lone `index.d.ts` describes the CommonJS build as ESM.
+  The build emits a `.d.cts` beside every `.d.ts` and the `exports` map points
+  each condition at the matching one.
+- **`sideEffects` is deliberately absent.** Bun 1.4.0's bundler tree-shakes
+  every module out of a pure re-export barrel when that field is present,
+  emitting `export { … }` with nothing bound — valid-looking output, a zero
+  exit code, and a package that throws `SyntaxError` on import. `bun run build`
+  asserts the bundle contains an implementation so this cannot ship again.

package/dist/client.d.cts

@@ -0,0 +1,221 @@
+import { type FetchLike, type RequestOptions, type TransportOptions } from "./http.cjs";
+import { SettingsSnapshot } from "./snapshot.cjs";
+import type { ApiKey, CreatedApiKey, Environment, Group, GroupMember, Health, IntermediateValue, PersonalValue, Platform, Role, Scope, ServerValue, Setting, SettingScope, SettingType, SettingValue, TypeConfig, WhoAmI } from "./types.cjs";
+/** How to reach the server, and what to assume when a call does not say. */
+export interface ClientOptions extends TransportOptions {
+    /**
+     * The environment used by calls that require one. Resolution always needs an
+     * environment, so setting it here means most calls take no options at all.
+     */
+    environment?: string;
+    /** The platform filter applied to resolution and to setting lookups. */
+    platform?: string | string[];
+}
+/** Options shared by both resolution calls. */
+export interface ResolveOptions extends RequestOptions {
+    /** Overrides the client's environment. Required if the client has none. */
+    environment?: string;
+    /** Restricts the resolution to these platforms. Capped by the key's own fence. */
+    platform?: string | string[];
+    /** Resolves as this role instead of the key's. It may not outrank the key. */
+    role?: string;
+}
+/** Resolution for one user. */
+export interface ResolveUserOptions extends ResolveOptions {
+    /**
+     * Groups to apply without storing membership, which is how an ad-hoc group
+     * is used. Saved memberships apply regardless.
+     */
+    groupId?: string | string[];
+}
+/** Filters for listing setting definitions. */
+export interface ListSettingsOptions extends RequestOptions {
+    environment?: string;
+    platform?: string;
+    scope?: SettingScope;
+}
+/** A new setting definition. Type, scope, platform and environment are fixed at creation. */
+export interface CreateSettingInput {
+    name: string;
+    type: SettingType;
+    scope: SettingScope;
+    platform: string;
+    /** Defaults to the client's environment. */
+    environment?: string;
+    description?: string;
+    /** The rules for this type. See {@link TypeConfig}. */
+    typeConfig?: TypeConfig;
+    /** Defaults to the calling key's own role. */
+    role?: string;
+    /** Used when no layer supplies a value. */
+    defaultValue?: SettingValue;
+}
+/** The parts of a definition that are safe to change after creation. */
+export interface UpdateSettingInput {
+    description?: string;
+    typeConfig?: TypeConfig;
+    role?: string;
+    defaultValue?: SettingValue;
+}
+/** Options for writing a group override. */
+export interface GroupValueOptions extends RequestOptions {
+    /** Whether the user is meant to observe the override. Defaults to true. */
+    visible?: boolean;
+    /** Whether the override beats the user's own value. Defaults to false. */
+    enforced?: boolean;
+}
+/** A new group. */
+export interface CreateGroupInput {
+    name: string;
+    description?: string;
+    /** Omit to span every environment, which a fenced key may not do. */
+    environment?: string | null;
+    /** Higher priority wins when two groups override the same setting. */
+    priority?: number;
+    /** Marks an ad-hoc group so operators can prune it later. */
+    ephemeral?: boolean;
+    /** Seeds membership in the same request. */
+    members?: string[];
+}
+/** A new API key. It can never reach further than the key that mints it. */
+export interface CreateKeyInput {
+    name: string;
+    scopes: Scope[];
+    /** Empty inherits the creating key's fence rather than granting everything. */
+    environments?: string[];
+    platforms?: string[];
+    /** Defaults to the lowest-ranked role. May not outrank the creating key. */
+    role?: string;
+    /** Supply at most one of these. */
+    expiresAt?: Date | string;
+    /** A Go duration such as `"720h"`. */
+    expiresIn?: string;
+}
+/**
+ * A client for the App Settings API.
+ *
+ * One instance is cheap and holds no connection state, so it is safe to build
+ * once at module scope and share it.
+ *
+ * @example
+ * const client = new AppSettingsClient({
+ *   baseUrl: "https://settings.example.com",
+ *   apiKey: process.env.SETTINGS_API_KEY!,
+ *   environment: "production",
+ * });
+ *
+ * const settings = await client.resolveUser("alice");
+ * if (settings.boolean("dark_mode")) { ... }
+ */
+export declare class AppSettingsClient {
+    #private;
+    constructor(options: ClientOptions);
+    /** The environment this client defaults to, if it has one. */
+    get environment(): string | undefined;
+    /** A copy of this client bound to a different environment. */
+    withEnvironment(environment: string): AppSettingsClient;
+    /**
+     * Every setting a user can see, collapsed to one effective value each.
+     *
+     * This is the call a product backend makes. Precedence, lowest to highest, is
+     * `default < server < advisory group < personal < enforced group`.
+     */
+    resolveUser(userId: string, options?: ResolveUserOptions): Promise<SettingsSnapshot>;
+    /** The server's own settings, with no user layer applied. */
+    resolveServer(options?: ResolveOptions): Promise<SettingsSnapshot>;
+    /** Describes the calling key, so a deployment can confirm what it can do. */
+    whoami(options?: RequestOptions): Promise<WhoAmI>;
+    /** Whether the process is up. Needs no API key on the server, but sends one. */
+    health(options?: RequestOptions): Promise<Health>;
+    /** Whether the server's dependencies are reachable. */
+    ready(options?: RequestOptions): Promise<Health>;
+    readonly settings: {
+        /** Every definition this key may see, narrowed by the given filters. */
+        list: (options?: ListSettingsOptions) => Promise<Setting[]>;
+        /** One definition by id. */
+        get: (id: string, options?: RequestOptions) => Promise<Setting>;
+        /** Defines a new setting. */
+        create: (input: CreateSettingInput, options?: RequestOptions) => Promise<Setting>;
+        /** Changes a definition. Omitted fields are left as they are. */
+        update: (id: string, input: UpdateSettingInput, options?: RequestOptions) => Promise<Setting>;
+        /**
+         * Removes a definition.
+         *
+         * A delete that would destroy stored values is refused with a `conflict`
+         * naming how many, unless `cascade` says to go ahead.
+         */
+        delete: (id: string, options?: RequestOptions & {
+            cascade?: boolean;
+        }) => Promise<void>;
+    };
+    readonly values: {
+        /** The server-wide layer, beneath every group and user value. */
+        server: {
+            get: (settingId: string, options?: RequestOptions) => Promise<ServerValue>;
+            set: (settingId: string, value: SettingValue, options?: RequestOptions) => Promise<ServerValue>;
+            /** Removes the value, falling back to the definition's default. */
+            clear: (settingId: string, options?: RequestOptions) => Promise<void>;
+        };
+        /** One user's own choice. */
+        personal: {
+            get: (settingId: string, userId: string, options?: RequestOptions) => Promise<PersonalValue>;
+            set: (settingId: string, userId: string, value: SettingValue, options?: RequestOptions) => Promise<PersonalValue>;
+            clear: (settingId: string, userId: string, options?: RequestOptions) => Promise<void>;
+        };
+        /** A group override, in either direction. */
+        group: {
+            get: (settingId: string, groupId: string, options?: RequestOptions) => Promise<IntermediateValue>;
+            /**
+             * Writes an override. `enforced` decides its direction: an enforced
+             * override beats the user's own value, an advisory one yields to it.
+             */
+            set: (settingId: string, groupId: string, value: SettingValue, options?: GroupValueOptions) => Promise<IntermediateValue>;
+            clear: (settingId: string, groupId: string, options?: RequestOptions) => Promise<void>;
+        };
+    };
+    readonly groups: {
+        list: (options?: RequestOptions & {
+            environment?: string;
+            includeEphemeral?: boolean;
+        }) => Promise<Group[]>;
+        get: (id: string, options?: RequestOptions) => Promise<Group>;
+        create: (input: CreateGroupInput, options?: RequestOptions) => Promise<Group>;
+        update: (id: string, input: {
+            description?: string;
+            priority?: number;
+        }, options?: RequestOptions) => Promise<Group>;
+        delete: (id: string, options?: RequestOptions) => Promise<void>;
+        /** Everyone whose membership is saved. Ad-hoc application does not appear here. */
+        members: (id: string, options?: RequestOptions) => Promise<GroupMember[]>;
+        addMembers: (id: string, userIds: string[], options?: RequestOptions) => Promise<number>;
+        removeMembers: (id: string, userIds: string[], options?: RequestOptions) => Promise<number>;
+    };
+    readonly taxonomy: {
+        roles: (options?: RequestOptions) => Promise<Role[]>;
+        /** Creates or updates a role. Rank orders roles and may not exceed the key's. */
+        upsertRole: (name: string, input: {
+            rank: number;
+            description?: string;
+        }, options?: RequestOptions) => Promise<Role>;
+        deleteRole: (name: string, options?: RequestOptions) => Promise<void>;
+        platforms: (options?: RequestOptions) => Promise<Platform[]>;
+        upsertPlatform: (name: string, description?: string, options?: RequestOptions) => Promise<Platform>;
+        deletePlatform: (name: string, options?: RequestOptions) => Promise<void>;
+        environments: (options?: RequestOptions) => Promise<Environment[]>;
+        upsertEnvironment: (name: string, description?: string, options?: RequestOptions) => Promise<Environment>;
+        deleteEnvironment: (name: string, options?: RequestOptions) => Promise<void>;
+    };
+    readonly keys: {
+        list: (options?: RequestOptions & {
+            includeRevoked?: boolean;
+        }) => Promise<ApiKey[]>;
+        /**
+         * Mints a key. The returned `token` is the only time it is ever available:
+         * only its hash is stored.
+         */
+        create: (input: CreateKeyInput, options?: RequestOptions) => Promise<CreatedApiKey>;
+        /** Revokes a key. This is permanent and takes effect immediately. */
+        revoke: (id: string, options?: RequestOptions) => Promise<void>;
+    };
+}
+export type { FetchLike, RequestOptions };