@voltro/plugin-flags 0.86.0 → 0.87.0

package/dist/config.d.ts

@@ -0,0 +1,250 @@
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+/** `TypedFlag` with the value type erased — what the plugin and the registry
+ *  hold. Sound because `TypedFlag` is covariant in `A` (see the annotation). */
+declare type AnyTypedFlag = TypedFlag<unknown>;
+
+/** Capture a whole untrusted SQL override before evaluator callbacks run. */
+export declare const captureConfigFlag: (entry: ConfigEntry<unknown>, input: FlagValue) => FlagDefinition;
+
+/** Config is bounded JSON. No Dates, bytes, accessors, prototypes or cycles. */
+export declare const captureConfigValue: (input: unknown) => unknown;
+
+export declare const captureDefinedConfig: (input: DefinedConfig) => DefinedConfig;
+
+export declare const configData: (input: unknown, keys: readonly string[]) => Readonly<Record<string, unknown>>;
+
+export declare interface ConfigEntry<out A> {
+    readonly key: string;
+    readonly flag: TypedFlag<A>;
+    readonly public: boolean;
+    readonly restartRequired: 'room' | 'live';
+    readonly min: number | null;
+    readonly max: number | null;
+}
+
+/** Typed Config failures contain no private value, subject or decode body. */
+declare class ConfigError extends ConfigError_base {
+}
+
+export declare const configError: (code: ConfigError["code"]) => ConfigError;
+
+declare const ConfigError_base: Schema.Class<ConfigError, Schema.TaggedStruct<"ConfigError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_value", "not_found", "unavailable"]>;
+}>, YieldableError>;
+
+export declare const configKey: (input: unknown) => string;
+
+export declare interface ConfigKeySummary {
+    readonly key: string;
+    readonly valueType: string;
+    readonly public: boolean;
+    readonly restartRequired: 'room' | 'live';
+    readonly min: number | null;
+    readonly max: number | null;
+}
+
+export declare interface ConfigSpec<S extends Schema.Top> {
+    readonly schema: S;
+    readonly default: NoInfer<Schema.Schema.Type<S>>;
+    readonly min?: number;
+    readonly max?: number;
+    readonly public?: boolean;
+    readonly restartRequired?: 'room' | 'live';
+    readonly variants?: DefineFlagSpec<S>['variants'];
+    readonly targeting?: readonly FlagTargetingRule[];
+    readonly rollout?: number;
+    readonly rolloutBy?: 'subject' | 'tenant';
+    readonly schedule?: FlagSchedule;
+}
+
+export declare const configSummary: (config: DefinedConfig) => readonly ConfigKeySummary[];
+
+export declare const defineConfig: <const Schemas extends Readonly<Record<string, Schema.Top>>>(input: { readonly [Key in keyof Schemas]: ConfigSpec<Schemas[Key]>; }) => DefinedConfig<{ readonly [Key in keyof Schemas]: Schema.Schema.Type<Schemas[Key]>; }>;
+
+export declare interface DefinedConfig<Values extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>> {
+    readonly entries: {
+        readonly [Key in keyof Values]: ConfigEntry<Values[Key]>;
+    };
+    readonly keys: readonly (keyof Values & string)[];
+    readonly typedFlags: readonly AnyTypedFlag[];
+}
+
+declare interface DefineFlagSpec<S extends Schema.Top> {
+    /** The flag key — `dotted.camelCase`, matching the `flags: { … }` record. */
+    readonly key: string;
+    /** The value Schema. Everything else in this spec is checked against it. */
+    readonly value: S;
+    /**
+     * The value served when the flag does not resolve to a variant.
+     *
+     * A wrong value here is a COMPILE ERROR. `NoInfer` is one of three reasons
+     * why and, measured, the redundant one — see the header for the other two and
+     * for why it is kept anyway.
+     */
+    readonly default: NoInfer<Schema.Schema.Type<S>>;
+    /** The value arms, each checked against the Schema. */
+    readonly variants?: ReadonlyArray<TypedFlagVariant<NoInfer<Schema.Schema.Type<S>>>>;
+    /** Variant name treated as the "off" state for boolean resolution. */
+    readonly offVariant?: string;
+    /** Master switch. `false` ⇒ off for everyone. Default true. */
+    readonly enabled?: boolean;
+    /** Percentage rollout 0..100. Omit ⇒ 100. */
+    readonly rollout?: number;
+    /** OR-of-rules targeting. */
+    readonly targeting?: ReadonlyArray<FlagTargetingRule>;
+    /** Bucket on the tenant id instead of the subject id. */
+    readonly rolloutBy?: 'subject' | 'tenant';
+    /** Time-boxed / ramping schedule. */
+    readonly schedule?: FlagSchedule;
+    /** Surfaced in the dashboard. */
+    readonly description?: string;
+    /** IN-11 — the `defineExperiment` name this flag's arms report uplift for. */
+    readonly experiment?: string;
+}
+
+/** The result of decoding an UNTRUSTED value (a DB override, a dashboard edit)
+ *  against a flag's Schema. Deliberately not an exception: the caller's correct
+ *  response is to keep the code-declared value and say so, not to unwind. */
+declare type FlagDecodeResult<A> = {
+    readonly ok: true;
+    readonly value: A;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+
+declare interface FlagDefinition {
+    /** Master switch. `false` → off for everyone regardless of rollout/targeting. Default true. */
+    readonly enabled?: boolean;
+    /** Percentage rollout 0..100 — deterministic per (key, subject/tenant) so a
+     *  caller stays in/out consistently. Omit = 100 (everyone the targeting allows). */
+    readonly rollout?: number;
+    /** OR-of-rules targeting. When present, the caller must match at least one
+     *  rule (in addition to passing the rollout). Omit = everyone. */
+    readonly targeting?: ReadonlyArray<FlagTargetingRule>;
+    /** Bucket on the tenant id instead of the subject id (rollout by tenant). */
+    readonly rolloutBy?: 'subject' | 'tenant';
+    /** Multivariate flag — a set of named variants the flag resolves ONE of per
+     *  subject, deterministically weighted (see `FlagVariant.weight`). A subject
+     *  stays in the same variant across calls. When present, `variant.evaluate`
+     *  serves the resolved variant; the boolean resolution is `enabled && variant
+     *  is served` (the flag is "on" for the caller unless a variant named in
+     *  `offVariant` is served — omit ⇒ any served variant counts as on). */
+    readonly variants?: ReadonlyArray<FlagVariant>;
+    /** Variant name treated as the "off" state for boolean resolution. Omit ⇒
+     *  passing targeting+rollout with any served variant counts as on. */
+    readonly offVariant?: string;
+    /** Time-boxed / ramping schedule, evaluated against the current time. */
+    readonly schedule?: FlagSchedule;
+    /** Surfaced in the dashboard / `flags.evaluate`. */
+    readonly description?: string;
+}
+
+/** A time-boxed / ramping schedule. Evaluated against the current time.
+ *  Order: outside [activateAt, deactivateAt) ⇒ off; a `ramp` interpolates the
+ *  effective rollout % linearly across its window. */
+declare interface FlagSchedule {
+    /** Flag is off before this instant (epoch millis or ISO string). Omit ⇒ no lower bound. */
+    readonly activateAt?: number | string;
+    /** Flag is off at/after this instant (epoch millis or ISO string). Omit ⇒ no upper bound. */
+    readonly deactivateAt?: number | string;
+    /** A ramping rollout: exposure grows linearly from `from`% to `to`% across
+     *  [`startAt`, `endAt`). Before `startAt` ⇒ `from`%, after `endAt` ⇒ `to`%.
+     *  The interpolated % REPLACES the flag's static `rollout` while active. */
+    readonly ramp?: {
+        readonly from: number;
+        readonly to: number;
+        readonly startAt: number | string;
+        readonly endAt: number | string;
+    };
+}
+
+/** One targeting rule — ANDs its conditions; a flag's `targeting` is an OR of rules. */
+declare interface FlagTargetingRule {
+    /** Match specific subject ids. */
+    readonly subjectIds?: ReadonlyArray<string>;
+    /** Match specific tenant ids. */
+    readonly tenantIds?: ReadonlyArray<string>;
+    /** Match `subject.type` (user / apiKey / serviceAccount / anonymous). */
+    readonly subjectTypes?: ReadonlyArray<string>;
+    /** Match `subject.metadata[key] === value` for every entry. */
+    readonly metadata?: Record<string, string>;
+}
+
+/** A flag value as authored: bare boolean (kill-switch) OR a rich definition. */
+declare type FlagValue = boolean | FlagDefinition;
+
+/** One multivariate variant: a named value with an optional rollout weight. */
+declare interface FlagVariant {
+    /** Stable variant name (the resolution returns this). */
+    readonly name: string;
+    /** The value served for this variant (string / number / boolean / JSON). */
+    readonly value: FlagVariantValue;
+    /** Relative allocation weight. Omit ⇒ equal split of the remaining weight.
+     *  Weights are normalised, so `[3, 1]` is 75% / 25%. */
+    readonly weight?: number;
+}
+
+/** A concrete variant value — string / number / boolean / JSON. Kept browser-safe. */
+declare type FlagVariantValue = string | number | boolean | null | ReadonlyArray<unknown> | Record<string, unknown>;
+
+/**
+ * A flag with a value type.
+ *
+ * `out A` is load-bearing rather than decorative: the plugin holds these in one
+ * `ReadonlyArray<TypedFlag<unknown>>`, which is only sound while every member
+ * that mentions `A` is a read position. If you add a field that CONSUMES an `A`
+ * (a `(value: A) => …` callback, say), that annotation is what will stop you —
+ * and the fix is to erase it behind a function returning a result, the way
+ * `decode` already does, not to drop the annotation.
+ */
+declare interface TypedFlag<out A> {
+    /** Brand — lets the plugin discriminate a typed flag from a bare `FlagValue`. */
+    readonly _voltroTypedFlag: true;
+    /** The flag key. Shares the flag namespace with `flags: { … }` entries; a
+     *  duplicate is refused at plugin construction. */
+    readonly key: string;
+    /** Human label of the value Schema (`number`, `"a" | "b"`, …) — for the
+     *  dashboard panel and for the refusal message when an override fails to
+     *  decode. Derived from the Schema's AST, so it cannot drift from it. */
+    readonly valueType: string;
+    /** The value served whenever the flag does not resolve to a variant: it is
+     *  off for this caller, or it declares no variants at all. Compile-checked
+     *  against the Schema. */
+    readonly defaultValue: A;
+    /** The value arms. Empty ⇒ the flag always serves `defaultValue` (which the
+     *  lifecycle report classifies as `constantOn`/`constantOff` — a flag that
+     *  cannot serve anything else is one to delete). */
+    readonly variants: ReadonlyArray<TypedFlagVariant<A>>;
+    /** Decode an untrusted value against the flag's Schema — the runtime half of
+     *  the contract `default` gets at compile time. */
+    readonly decode: (input: unknown) => FlagDecodeResult<A>;
+    /** The evaluator-facing definition. This is what goes into the registry the
+     *  existing `evaluateFlag` / `resolveVariant` already read; nothing about
+     *  evaluation changes because a flag is typed. */
+    readonly definition: FlagDefinition;
+    /**
+     * IN-11 — the `defineExperiment` this flag's variants report uplift for.
+     *
+     * A NAME rather than the definition object, on purpose: `defineExperiment`
+     * lives in `@voltro/runtime`, which is server-only, and this module has to
+     * stay loadable in a browser bundle. The link is validated at BOOT, where
+     * both sides are known (`assertFlagExperimentLinkage`) — a flag naming an
+     * experiment that does not exist, or whose arms disagree with the flag's,
+     * refuses to start rather than reporting uplift for arms nobody is served.
+     */
+    readonly experiment?: string;
+}
+
+/** One named arm of a typed flag. `value` is checked against the flag's Schema
+ *  at COMPILE time. Weights behave exactly as `FlagVariant.weight`. */
+declare interface TypedFlagVariant<out A> {
+    readonly name: string;
+    readonly value: A;
+    /** Relative allocation weight. Omit ⇒ equal split. */
+    readonly weight?: number;
+}
+
+export { }

package/dist/config.js

@@ -0,0 +1,235 @@
+import { ConfigError as e } from "./errors.js";
+import { defineFlag as t } from "./define.js";
+import { Schema as n } from "effect";
+//#region src/config.ts
+var r = (t) => new e({ code: t }), i = /* @__PURE__ */ new WeakSet(), a = (e) => {
+	if (!e || typeof e != "object" || !i.has(e)) throw r("invalid_input");
+	return e;
+}, o = /^[A-Za-z][A-Za-z0-9._-]{0,119}$/, s = (e) => {
+	if (typeof e != "string" || !o.test(e)) throw r("invalid_input");
+	return e;
+}, c = (e, t) => {
+	if (!e || typeof e != "object" || Array.isArray(e) || ![null, Object.prototype].includes(Object.getPrototypeOf(e))) throw r("invalid_input");
+	let n = Object.create(null);
+	for (let i of Reflect.ownKeys(e)) {
+		let a = Object.getOwnPropertyDescriptor(e, i);
+		if (typeof i != "string" || !t.includes(i) || !a?.enumerable || !("value" in a)) throw r("invalid_input");
+		n[i] = a.value;
+	}
+	return Object.freeze(n);
+}, l = (e) => {
+	let t = 0, n = /* @__PURE__ */ new Set(), i = (e, a) => {
+		if (++t > 4096 || a > 16) throw r("invalid_value");
+		if (e === null || typeof e == "boolean" || typeof e == "number" && Number.isFinite(e)) return e;
+		if (typeof e == "string") {
+			if (e.length > 16384) throw r("invalid_value");
+			return e;
+		}
+		if (!e || typeof e != "object" || n.has(e)) throw r("invalid_value");
+		n.add(e);
+		try {
+			if (Array.isArray(e)) {
+				if (e.length > 1024 || Reflect.ownKeys(e).length !== e.length + 1) throw r("invalid_value");
+				let t = [];
+				for (let n = 0; n < e.length; n++) {
+					let o = Object.getOwnPropertyDescriptor(e, String(n));
+					if (!o || !("value" in o) || !o.enumerable) throw r("invalid_value");
+					t.push(i(o.value, a + 1));
+				}
+				return Object.freeze(t);
+			}
+			let t = Reflect.ownKeys(e);
+			if (t.length > 256 || t.some((e) => typeof e != "string" || e.length > 120)) throw r("invalid_value");
+			let n = c(e, t), o = Object.create(null);
+			for (let [e, t] of Object.entries(n)) o[e] = i(t, a + 1);
+			return Object.freeze(o);
+		} finally {
+			n.delete(e);
+		}
+	}, a = i(e, 0);
+	if (new TextEncoder().encode(JSON.stringify(a)).byteLength > 16384) throw r("invalid_value");
+	return a;
+}, u = (e) => {
+	if (typeof e != "number" || !Number.isFinite(e) || e < 0 || e > 100) throw r("invalid_input");
+	return e;
+}, d = (e) => {
+	let t = typeof e == "string" ? Date.parse(e) : e;
+	if (typeof t != "number" || !Number.isSafeInteger(t) || t < 0 || t > 864e13) throw r("invalid_input");
+	return t;
+}, f = (e) => {
+	let t = c(l(e), [
+		"activateAt",
+		"deactivateAt",
+		"ramp"
+	]), n = t.activateAt === void 0 ? void 0 : d(t.activateAt), i = t.deactivateAt === void 0 ? void 0 : d(t.deactivateAt);
+	if (n !== void 0 && i !== void 0 && i <= n) throw r("invalid_input");
+	let a;
+	if (t.ramp !== void 0) {
+		let e = c(t.ramp, [
+			"from",
+			"to",
+			"startAt",
+			"endAt"
+		]), n = d(e.startAt), i = d(e.endAt);
+		if (i <= n) throw r("invalid_input");
+		a = Object.freeze({
+			from: u(e.from),
+			to: u(e.to),
+			startAt: n,
+			endAt: i
+		});
+	}
+	return Object.freeze({
+		...n === void 0 ? {} : { activateAt: n },
+		...i === void 0 ? {} : { deactivateAt: i },
+		...a === void 0 ? {} : { ramp: a }
+	});
+}, p = (e) => {
+	let t = l(e);
+	if (!Array.isArray(t) || t.length > 32) throw r("invalid_input");
+	return Object.freeze(t.map((e) => {
+		let t = c(e, [
+			"subjectIds",
+			"tenantIds",
+			"subjectTypes",
+			"metadata"
+		]);
+		for (let e of [
+			"subjectIds",
+			"tenantIds",
+			"subjectTypes"
+		]) if (t[e] !== void 0 && (!Array.isArray(t[e]) || t[e].length < 1 || !t[e].every((e) => typeof e == "string" && e.length > 0 && e.length <= 120))) throw r("invalid_input");
+		if (t.metadata !== void 0 && (!t.metadata || typeof t.metadata != "object" || Array.isArray(t.metadata) || !Object.values(t.metadata).every((e) => typeof e == "string"))) throw r("invalid_input");
+		return t;
+	}));
+}, m = (e) => {
+	if (!e || typeof e != "object") throw r("invalid_input");
+	let a = Reflect.ownKeys(e);
+	if (a.length < 1 || a.length > 128 || a.some((e) => typeof e != "string")) throw r("invalid_input");
+	let o = c(e, a), u = Object.create(null);
+	for (let [e, i] of Object.entries(o)) {
+		s(e);
+		let a = c(i, [
+			"schema",
+			"default",
+			"min",
+			"max",
+			"public",
+			"restartRequired",
+			"variants",
+			"targeting",
+			"rollout",
+			"rolloutBy",
+			"schedule"
+		]);
+		if (!n.isSchema(a.schema) || a.public !== void 0 && typeof a.public != "boolean" || a.restartRequired !== void 0 && a.restartRequired !== "room" && a.restartRequired !== "live" || a.rolloutBy !== void 0 && a.rolloutBy !== "tenant" && a.rolloutBy !== "subject") throw r("invalid_input");
+		for (let e of ["min", "max"]) if (a[e] !== void 0 && (typeof a[e] != "number" || !Number.isFinite(a[e]))) throw r("invalid_input");
+		let o = a.min === void 0 ? null : a.min, d = a.max === void 0 ? null : a.max;
+		if (o !== null && (typeof o != "number" || !Number.isFinite(o)) || d !== null && (typeof d != "number" || !Number.isFinite(d)) || typeof o == "number" && typeof d == "number" && o > d) throw r("invalid_input");
+		let m = a.schema.pipe(n.check(n.makeFilter((e) => o === null && d === null || typeof e == "number" && Number.isFinite(e) && (o === null || e >= o) && (d === null || e <= d)))), h = l(a.default), g = l(a.variants ?? [{
+			name: "configured",
+			value: h
+		}]);
+		if (!Array.isArray(g) || g.length < 1 || g.length > 32) throw r("invalid_input");
+		let _;
+		try {
+			_ = t({
+				key: e,
+				value: m,
+				default: h,
+				variants: g,
+				...a.targeting === void 0 ? {} : { targeting: p(a.targeting) },
+				...a.rollout === void 0 ? {} : { rollout: a.rollout },
+				...a.rolloutBy === void 0 ? {} : { rolloutBy: a.rolloutBy },
+				...a.schedule === void 0 ? {} : { schedule: f(a.schedule) }
+			});
+		} catch {
+			throw r("invalid_value");
+		}
+		let v = _.decode;
+		_ = Object.freeze({
+			..._,
+			definition: l(_.definition),
+			decode: (e) => {
+				try {
+					let t = v(l(e));
+					return t.ok ? {
+						ok: !0,
+						value: l(t.value)
+					} : {
+						ok: !1,
+						reason: "Value does not satisfy the bounded Config contract"
+					};
+				} catch {
+					return {
+						ok: !1,
+						reason: "Value does not satisfy the bounded Config contract"
+					};
+				}
+			}
+		}), u[e] = Object.freeze({
+			key: e,
+			flag: _,
+			public: a.public ?? !1,
+			restartRequired: a.restartRequired ?? "room",
+			min: o,
+			max: d
+		});
+	}
+	let d = Object.freeze({
+		entries: Object.freeze(u),
+		keys: Object.freeze(Object.keys(u)),
+		typedFlags: Object.freeze(Object.values(u).map((e) => e.flag))
+	});
+	return i.add(d), d;
+}, h = (e, t) => {
+	let n = c(typeof t == "boolean" ? { enabled: t } : t, [
+		"enabled",
+		"rollout",
+		"rolloutBy",
+		"variants",
+		"offVariant",
+		"targeting",
+		"schedule",
+		"description"
+	]);
+	if (n.enabled !== void 0 && typeof n.enabled != "boolean" || n.rolloutBy !== void 0 && n.rolloutBy !== "subject" && n.rolloutBy !== "tenant" || n.description !== void 0 && (typeof n.description != "string" || n.description.length > 1024)) throw r("invalid_value");
+	let i = l(n.variants ?? []);
+	if (!Array.isArray(i) || i.length > 32) throw r("invalid_value");
+	let a = /* @__PURE__ */ new Set(), o = i.map((t) => {
+		let n = c(t, [
+			"name",
+			"value",
+			"weight"
+		]), i = s(n.name), o = e.flag.decode(n.value);
+		if (!o.ok || a.has(i) || n.weight !== void 0 && (typeof n.weight != "number" || !Number.isFinite(n.weight) || n.weight <= 0)) throw r("invalid_value");
+		return a.add(i), Object.freeze({
+			name: i,
+			value: l(o.value),
+			...n.weight === void 0 ? {} : { weight: n.weight }
+		});
+	});
+	if (n.offVariant !== void 0 && (typeof n.offVariant != "string" || !a.has(n.offVariant))) throw r("invalid_value");
+	return Object.freeze({
+		...n.enabled === void 0 ? {} : { enabled: n.enabled },
+		...n.rollout === void 0 ? {} : { rollout: u(n.rollout) },
+		...n.rolloutBy === void 0 ? {} : { rolloutBy: n.rolloutBy },
+		variants: Object.freeze(o),
+		...n.offVariant === void 0 ? {} : { offVariant: n.offVariant },
+		...n.targeting === void 0 ? {} : { targeting: p(n.targeting) },
+		...n.schedule === void 0 ? {} : { schedule: f(n.schedule) },
+		...n.description === void 0 ? {} : { description: n.description }
+	});
+}, g = (e) => Object.freeze(e.keys.map((t) => {
+	let n = e.entries[t];
+	return Object.freeze({
+		key: t,
+		valueType: n.flag.valueType,
+		public: n.public,
+		restartRequired: n.restartRequired,
+		min: n.min,
+		max: n.max
+	});
+}));
+//#endregion
+export { h as captureConfigFlag, l as captureConfigValue, a as captureDefinedConfig, c as configData, r as configError, s as configKey, g as configSummary, m as defineConfig };

package/dist/errors.d.ts

@@ -1,6 +1,14 @@
 import { Schema } from 'effect';
 import { YieldableError } from 'effect/Cause';
 
+/** Typed Config failures contain no private value, subject or decode body. */
+export declare class ConfigError extends ConfigError_base {
+}
+
+declare const ConfigError_base: Schema.Class<ConfigError, Schema.TaggedStruct<"ConfigError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_value", "not_found", "unavailable"]>;
+}>, YieldableError>;
+
 /** Raised when a flag-gated call hits a disabled flag. Merged into every
  *  procedure's wire-error union so the client decodes it typed. */
 export declare class FlagDisabled extends FlagDisabled_base {
@@ -10,4 +18,14 @@ declare const FlagDisabled_base: Schema.Class<FlagDisabled, Schema.TaggedStruct<
     readonly flag: Schema.String;
 }>, YieldableError>;
 
+/** A refused kill-switch flip: unknown key, a typed Config value (it has its own writer),
+ *  a store that is not bound yet, or a write whose commit could not be confirmed. */
+export declare class FlagToggleRefused extends FlagToggleRefused_base {
+}
+
+declare const FlagToggleRefused_base: Schema.Class<FlagToggleRefused, Schema.TaggedStruct<"FlagToggleRefused", {
+    readonly key: Schema.String;
+    readonly reason: Schema.Literals<readonly ["unknown_flag", "config_value", "not_ready", "unconfirmed"]>;
+}>, YieldableError>;
+
 export { }

package/dist/errors.js

@@ -1,5 +1,18 @@
 import { Schema as e } from "effect";
 //#region src/errors.ts
-var t = class extends e.TaggedError()("FlagDisabled", { flag: e.String }) {};
+var t = class extends e.TaggedError()("FlagDisabled", { flag: e.String }) {}, n = class extends e.TaggedError()("FlagToggleRefused", {
+	key: e.String,
+	reason: e.Literals([
+		"unknown_flag",
+		"config_value",
+		"not_ready",
+		"unconfirmed"
+	])
+}) {}, r = class extends e.TaggedError()("ConfigError", { code: e.Literals([
+	"invalid_input",
+	"invalid_value",
+	"not_found",
+	"unavailable"
+]) }) {};
 //#endregion
-export { t as FlagDisabled };
+export { r as ConfigError, t as FlagDisabled, n as FlagToggleRefused };