@smplkit/sdk 1.9.6 → 1.10.0

package/dist/index.d.ts

@@ -73,86 +73,39 @@ declare class SharedWebSocket {
 }
 
 /**
- * Config resource — active-record model with save() pattern.
+ * LiveConfigProxy — live, dict-like, read-only configuration access.
  */
 
 /**
- * A configuration resource managed by the smplkit platform.
+ * A live, dict-like, read-only view of resolved config values.
  *
- * Management: mutate properties directly and call `save()` to persist.
- * Creates if new, updates if existing.
- */
-declare class Config {
-    /** Unique identifier (slug, e.g. `"user-service"`). */
-    id: string | null;
-    /** Display name. */
-    name: string;
-    /** Optional description. */
-    description: string | null;
-    /** Parent config id (slug), or null if this is a root config. */
-    parent: string | null;
-    /** Base key-value pairs. */
-    items: Record<string, unknown>;
-    /**
-     * Per-environment overrides.
-     * Structured as `{ env_name: { values: { key: value } } }`.
-     */
-    environments: Record<string, unknown>;
-    /** When the config was created, or null if unavailable. */
-    createdAt: string | null;
-    /** When the config was last updated, or null if unavailable. */
-    updatedAt: string | null;
-    /** @internal */
-    readonly _client: ConfigClient;
-    /** @internal */
-    constructor(client: ConfigClient, fields: {
-        id: string | null;
-        name: string;
-        description: string | null;
-        parent: string | null;
-        items: Record<string, unknown>;
-        environments: Record<string, unknown>;
-        createdAt: string | null;
-        updatedAt: string | null;
-    });
-    /**
-     * Persist this config to the server.
-     *
-     * Creates if new, updates if existing.
-     * Updates this instance in-place with the server response.
-     */
-    save(): Promise<void>;
-    /**
-     * Walk the parent chain and return config data objects, child-to-root.
-     *
-     * @param configs - Optional pre-fetched list of configs to look up parents
-     *   by ID, avoiding extra network calls and the key-vs-UUID mismatch with
-     *   {@link ConfigClient.get}.
-     * @internal
-     */
-    _buildChain(configs?: Config[]): Promise<Array<{
-        id: string;
-        items: Record<string, unknown>;
-        environments: Record<string, unknown>;
-    }>>;
-    /** @internal — copy all fields from another Config instance. */
-    _apply(other: Config): void;
-    toString(): string;
-}
-
-/**
- * LiveConfigProxy — live configuration access.
- */
-
-/**
- * A live proxy whose properties always reflect the latest config values.
+ * Returned by {@link ConfigClient.get}. Always reflects the latest
+ * server-pushed state — every read sees current values.
+ *
+ * Attribute access returns the current resolved value for the given item
+ * key. If a *model* class was provided, the model is reconstructed from
+ * the latest values on each access (so attribute access type-checks
+ * against the model).
+ *
+ * Dict-like API: `proxy["key"]`, `key in proxy`, `Object.keys(proxy)`,
+ * `proxy.values()`, `proxy.items()`, `proxy.get(key, default)`,
+ * iteration via `for (const k in proxy)`.
+ *
+ * Read-only: `proxy.x = ...`, `delete proxy.x`, `proxy["k"] = ...` all throw.
+ *
+ * Note: customer config items whose names collide with proxy method names
+ * (`keys`, `values`, `items`, `get`, `onChange`) are shadowed for attribute
+ * access — use subscript (`proxy["values"]`) for those.
  *
  * @example
  * ```typescript
- * const proxy = await client.config.subscribe("user-service");
- * console.log(proxy.timeout);  // current value
- * // ... later, after a config change ...
- * console.log(proxy.timeout);  // updated value
+ * const cfg = await client.config.get("user-service");
+ * console.log(cfg.database.host);   // resolved value
+ * console.log(cfg["max_retries"]);  // subscript also works
+ * for (const key of Object.keys(cfg)) console.log(key);
+ *
+ * cfg.onChange((event) => console.log(event));
+ * cfg.onChange("max_retries", (event) => console.log("retries changed"));
  * ```
  */
 declare class LiveConfigProxy<T = Record<string, unknown>> {
@@ -165,127 +118,432 @@ declare class LiveConfigProxy<T = Record<string, unknown>> {
     constructor(client: ConfigClient, key: string, model?: new (data: any) => T);
     /** @internal */
     _currentValues(): Record<string, unknown>;
-}
-
-/** Describes a single config value change detected on refresh. */
-interface ConfigChangeEvent {
-    /** The config id that changed. */
-    configId: string;
-    /** The item key within the config that changed. */
-    itemKey: string;
-    /** The previous value (null if the key was absent). */
-    oldValue: unknown;
-    /** The updated value (null if the key was removed). */
-    newValue: unknown;
-    /** How the change was delivered. */
-    source: "websocket" | "manual";
-}
-/**
- * Management API for smplkit Config — CRUD operations on Config models.
- *
- * Access via `SmplClient.config.management`.
- */
-declare class ConfigManagement {
-    private readonly _client;
-    constructor(_client: ConfigClient);
-    /** Create an unsaved config. Call `.save()` to persist. */
-    new(id: string, options?: {
-        name?: string;
-        description?: string;
-        parent?: string;
-    }): Config;
-    /** Fetch a config by id. */
-    get(id: string): Promise<Config>;
-    /** List all configs. */
-    list(): Promise<Config[]>;
-    /** Delete a config by id. */
-    delete(id: string): Promise<void>;
-}
-/**
- * Client for the smplkit Config API.
- *
- * Obtained via `SmplClient.config`.
- */
-declare class ConfigClient {
-    /** @internal */
-    readonly _apiKey: string;
-    /** @internal */
-    readonly _baseUrl: string;
-    /** @internal */
-    private readonly _http;
-    /** @internal — returns the shared WebSocket for real-time updates. */
-    _getSharedWs?: () => SharedWebSocket;
-    /** @internal — set by SmplClient after construction. */
-    _parent: {
-        readonly _environment: string;
-        readonly _service: string | null;
-        readonly _metrics: MetricsReporter | null;
-    } | null;
-    /** Management API — CRUD operations on Config models. */
-    readonly management: ConfigManagement;
-    private _configCache;
-    private _initialized;
-    private _listeners;
-    /** @internal */
-    constructor(apiKey: string, timeout?: number, baseUrl?: string);
-    /** @internal */
-    _mgNew(id: string, options?: {
-        name?: string;
-        description?: string;
-        parent?: string;
-    }): Config;
-    /** @internal */
-    _mgList(): Promise<Config[]>;
-    /** @internal */
-    _mgDelete(id: string): Promise<void>;
-    /** @internal — POST a new config. */
-    _createConfig(config: Config): Promise<Config>;
-    /** @internal — PUT a config update. */
-    _updateConfig(config: Config): Promise<Config>;
-    /** @internal — fetch a config by id. */
-    _getById(id: string): Promise<Config>;
+    /** Dict method: list of resolved item keys. */
+    keys(): string[];
+    /** Dict method: list of resolved item values. */
+    values(): unknown[];
+    /** Dict method: list of `[key, value]` pairs. */
+    items(): Array<[string, unknown]>;
+    /** Dict method: get a value by key, returning `defaultValue` if absent. */
+    get<V = unknown>(key: string, defaultValue?: V): V | unknown;
     /**
-     * Get a config's resolved values for the current environment.
+     * Register a change listener scoped to this config.
      *
-     * Returns the resolved key-value pairs for the given config.
-     * Optionally pass a model class to map the resolved values.
-     */
-    get<T = Record<string, unknown>>(id: string, model?: new (data: any) => T): Promise<T>;
-    /**
-     * Subscribe to a config's values. Returns a proxy whose properties
-     * always reflect the latest resolved values.
+     * Three forms:
+     * - `proxy.onChange(callback)` — fires on any change to this config.
+     * - `proxy.onChange("itemKey", callback)` — fires only when `itemKey` changes.
      *
-     * Optionally pass a model class to map the resolved values.
+     * Equivalent to `client.config.onChange(this._key, ...)`; offered as
+     * sugar so callers who already have a live proxy can register listeners
+     * without re-stating the config id.
      */
-    subscribe<T = Record<string, unknown>>(id: string, model?: new (data: any) => T): Promise<LiveConfigProxy<T>>;
-    /**
-     * Register a change listener.
-     *
-     * - `onChange(callback)` — fires for any config change (global).
-     * - `onChange(configId, callback)` — fires for changes to a specific config.
-     * - `onChange(configId, itemKey, callback)` — fires for a specific item.
-     */
-    onChange(callbackOrConfigId: string | ((event: ConfigChangeEvent) => void), callbackOrItemKey?: string | ((event: ConfigChangeEvent) => void), callback?: (event: ConfigChangeEvent) => void): void;
-    /**
-     * Refresh all config values from the server.
-     * Fires change listeners for any values that changed.
-     */
-    refresh(): Promise<void>;
-    /** @internal */
-    private _ensureInitialized;
-    /** @internal — called by SmplClient for backward compat. */
-    _connectInternal(environment: string): Promise<void>;
-    /** @internal — get resolved config from cache. Used by LiveConfigProxy. */
-    _getCachedConfig(key: string): Record<string, unknown> | undefined;
-    private _handleConfigChanged;
-    private _handleConfigDeleted;
-    private _handleConfigsChanged;
-    /** Fetch a single config by key. Returns null if not found. @internal */
-    private _fetchSingleConfig;
-    /** Resolve a config's values for an environment (no parent chain). @internal */
-    private _resolveConfigValues;
-    /** @internal */
-    private _diffAndFire;
+    onChange(callback: (event: ConfigChangeEvent) => void): void;
+    onChange(itemKey: string, callback: (event: ConfigChangeEvent) => void): void;
+}
+
+interface components$1 {
+    schemas: {
+        /**
+         * Error
+         * @description Single JSON:API error object.
+         */
+        Error: {
+            /** Status */
+            status: string;
+            /** Title */
+            title: string;
+            /** Detail */
+            detail?: string | null;
+            /** Source */
+            source?: {
+                [key: string]: unknown;
+            } | null;
+        };
+        /**
+         * ErrorResponse
+         * @description JSON:API error response envelope.
+         */
+        ErrorResponse: {
+            /** Errors */
+            errors: components$1["schemas"]["Error"][];
+        };
+        /**
+         * LogGroup
+         * @example {
+         *       "created_at": "2026-04-01T10:00:00Z",
+         *       "environments": {
+         *         "production": {
+         *           "level": "ERROR"
+         *         }
+         *       },
+         *       "level": "WARN",
+         *       "name": "Database Loggers",
+         *       "updated_at": "2026-04-01T10:00:00Z"
+         *     }
+         */
+        LogGroup: {
+            /** Name */
+            name: string;
+            /** Level */
+            level?: string | null;
+            /** Parent Id */
+            parent_id?: string | null;
+            /** Environments */
+            environments?: {
+                [key: string]: unknown;
+            } | null;
+            /** Created At */
+            readonly created_at?: string | null;
+            /** Updated At */
+            readonly updated_at?: string | null;
+        };
+        /** LogGroupListResponse */
+        LogGroupListResponse: {
+            /** Data */
+            data: components$1["schemas"]["LogGroupResource"][];
+        };
+        /**
+         * LogGroupResource
+         * @example {
+         *       "attributes": {
+         *         "created_at": "2026-04-01T10:00:00Z",
+         *         "environments": {
+         *           "production": {
+         *             "level": "ERROR"
+         *           }
+         *         },
+         *         "level": "WARN",
+         *         "name": "Database Loggers",
+         *         "updated_at": "2026-04-01T10:00:00Z"
+         *       },
+         *       "id": "database-loggers",
+         *       "type": "log_group"
+         *     }
+         */
+        LogGroupResource: {
+            /** Id */
+            id?: string | null;
+            /**
+             * Type
+             * @constant
+             */
+            type: "log_group";
+            attributes: components$1["schemas"]["LogGroup"];
+        };
+        /** LogGroupResponse */
+        LogGroupResponse: {
+            data: components$1["schemas"]["LogGroupResource"];
+        };
+        /**
+         * Logger
+         * @example {
+         *       "created_at": "2026-04-01T10:00:00Z",
+         *       "environments": {
+         *         "production": {
+         *           "level": "WARN"
+         *         },
+         *         "staging": {
+         *           "level": "DEBUG"
+         *         }
+         *       },
+         *       "group": "database-loggers",
+         *       "level": "DEBUG",
+         *       "managed": true,
+         *       "name": "SQL Logger",
+         *       "updated_at": "2026-04-01T10:00:00Z"
+         *     }
+         */
+        Logger: {
+            /** Name */
+            name: string;
+            /** Level */
+            level?: string | null;
+            /** Group */
+            group?: string | null;
+            /** Managed */
+            managed?: boolean | null;
+            /** Sources */
+            readonly sources?: {
+                [key: string]: unknown;
+            }[] | null;
+            /** Environments */
+            environments?: {
+                [key: string]: unknown;
+            } | null;
+            /** Effective Levels */
+            readonly effective_levels?: {
+                [key: string]: unknown;
+            } | null;
+            /** Created At */
+            readonly created_at?: string | null;
+            /** Updated At */
+            readonly updated_at?: string | null;
+        };
+        /**
+         * LoggerBulkItem
+         * @example {
+         *       "environment": "production",
+         *       "id": "sqlalchemy.engine",
+         *       "level": "WARN",
+         *       "resolved_level": "WARN",
+         *       "service": "api-gateway"
+         *     }
+         */
+        LoggerBulkItem: {
+            /**
+             * Id
+             * @description Normalized logger name
+             */
+            id: string;
+            /**
+             * Level
+             * @description The explicitly-set level on this logger. Null if inherited.
+             */
+            level?: string | null;
+            /**
+             * Resolved Level
+             * @description The effective level after framework inheritance. Never null in compliant SDKs.
+             */
+            resolved_level?: string | null;
+            /**
+             * Service
+             * @description Service name that discovered this logger
+             */
+            service?: string | null;
+            /**
+             * Environment
+             * @description Environment where this logger was observed
+             */
+            environment?: string | null;
+        };
+        /**
+         * LoggerBulkRequest
+         * @example {
+         *       "loggers": [
+         *         {
+         *           "environment": "production",
+         *           "id": "sqlalchemy.engine",
+         *           "level": "WARN",
+         *           "service": "api-gateway"
+         *         },
+         *         {
+         *           "environment": "production",
+         *           "id": "stripe",
+         *           "level": "INFO",
+         *           "service": "api-gateway"
+         *         }
+         *       ]
+         *     }
+         */
+        LoggerBulkRequest: {
+            /** Loggers */
+            loggers: components$1["schemas"]["LoggerBulkItem"][];
+        };
+        /**
+         * LoggerBulkResponse
+         * @example {
+         *       "registered": 5
+         *     }
+         */
+        LoggerBulkResponse: {
+            /** Registered */
+            registered: number;
+        };
+        /** LoggerListResponse */
+        LoggerListResponse: {
+            /** Data */
+            data: components$1["schemas"]["LoggerResource"][];
+        };
+        /**
+         * LoggerResource
+         * @example {
+         *       "attributes": {
+         *         "created_at": "2026-04-01T10:00:00Z",
+         *         "environments": {
+         *           "production": {
+         *             "level": "WARN"
+         *           },
+         *           "staging": {
+         *             "level": "DEBUG"
+         *           }
+         *         },
+         *         "group": "database-loggers",
+         *         "level": "DEBUG",
+         *         "managed": true,
+         *         "name": "SQL Logger",
+         *         "updated_at": "2026-04-01T10:00:00Z"
+         *       },
+         *       "id": "com.example.sql",
+         *       "type": "logger"
+         *     }
+         */
+        LoggerResource: {
+            /** Id */
+            id?: string | null;
+            /**
+             * Type
+             * @constant
+             */
+            type: "logger";
+            attributes: components$1["schemas"]["Logger"];
+        };
+        /** LoggerResponse */
+        LoggerResponse: {
+            data: components$1["schemas"]["LoggerResource"];
+        };
+        /**
+         * LoggerSource
+         * @example {
+         *       "created_at": "2026-04-01T10:00:00Z",
+         *       "environment": "production",
+         *       "first_observed": "2026-04-01T10:00:00Z",
+         *       "last_seen": "2026-04-11T15:30:00Z",
+         *       "resolved_level": "WARN",
+         *       "service": "api-gateway",
+         *       "updated_at": "2026-04-11T15:30:00Z"
+         *     }
+         */
+        LoggerSource: {
+            /** Service */
+            readonly service?: string;
+            /** Environment */
+            readonly environment?: string;
+            /** Level */
+            readonly level?: string | null;
+            /** Resolved Level */
+            readonly resolved_level?: string;
+            /** First Observed */
+            readonly first_observed?: string | null;
+            /** Last Seen */
+            readonly last_seen?: string | null;
+            /** Created At */
+            readonly created_at?: string | null;
+            /** Updated At */
+            readonly updated_at?: string | null;
+        };
+        /** LoggerSourceListResponse */
+        LoggerSourceListResponse: {
+            /** Data */
+            data: components$1["schemas"]["LoggerSourceResource"][];
+        };
+        /**
+         * LoggerSourceResource
+         * @example {
+         *       "attributes": {
+         *         "created_at": "2026-04-01T10:00:00Z",
+         *         "environment": "production",
+         *         "first_observed": "2026-04-01T10:00:00Z",
+         *         "last_seen": "2026-04-11T15:30:00Z",
+         *         "resolved_level": "WARN",
+         *         "service": "api-gateway",
+         *         "updated_at": "2026-04-11T15:30:00Z"
+         *       },
+         *       "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+         *       "type": "logger_source"
+         *     }
+         */
+        LoggerSourceResource: {
+            /** Id */
+            id?: string | null;
+            /**
+             * Type
+             * @constant
+             */
+            type: "logger_source";
+            attributes: components$1["schemas"]["LoggerSource"];
+        };
+        /** ServiceAttributes */
+        ServiceAttributes: Record<string, never>;
+        /** ServiceListResponse */
+        ServiceListResponse: {
+            /** Data */
+            data: components$1["schemas"]["ServiceResource"][];
+        };
+        /**
+         * ServiceResource
+         * @example {
+         *       "attributes": {},
+         *       "id": "api-gateway",
+         *       "type": "service"
+         *     }
+         */
+        ServiceResource: {
+            /** Id */
+            id: string;
+            /**
+             * Type
+             * @constant
+             */
+            type: "service";
+            /** @default {} */
+            attributes: components$1["schemas"]["ServiceAttributes"];
+        };
+        /** UsageAttributes */
+        UsageAttributes: {
+            /** Limit Key */
+            limit_key: string;
+            /** Period */
+            period: string;
+            /** Value */
+            value: number;
+        };
+        /**
+         * UsageListResponse
+         * @example {
+         *       "data": [
+         *         {
+         *           "attributes": {
+         *             "limit_key": "logging.managed_loggers",
+         *             "period": "current",
+         *             "value": 8
+         *           },
+         *           "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+         *           "type": "usage"
+         *         },
+         *         {
+         *           "attributes": {
+         *             "limit_key": "logging.groups",
+         *             "period": "current",
+         *             "value": 2
+         *           },
+         *           "id": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
+         *           "type": "usage"
+         *         }
+         *       ]
+         *     }
+         */
+        UsageListResponse: {
+            /** Data */
+            data: components$1["schemas"]["UsageResource"][];
+        };
+        /**
+         * UsageResource
+         * @example {
+         *       "attributes": {
+         *         "limit_key": "logging.managed_loggers",
+         *         "period": "current",
+         *         "value": 8
+         *       },
+         *       "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+         *       "type": "usage"
+         *     }
+         */
+        UsageResource: {
+            /** Id */
+            id: string;
+            /**
+             * Type
+             * @constant
+             */
+            type: "usage";
+            attributes: components$1["schemas"]["UsageAttributes"];
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
 }
 
 interface components {
@@ -727,173 +985,493 @@ interface components {
 }
 
 /**
- * Public types for the Flags SDK: Context, Rule.
+ * Shared types for the management namespace.
+ */
+/** Whether an environment participates in the canonical ordering.
+ *
+ * STANDARD environments are the customer's deploy targets (production,
+ * staging, development, etc.) and appear in the environment_order list.
+ * AD_HOC environments are transient targets (preview branches,
+ * developer sandboxes) that are excluded from the standard ordering.
+ */
+declare enum EnvironmentClassification {
+    STANDARD = "STANDARD",
+    AD_HOC = "AD_HOC"
+}
+/**
+ * A color, expressed as a CSS hex string.
+ *
+ * Frozen — construct a fresh `Color` to change a value.
+ *
+ * @example
+ * ```typescript
+ * new Color("#ef4444")            // 6-digit hex
+ * new Color("#fff")               // 3-digit shorthand
+ * new Color("#ef4444aa")          // 8-digit with alpha
+ * Color.rgb(239, 68, 68)          // RGB components
+ * ```
+ */
+declare class Color {
+    /** The normalized lowercase hex string. */
+    readonly hex: string;
+    constructor(hex: string);
+    /** Construct a `Color` from 0–255 RGB components. */
+    static rgb(r: number, g: number, b: number): Color;
+    toString(): string;
+    /** Equality by hex value. */
+    equals(other: unknown): boolean;
+}
+
+/**
+ * Active-record models for management resources.
+ */
+
+/** @internal */
+interface EnvironmentModelClient {
+    _create(env: Environment): Promise<Environment>;
+    _update(env: Environment): Promise<Environment>;
+    delete(id: string): Promise<void>;
+}
+/** @internal */
+interface ContextTypeModelClient {
+    _create(ct: ContextType): Promise<ContextType>;
+    _update(ct: ContextType): Promise<ContextType>;
+    delete(id: string): Promise<void>;
+}
+/** @internal */
+interface AccountSettingsModelClient {
+    _save(data: Record<string, any>): Promise<AccountSettings>;
+}
+/**
+ * An environment resource managed by the smplkit platform.
+ *
+ * Mutate fields, then call {@link save} to create or update.
+ */
+declare class Environment {
+    /** Unique slug identifier (e.g. `"production"`). */
+    id: string | null;
+    /** Human-readable display name. */
+    name: string;
+    /** Whether this is a STANDARD or AD_HOC environment. */
+    classification: EnvironmentClassification;
+    /** When the environment was created. */
+    createdAt: string | null;
+    /** When the environment was last updated. */
+    updatedAt: string | null;
+    /** @internal */
+    private _color;
+    /** @internal */
+    readonly _client: EnvironmentModelClient | null;
+    /** @internal */
+    constructor(client: EnvironmentModelClient | null, fields: {
+        id: string | null;
+        name: string;
+        color?: Color | string | null;
+        classification: EnvironmentClassification;
+        createdAt?: string | null;
+        updatedAt?: string | null;
+    });
+    /** The environment color, or `null`. Accepts `Color | string | null` on assignment. */
+    get color(): Color | null;
+    set color(value: Color | string | null);
+    /** Persist this environment to the server (creates if new, updates if existing). */
+    save(): Promise<void>;
+    /** Delete this environment from the server. */
+    delete(): Promise<void>;
+    /** @internal */
+    _apply(other: Environment): void;
+    toString(): string;
+}
+/**
+ * A context-type resource managed by the smplkit platform.
+ *
+ * Mutate fields or use {@link addAttribute} / {@link removeAttribute} /
+ * {@link updateAttribute}, then call {@link save} to persist.
+ */
+declare class ContextType {
+    /** Unique slug identifier (e.g. `"user"`). */
+    id: string | null;
+    /** Human-readable display name. */
+    name: string;
+    /** Known attribute keys with metadata objects. */
+    attributes: Record<string, Record<string, any>>;
+    createdAt: string | null;
+    updatedAt: string | null;
+    /** @internal */
+    readonly _client: ContextTypeModelClient | null;
+    /** @internal */
+    constructor(client: ContextTypeModelClient | null, fields: {
+        id: string | null;
+        name: string;
+        attributes?: Record<string, Record<string, any>>;
+        createdAt?: string | null;
+        updatedAt?: string | null;
+    });
+    /** Add a known-attribute slot. Local; call {@link save} to persist. */
+    addAttribute(name: string, metadata?: Record<string, any>): void;
+    /** Remove a known-attribute slot. Local; call {@link save} to persist. */
+    removeAttribute(name: string): void;
+    /** Replace a known-attribute slot's metadata. Local; call {@link save} to persist. */
+    updateAttribute(name: string, metadata: Record<string, any>): void;
+    save(): Promise<void>;
+    delete(): Promise<void>;
+    /** @internal */
+    _apply(other: ContextType): void;
+    toString(): string;
+}
+/**
+ * Active-record account-settings model.
+ *
+ * The wire format is opaque JSON. Documented keys are exposed as typed
+ * properties; unknown keys live in `raw`. Call {@link save} to write back.
+ */
+declare class AccountSettings {
+    /** @internal */
+    private _data;
+    /** @internal */
+    readonly _client: AccountSettingsModelClient | null;
+    /** @internal */
+    constructor(client: AccountSettingsModelClient | null, data: Record<string, any>);
+    /** The full settings dict. */
+    get raw(): Record<string, any>;
+    set raw(value: Record<string, any>);
+    /** Canonical ordering of STANDARD environments. Empty array if unset. */
+    get environmentOrder(): string[];
+    set environmentOrder(value: string[]);
+    save(): Promise<void>;
+    /** @internal */
+    _apply(other: AccountSettings): void;
+    /** @internal — expose raw data for `_save()`. */
+    get _rawData(): Record<string, any>;
+    toString(): string;
+}
+
+/**
+ * Public types for the Flags SDK: Op, Context, FlagDeclaration, Rule.
+ */
+/**
+ * Operators supported by `Rule.when`.
+ *
+ * Customers should prefer `Op.EQ` etc. over raw strings so the IDE
+ * can validate calls. Raw strings are still accepted for flexibility.
  */
+declare enum Op {
+    EQ = "==",
+    NEQ = "!=",
+    LT = "<",
+    LTE = "<=",
+    GT = ">",
+    GTE = ">=",
+    IN = "in",
+    CONTAINS = "contains"
+}
+/** @internal */
+interface ContextClient {
+    _saveContext(ctx: Context): Promise<Context>;
+    delete(id: string): Promise<void>;
+}
 /**
- * A typed evaluation context entity.
+ * A typed evaluation-context entity.
  *
- * Represents a single entity (user, account, device, etc.) in the
- * evaluation context.  The *type* and *key* identify the entity;
- * *attributes* carry the data that JSON Logic rules target.
+ * Represents a single entity (user, account, device, etc.). The *type*
+ * and *key* identify the entity; *attributes* carry the data that
+ * targeting rules evaluate against.
+ *
+ * Used for both authoring (`flag.get({ context: [...] })`,
+ * `client.setContext([...])`, `mgmt.contexts.register([...])`) and
+ * reading (`mgmt.contexts.list/get` return populated `Context`
+ * instances with `save()` / `delete()` ready to call).
+ *
+ * Validation happens at construction:
+ * - `type` and `key` must be strings (numeric IDs rejected — stringify
+ *   them at the SDK boundary).
+ * - Unknown property assignment via dotted notation is blocked. Use
+ *   `ctx.attributes["plan"] = ...` instead.
+ * - Once persisted (`createdAt` is set), `type` and `key` become
+ *   immutable.
  *
  * @example
  * ```typescript
- * new Context("user", "user-123", { plan: "enterprise", firstName: "Alice" })
- * new Context("user", "user-123", { plan: "enterprise" }, { name: "Alice Smith" })
+ * new Context("user", "user-123", { plan: "enterprise" });
+ * new Context("account", "acme", { region: "us" }, { name: "Acme" });
  * ```
  */
 declare class Context {
-    readonly type: string;
-    readonly key: string;
-    readonly name: string | null;
-    readonly attributes: Record<string, unknown>;
+    type: string;
+    key: string;
+    name: string | null;
+    attributes: Record<string, unknown>;
+    createdAt: string | null;
+    updatedAt: string | null;
+    /** @internal */
+    _client: ContextClient | null;
     constructor(type: string, key: string, attributes?: Record<string, unknown>, options?: {
         name?: string;
+        createdAt?: string | null;
+        updatedAt?: string | null;
     });
+    /** Composite `"{type}:{key}"` identifier. */
+    get id(): string;
+    /** Persist this context to the server (create or update). */
+    save(): Promise<void>;
+    /** Delete this context from the server. */
+    delete(): Promise<void>;
+    /** @internal */
+    _apply(other: Context): void;
     toString(): string;
 }
+/**
+ * Describes a flag declaration for buffered registration.
+ *
+ * Used by `mgmt.flags.register` to queue declarations for bulk
+ * registration. `service` and `environment` default to `null`; the
+ * runtime client fills them from the active `SmplClient` when it
+ * forwards declarations.
+ */
+declare class FlagDeclaration {
+    readonly id: string;
+    readonly type: string;
+    readonly default: unknown;
+    readonly service: string | null;
+    readonly environment: string | null;
+    constructor(fields: {
+        id: string;
+        type: string;
+        default: unknown;
+        service?: string | null;
+        environment?: string | null;
+    });
+}
 /**
  * Fluent builder for flag targeting rules.
  *
  * @example
  * ```typescript
- * new Rule("Enable for enterprise users")
- *     .when("user.plan", "==", "enterprise")
- *     .when("account.region", "==", "us")
- *     .serve(true)
- *     .build()
+ * new Rule("Enable for enterprise users", { environment: "staging" })
+ *   .when("user.plan", Op.EQ, "enterprise")
+ *   .when("account.region", Op.EQ, "us")
+ *   .serve(true);
  * ```
  *
- * Multiple `.when()` calls are combined with AND logic.
+ * Multiple `.when()` calls are AND'd. `environment` is required so the
+ * target environment is unambiguous when the rule is passed to
+ * `Flag.addRule`. `.serve()` finalizes the rule and returns a built
+ * dict ready to pass to `addRule`.
  */
 declare class Rule {
-    private _description;
-    private _conditions;
-    private _value;
-    private _environment;
-    constructor(description: string);
-    /** Tag this rule with an environment key (used by `addRule`). */
-    environment(envKey: string): Rule;
-    /** Add a condition.  Multiple calls are AND'd. */
-    when(variable: string, op: string, value: any): Rule;
-    /** Set the value returned when this rule matches. */
-    serve(value: any): Rule;
-    /** Finalize and return the rule as a plain object. */
-    build(): Record<string, any>;
+    private readonly _description;
+    private readonly _conditions;
+    private readonly _environment;
+    constructor(description: string, options: {
+        environment: string;
+    });
+    /**
+     * Add a condition. Multiple calls are AND'd at the top level.
+     *
+     * Two forms:
+     * - `when(var, op, value)` — convenience for simple comparisons.
+     * - `when(expr)` — escape hatch accepting an arbitrary JSON Logic
+     *   expression (use this for OR, nested AND/OR, `if`, etc.).
+     */
+    when(expr: Record<string, any>): Rule;
+    when(variable: string, op: Op | string, value: any): Rule;
+    /** Finalize the rule with `value` served on match and return the built dict. */
+    serve(value: any): Record<string, any>;
 }
 
 /**
- * Flag model hierarchy with typed subclasses for type-safe evaluation.
+ * Config model + ConfigItem + ConfigEnvironment.
  */
-
+/** Type of a {@link ConfigItem} value. */
+declare enum ItemType {
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    BOOLEAN = "BOOLEAN",
+    JSON = "JSON"
+}
+/** @internal Config client surface used by the active-record `Config.save`/`delete`. */
+interface ConfigModelClient {
+    _createConfig?: (config: Config) => Promise<Config>;
+    _updateConfig?: (config: Config) => Promise<Config>;
+    _deleteConfig?: (id: string) => Promise<void>;
+    _fetchConfig?: (id: string) => Promise<Config>;
+}
+/** A single typed item in a {@link Config}. */
+declare class ConfigItem {
+    readonly name: string;
+    readonly value: unknown;
+    readonly type: ItemType;
+    readonly description: string | null;
+    constructor(name: string, value: unknown, type: ItemType | string, options?: {
+        description?: string;
+    });
+    toString(): string;
+}
 /**
- * A flag resource.
+ * Per-environment value overrides for a {@link Config}.
  *
- * Call `save()` to persist changes. Call `get()` to evaluate the flag.
+ * Read-only inspection container. Mutation is performed via {@link Config}'s
+ * setters with `environment` option (e.g. `cfg.setString("k", "v",
+ * { environment: "production" })`).
  */
-declare class Flag {
-    /** Unique identifier (slug) within the account. */
+declare class ConfigEnvironment {
+    /** @internal */
+    readonly _valuesRaw: Record<string, Record<string, unknown>>;
+    constructor(values?: Record<string, unknown>);
+    /** Return overrides as a plain dict `{key: rawValue}`. */
+    get values(): Record<string, unknown>;
+    /** Return the full typed overrides `{key: {value, type, description}}` (deep copy). */
+    get valuesRaw(): Record<string, Record<string, unknown>>;
+    toString(): string;
+}
+/**
+ * A configuration resource fetched from the Smpl Config service.
+ *
+ * Mutate base values via `set` / `setString` / `setNumber` /
+ * `setBoolean` / `setJson` / `remove` (pass `{ environment: "..." }` to
+ * scope mutations to a specific environment). Call {@link save} to persist.
+ */
+declare class Config {
     id: string | null;
-    /** Human-readable display name. */
     name: string;
-    /** Value type: BOOLEAN, STRING, NUMERIC, or JSON. */
-    type: string;
-    /** Flag-level default value. */
-    default: unknown;
-    /** Closed set of possible values (constrained), or null (unconstrained). */
-    values: Array<{
-        name: string;
-        value: unknown;
-    }> | null;
-    /** Optional description. */
     description: string | null;
-    /** Per-environment configuration. */
-    environments: Record<string, any>;
-    /** When the flag was created. */
+    parent: string | null;
     createdAt: string | null;
-    /** When the flag was last updated. */
     updatedAt: string | null;
     /** @internal */
-    readonly _client: FlagsClient;
+    protected _itemsRaw: Record<string, Record<string, unknown>>;
     /** @internal */
-    constructor(client: FlagsClient, fields: {
+    protected _environments: Record<string, ConfigEnvironment>;
+    /** @internal */
+    readonly _client: ConfigModelClient | null;
+    /** @internal */
+    constructor(client: ConfigModelClient | null, fields: {
         id: string | null;
         name: string;
-        type: string;
-        default: unknown;
-        values: Array<{
-            name: string;
-            value: unknown;
-        }> | null;
-        description: string | null;
-        environments: Record<string, any>;
-        createdAt: string | null;
-        updatedAt: string | null;
+        description?: string | null;
+        parent?: string | null;
+        items?: Record<string, unknown> | null;
+        environments?: Record<string, unknown> | null;
+        createdAt?: string | null;
+        updatedAt?: string | null;
     });
     /**
-     * Persist this flag to the server.
+     * Read-only `{key: rawValue}` view of base items.
      *
-     * Creates if new, updates if existing.
-     * Updates this instance in-place with the server response.
+     * Mutate via {@link set} / {@link setString} / {@link setNumber} /
+     * {@link setBoolean} / {@link setJson} / {@link remove}.
      */
-    save(): Promise<void>;
+    get items(): Record<string, unknown>;
+    /** Return the full typed items `{key: {value, type, description}}` (deep copy). */
+    get itemsRaw(): Record<string, Record<string, unknown>>;
+    /**
+     * Read-only view of per-environment overrides keyed by environment id.
+     *
+     * Mutate via the `environment` option on {@link set} / {@link setString} /
+     * {@link setNumber} / {@link setBoolean} / {@link setJson} / {@link remove}.
+     */
+    get environments(): Record<string, ConfigEnvironment>;
+    /** @internal — return the wire-shaped raw items for serialization. */
+    get _itemsRawDirect(): Record<string, Record<string, unknown>>;
+    /** @internal — return the typed environments dict for serialization. */
+    get _environmentsDirect(): Record<string, ConfigEnvironment>;
+    /** @internal — return the dict that `set()` / `remove()` should mutate. */
+    private _itemsTarget;
+    /**
+     * Set (or replace) an item. With `environment`, sets an override on
+     * that environment.
+     */
+    set(item: ConfigItem, options?: {
+        environment?: string;
+    }): void;
+    /** Remove an item by name. With `environment`, removes only that env's override. */
+    remove(name: string, options?: {
+        environment?: string;
+    }): void;
+    /** Convenience: set a STRING item (or environment override). */
+    setString(name: string, value: string, options?: {
+        description?: string;
+        environment?: string;
+    }): void;
+    /** Convenience: set a NUMBER item (or environment override). */
+    setNumber(name: string, value: number, options?: {
+        description?: string;
+        environment?: string;
+    }): void;
+    /** Convenience: set a BOOLEAN item (or environment override). */
+    setBoolean(name: string, value: boolean, options?: {
+        description?: string;
+        environment?: string;
+    }): void;
+    /** Convenience: set a JSON item (or environment override). */
+    setJson(name: string, value: unknown, options?: {
+        description?: string;
+        environment?: string;
+    }): void;
     /**
-     * Add a rule to a specific environment.
+     * Persist this config to the server.
      *
-     * The built rule must include an `environment` key (set via
-     * `Rule(...).environment("env_key")`). Call `save()` to persist.
+     * Creates a new config if unsaved, or updates the existing one.
      *
-     * @returns `this` for chaining.
+     * @throws SmplkitNotFoundError if the config no longer exists (update).
+     * @throws SmplkitValidationError if the server rejects the request.
+     * @throws Error if the model was constructed without a management client.
      */
-    addRule(builtRule: Record<string, any>): Flag;
-    /** Enable or disable a flag in a specific environment. Call `save()` to persist. */
-    setEnvironmentEnabled(envKey: string, enabled: boolean): void;
-    /** Set the default value for a specific environment. Call `save()` to persist. */
-    setEnvironmentDefault(envKey: string, defaultValue: unknown): void;
-    /** Clear all rules for a specific environment. Call `save()` to persist. */
-    clearRules(envKey: string): void;
+    save(): Promise<void>;
+    /** Delete this config from the server. */
+    delete(): Promise<void>;
+    /** @internal */
+    _apply(other: Config): void;
     /**
-     * Evaluate the flag and return its current value.
+     * Walk the parent chain and return config data dicts child-to-root.
      *
-     * Requires `initialize()` to have been called on the flags client.
+     * @internal
      */
-    get(options?: {
-        context?: Context[];
-    }): unknown;
-    /** @internal — copy all fields from another Flag instance. */
-    _apply(other: Flag): void;
-    toString(): string;
-}
-/** Typed flag that returns `boolean` from `get()`. */
-declare class BooleanFlag extends Flag {
-    get(options?: {
-        context?: Context[];
-    }): boolean;
-}
-/** Typed flag that returns `string` from `get()`. */
-declare class StringFlag extends Flag {
-    get(options?: {
-        context?: Context[];
-    }): string;
-}
-/** Typed flag that returns `number` from `get()`. */
-declare class NumberFlag extends Flag {
-    get(options?: {
-        context?: Context[];
-    }): number;
+    _buildChain(configs?: Config[]): Promise<Array<{
+        id: string | null;
+        items: Record<string, Record<string, unknown>>;
+        environments: Record<string, {
+            values: Record<string, Record<string, unknown>>;
+        }>;
+    }>>;
+    toString(): string;
 }
-/** Typed flag that returns `Record<string, any>` from `get()`. */
-declare class JsonFlag extends Flag {
-    get(options?: {
-        context?: Context[];
-    }): Record<string, any>;
+
+type ConfigHttp$1 = ReturnType<typeof createClient<___generated_config_d_ts.paths>>;
+/**
+ * `mgmt.config.*` — CRUD client for configs.
+ */
+declare class ManagementConfigClient {
+    private readonly _http;
+    /** @internal */
+    constructor(_http: ConfigHttp$1);
+    /** Construct an unsaved {@link Config}. Call `.save()` to persist. */
+    new(id: string, options?: {
+        name?: string;
+        description?: string;
+        parent?: string | Config | null;
+    }): Config;
+    /** List all configs. */
+    list(): Promise<Config[]>;
+    /** Fetch a config by id. */
+    get(id: string): Promise<Config>;
+    /** Delete a config by id. */
+    delete(id: string): Promise<void>;
+    /** @internal — called by `Config.delete()`. */
+    _deleteConfig(id: string): Promise<void>;
+    /** @internal — called by `Config._buildChain` to resolve parents. */
+    _fetchConfig(id: string): Promise<Config>;
+    /** @internal — called by `Config.save()` for new resources. */
+    _createConfig(config: Config): Promise<Config>;
+    /** @internal — called by `Config.save()` for existing resources. */
+    _updateConfig(config: Config): Promise<Config>;
 }
 
 /**
- * FlagsClient — management and runtime for Smpl Flags.
+ * FlagsClient — runtime client for Smpl Flags (handle declaration, evaluation,
+ * live updates). Management/CRUD lives on `mgmt.flags.*`.
  */
 
-type FlagResource = components["schemas"]["FlagResource"];
 /** Describes a flag definition change. */
 declare class FlagChangeEvent {
     readonly id: string;
@@ -908,69 +1486,13 @@ declare class FlagStats {
     readonly cacheMisses: number;
     constructor(cacheHits: number, cacheMisses: number);
 }
-/** @internal — exported so ManagementClient.contexts can share the same buffer. */
-declare class ContextRegistrationBuffer {
-    private _seen;
-    private _pending;
-    observe(contexts: Context[]): void;
-    drain(): Array<Record<string, any>>;
-    get pendingCount(): number;
-}
-/**
- * Management API for smplkit Flags — CRUD operations on Flag models.
- *
- * Access via `SmplClient.flags.management`.
- */
-declare class FlagsManagement {
-    private readonly _client;
-    constructor(_client: FlagsClient);
-    /** Create an unsaved boolean flag. Call `.save()` to persist. */
-    newBooleanFlag(id: string, options: {
-        default: boolean;
-        name?: string;
-        description?: string;
-    }): BooleanFlag;
-    /** Create an unsaved string flag. Call `.save()` to persist. */
-    newStringFlag(id: string, options: {
-        default: string;
-        name?: string;
-        description?: string;
-        values?: Array<{
-            name: string;
-            value: unknown;
-        }>;
-    }): StringFlag;
-    /** Create an unsaved number flag. Call `.save()` to persist. */
-    newNumberFlag(id: string, options: {
-        default: number;
-        name?: string;
-        description?: string;
-        values?: Array<{
-            name: string;
-            value: unknown;
-        }>;
-    }): NumberFlag;
-    /** Create an unsaved JSON flag. Call `.save()` to persist. */
-    newJsonFlag(id: string, options: {
-        default: Record<string, any>;
-        name?: string;
-        description?: string;
-        values?: Array<{
-            name: string;
-            value: unknown;
-        }>;
-    }): JsonFlag;
-    /** Fetch a flag by id. */
-    get(id: string): Promise<Flag>;
-    /** List all flags. */
-    list(): Promise<Flag[]>;
-    /** Delete a flag by id. */
-    delete(id: string): Promise<void>;
-}
+
 /**
- * Client for the smplkit Flags API.
+ * Runtime client for the smplkit Flags service.
  *
- * Obtained via `SmplClient.flags`.
+ * Obtained via `SmplClient.flags`. Provides flag handle declaration,
+ * evaluation, and live-updates. Management/CRUD lives on
+ * `SmplClient.manage.flags` (or use a standalone {@link SmplManagementClient}).
  */
 declare class FlagsClient {
     /** @internal */
@@ -1000,56 +1522,8 @@ declare class FlagsClient {
         readonly _service: string | null;
         readonly _metrics: MetricsReporter | null;
     } | null;
-    /** Management API — CRUD operations on Flag models. */
-    readonly management: FlagsManagement;
     /** @internal */
     constructor(apiKey: string, ensureWs: () => SharedWebSocket, timeout?: number, flagsBaseUrl?: string, appBaseUrl?: string, contextBuffer?: ContextRegistrationBuffer);
-    /** @internal */
-    _mgNewBooleanFlag(id: string, options: {
-        default: boolean;
-        name?: string;
-        description?: string;
-    }): BooleanFlag;
-    /** @internal */
-    _mgNewStringFlag(id: string, options: {
-        default: string;
-        name?: string;
-        description?: string;
-        values?: Array<{
-            name: string;
-            value: unknown;
-        }>;
-    }): StringFlag;
-    /** @internal */
-    _mgNewNumberFlag(id: string, options: {
-        default: number;
-        name?: string;
-        description?: string;
-        values?: Array<{
-            name: string;
-            value: unknown;
-        }>;
-    }): NumberFlag;
-    /** @internal */
-    _mgNewJsonFlag(id: string, options: {
-        default: Record<string, any>;
-        name?: string;
-        description?: string;
-        values?: Array<{
-            name: string;
-            value: unknown;
-        }>;
-    }): JsonFlag;
-    /** @internal */
-    _mgGet(id: string): Promise<Flag>;
-    /** @internal */
-    _mgList(): Promise<Flag[]>;
-    /** @internal */
-    _mgDelete(id: string): Promise<void>;
-    /** @internal — POST a new flag. */
-    _createFlag(flag: Flag): Promise<Flag>;
-    /** @internal — PUT a flag update. */
-    _updateFlag(flag: Flag): Promise<Flag>;
     /** Declare a boolean flag handle for runtime evaluation. */
     booleanFlag(id: string, defaultValue: boolean): BooleanFlag;
     /** Declare a string flag handle for runtime evaluation. */
@@ -1112,11 +1586,320 @@ declare class FlagsClient {
     private _fireChangeListenersAll;
     private _flushFlags;
     private _flushContexts;
-    /** @internal */
-    _resourceToModel(resource: FlagResource): Flag;
     private _resourceToPlainDict;
 }
 
+/**
+ * Flag, FlagValue, FlagRule, FlagEnvironment — flag model + frozen wrappers.
+ */
+
+/** @internal Flag client surface needed by the model (covers both runtime + management). */
+interface FlagModelClient {
+    _createFlag?: (flag: Flag) => Promise<Flag>;
+    _updateFlag?: (flag: Flag) => Promise<Flag>;
+    _deleteFlag?: (id: string) => Promise<void>;
+    _evaluateHandle(id: string, defaultValue: unknown, context: Context[] | null): unknown;
+}
+/**
+ * A constrained value entry on a {@link Flag}.
+ *
+ * Lives in {@link Flag.values}. Frozen — author values via
+ * {@link Flag.addValue} / {@link Flag.removeValue} / {@link Flag.clearValues}.
+ */
+declare class FlagValue {
+    readonly name: string;
+    readonly value: unknown;
+    constructor(fields: {
+        name: string;
+        value: unknown;
+    });
+}
+/**
+ * A single targeting rule on a {@link Flag}.
+ *
+ * Lives in {@link FlagEnvironment.rules}. Frozen — author rules via the
+ * {@link Rule} fluent builder and pass through {@link Flag.addRule}.
+ */
+declare class FlagRule {
+    /** JSON Logic predicate. Empty object means "always match". */
+    readonly logic: Readonly<Record<string, unknown>>;
+    /** Value to serve when `logic` evaluates truthy. */
+    readonly value: unknown;
+    /** Human-readable label (optional). */
+    readonly description: string | null;
+    constructor(fields: {
+        logic: Record<string, unknown>;
+        value: unknown;
+        description?: string | null;
+    });
+}
+/**
+ * Per-environment configuration on a {@link Flag}.
+ *
+ * Lives at `flag.environments[envName]`. Frozen — mutate via
+ * {@link Flag.addRule} / {@link Flag.enableRules} / {@link Flag.disableRules} /
+ * {@link Flag.setDefault} / {@link Flag.clearRules} (with `environment` option).
+ */
+declare class FlagEnvironment {
+    /** Whether the flag is active in this environment. */
+    readonly enabled: boolean;
+    /** Environment-specific default override (`null` means no override). */
+    readonly default: unknown;
+    /** Targeting rules to evaluate, in order. Frozen tuple. */
+    readonly rules: ReadonlyArray<FlagRule>;
+    constructor(fields?: {
+        enabled?: boolean;
+        default?: unknown;
+        rules?: ReadonlyArray<FlagRule>;
+    });
+    /** Return a new `FlagEnvironment` with the given fields replaced. @internal */
+    _replace(fields: {
+        enabled?: boolean;
+        default?: unknown;
+        rules?: ReadonlyArray<FlagRule>;
+    }): FlagEnvironment;
+}
+/**
+ * A flag resource.
+ *
+ * Provides management operations (save, addRule, environment settings)
+ * and runtime evaluation via {@link Flag.get}.
+ *
+ * Use typed variants ({@link BooleanFlag}, {@link StringFlag},
+ * {@link NumberFlag}, {@link JsonFlag}) for type-safe `get()` returns.
+ */
+declare class Flag {
+    id: string | null;
+    name: string;
+    type: string;
+    default: unknown;
+    description: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+    /** @internal */
+    protected _values: FlagValue[] | null;
+    /** @internal */
+    protected _environments: Record<string, FlagEnvironment>;
+    /** @internal */
+    readonly _client: FlagModelClient | null;
+    /** @internal */
+    constructor(client: FlagModelClient | null, fields: {
+        id: string | null;
+        name: string;
+        type: string;
+        default: unknown;
+        values: FlagValue[] | null;
+        description: string | null;
+        environments: Record<string, FlagEnvironment>;
+        createdAt: string | null;
+        updatedAt: string | null;
+    });
+    /**
+     * Read-only view of constrained values.
+     *
+     * `null` means unconstrained. Mutate via {@link addValue} /
+     * {@link removeValue} / {@link clearValues}.
+     */
+    get values(): FlagValue[] | null;
+    /**
+     * Read-only view of per-environment configuration.
+     *
+     * Mutate via {@link addRule} / {@link enableRules} / {@link disableRules} /
+     * {@link setDefault} (with `environment` option) / {@link clearRules}.
+     */
+    get environments(): Record<string, FlagEnvironment>;
+    /**
+     * Persist this flag to the server.
+     *
+     * Creates a new flag if unsaved, or updates the existing one.
+     */
+    save(): Promise<void>;
+    /** Delete this flag from the server. */
+    delete(): Promise<void>;
+    /**
+     * Append a rule to a specific environment.
+     *
+     * The *builtRule* dict must include an `environment` key. Call
+     * {@link save} to persist. Returns `this` for chaining.
+     */
+    addRule(builtRule: Record<string, any>): this;
+    /**
+     * Enable rule evaluation. Call {@link save} to persist.
+     *
+     * With `environment` set scopes to that single environment; without,
+     * enables rules in every environment configured on this flag.
+     */
+    enableRules(options?: {
+        environment?: string;
+    }): void;
+    /**
+     * Disable rule evaluation (kill switch). Call {@link save} to persist.
+     *
+     * With `environment` set scopes to that single environment; without,
+     * disables rules in every environment configured on this flag. When
+     * disabled, {@link Flag.get} skips rules and returns the env-specific
+     * default (or the flag's base default).
+     */
+    disableRules(options?: {
+        environment?: string;
+    }): void;
+    /**
+     * Set the flag's default served value.
+     *
+     * With `environment` undefined (the default), updates the flag-level
+     * default used when no environment-specific override applies. With
+     * `environment` set, sets the per-environment default served when no
+     * rule matches.
+     *
+     * Call {@link save} to persist.
+     */
+    setDefault(value: unknown, options?: {
+        environment?: string;
+    }): void;
+    /**
+     * Clear the per-environment default override on `environment`.
+     *
+     * After clearing, the environment falls back to the flag's base default
+     * when no rule matches. Call {@link save} to persist.
+     */
+    clearDefault(options: {
+        environment: string;
+    }): void;
+    /**
+     * Remove rules. Call {@link save} to persist.
+     *
+     * With `environment` set scopes to that single environment; without,
+     * removes rules from every environment configured on this flag.
+     */
+    clearRules(options?: {
+        environment?: string;
+    }): void;
+    /** Append a constrained value. Returns `this` for chaining. */
+    addValue(name: string, value: unknown): this;
+    /** Remove the first values entry whose `value` field matches. Returns `this`. */
+    removeValue(value: unknown): this;
+    /** Set values to `null` (unconstrained). Call {@link save} to persist. */
+    clearValues(): void;
+    /** Evaluate this flag and return its current value. */
+    get(options?: {
+        context?: Context[];
+    }): unknown;
+    /** @internal */
+    _apply(other: Flag): void;
+    /** @internal — raw access for serialization. */
+    _envsRaw(): Record<string, FlagEnvironment>;
+    toString(): string;
+}
+/** Typed flag that returns `boolean` from {@link Flag.get}. */
+declare class BooleanFlag extends Flag {
+    get(options?: {
+        context?: Context[];
+    }): boolean;
+}
+/** Typed flag that returns `string` from {@link Flag.get}. */
+declare class StringFlag extends Flag {
+    get(options?: {
+        context?: Context[];
+    }): string;
+}
+/** Typed flag that returns `number` from {@link Flag.get}. */
+declare class NumberFlag extends Flag {
+    get(options?: {
+        context?: Context[];
+    }): number;
+}
+/** Typed flag that returns `Record<string, unknown>` from {@link Flag.get}. */
+declare class JsonFlag extends Flag {
+    get(options?: {
+        context?: Context[];
+    }): Record<string, unknown>;
+}
+
+type FlagsHttp$1 = ReturnType<typeof createClient<___generated_flags_d_ts.paths>>;
+/**
+ * Buffer pending flag declarations for bulk registration. @internal
+ */
+declare class FlagRegistrationBuffer {
+    private _seen;
+    private _pending;
+    add(decl: FlagDeclaration): void;
+    drain(): Array<components["schemas"]["FlagBulkItem"]>;
+    get pendingCount(): number;
+}
+/**
+ * `mgmt.flags.*` — CRUD client for flags + bulk registration buffer.
+ */
+declare class ManagementFlagsClient {
+    private readonly _http;
+    /** @internal */
+    readonly _buffer: FlagRegistrationBuffer;
+    /** @internal */
+    constructor(_http: FlagsHttp$1);
+    /** Construct an unsaved {@link BooleanFlag}. Call `.save()` to persist. */
+    newBooleanFlag(id: string, options: {
+        default: boolean;
+        name?: string;
+        description?: string;
+    }): BooleanFlag;
+    /** Construct an unsaved {@link StringFlag}. Call `.save()` to persist. */
+    newStringFlag(id: string, options: {
+        default: string;
+        name?: string;
+        description?: string;
+        values?: Array<FlagValue | {
+            name: string;
+            value: unknown;
+        }>;
+    }): StringFlag;
+    /** Construct an unsaved {@link NumberFlag}. Call `.save()` to persist. */
+    newNumberFlag(id: string, options: {
+        default: number;
+        name?: string;
+        description?: string;
+        values?: Array<FlagValue | {
+            name: string;
+            value: unknown;
+        }>;
+    }): NumberFlag;
+    /** Construct an unsaved {@link JsonFlag}. Call `.save()` to persist. */
+    newJsonFlag(id: string, options: {
+        default: Record<string, unknown>;
+        name?: string;
+        description?: string;
+        values?: Array<FlagValue | {
+            name: string;
+            value: unknown;
+        }>;
+    }): JsonFlag;
+    /** Fetch a flag by id. */
+    get(id: string): Promise<Flag>;
+    /** List all flags. */
+    list(): Promise<Flag[]>;
+    /** Delete a flag by id. */
+    delete(id: string): Promise<void>;
+    /** @internal — called by `Flag.delete()`. */
+    _deleteFlag(id: string): Promise<void>;
+    /**
+     * Queue flag declaration(s) for bulk registration; optionally flush.
+     *
+     * Threshold-based flushing fires when 50+ pending; the periodic
+     * timer on {@link SmplClient} also drains it every 60s.
+     */
+    register(items: FlagDeclaration | FlagDeclaration[], options?: {
+        flush?: boolean;
+    }): Promise<void>;
+    /** Send any pending flag declarations to the server. */
+    flush(): Promise<void>;
+    /** Number of declarations awaiting flush. */
+    get pendingCount(): number;
+    /** @internal — called by `Flag.save()` for new resources. */
+    _createFlag(flag: Flag): Promise<Flag>;
+    /** @internal — called by `Flag.save()` for existing resources. */
+    _updateFlag(flag: Flag): Promise<Flag>;
+    /** @internal — flag models constructed via `mgmt.flags.*` cannot evaluate. */
+    _evaluateHandle(_id: string, _defaultValue: unknown, _context: Context[] | null): unknown;
+}
+
 /**
  * Public types for the Logging SDK.
  */
@@ -1130,39 +1913,63 @@ declare enum LogLevel {
     FATAL = "FATAL",
     SILENT = "SILENT"
 }
-/** Describes a logger configuration change. */
-interface LoggerChangeEvent {
-    /** The logger id that changed. */
-    id: string;
-    /** The new effective log level, or null if removed. */
-    level: LogLevel | null;
-    /** How the change was delivered. */
-    source: string;
-    /** True when the logger or group was deleted. */
-    deleted?: true;
+/**
+ * Describes a logger configuration change. Frozen — fields cannot be
+ * mutated after construction so a listener cannot affect later listeners.
+ *
+ * The `level` field is a TypeScript-SDK-only convenience for callers that
+ * want to act on the new effective level without re-fetching the logger.
+ */
+declare class LoggerChangeEvent {
+    readonly id: string;
+    readonly source: string;
+    readonly level?: LogLevel | null;
+    readonly deleted?: true;
+    constructor(fields: {
+        id: string;
+        source: string;
+        level?: LogLevel | null;
+        deleted?: true;
+    });
 }
 /**
- * Describes a logger to register via `client.logging.management.registerSources()`.
+ * Describes a logger to register via `mgmt.loggers.register([source, ...])`.
  *
- * Unlike auto-discovery (which reads the current process's logging framework),
- * `registerSources` accepts explicit `service` and `environment` overrides —
- * useful for sample-data seeding, cross-tenant migration, and test fixtures.
+ * Unlike runtime auto-discovery (which reads the current process's logging
+ * framework), `mgmt.loggers.register` accepts explicit `service` and
+ * `environment` overrides — useful for sample-data seeding, cross-tenant
+ * migration, and test fixtures.
+ *
+ * Frozen.
  */
 declare class LoggerSource {
     /** Logger name (e.g. `"sqlalchemy.engine"`). */
     readonly name: string;
     /** Service name this source belongs to. */
-    readonly service: string;
+    readonly service: string | null;
     /** Environment name this source belongs to. */
-    readonly environment: string;
+    readonly environment: string | null;
     /** Effective log level for this source. */
     readonly resolvedLevel: LogLevel;
     /** Explicit (configured) log level, if different from `resolvedLevel`. */
     readonly level: LogLevel | null;
     constructor(name: string, options: {
-        service: string;
-        environment: string;
-        resolved_level: LogLevel;
+        service?: string | null;
+        environment?: string | null;
+        resolvedLevel: LogLevel;
+        level?: LogLevel | null;
+    });
+}
+/**
+ * Per-environment configuration on a logger or log group.
+ *
+ * Frozen — mutate via `logger.setLevel(level, { environment: "..." })`
+ * or remove with `logger.clearLevel({ environment: "..." })`.
+ */
+declare class LoggerEnvironment {
+    /** Per-environment level override (`null` means no override). */
+    readonly level: LogLevel | null;
+    constructor(fields?: {
         level?: LogLevel | null;
     });
 }
@@ -1171,10 +1978,22 @@ declare class LoggerSource {
  * Logger and LogGroup active-record models for the Logging SDK.
  */
 
+/** @internal */
+interface LoggerModelClient {
+    _saveLogger?: (logger: Logger) => Promise<Logger>;
+    _deleteLogger?: (id: string) => Promise<void>;
+}
+/** @internal */
+interface LogGroupModelClient {
+    _saveGroup?: (group: LogGroup) => Promise<LogGroup>;
+    _deleteGroup?: (id: string) => Promise<void>;
+}
 /**
  * A logger resource managed by the smplkit platform.
  *
- * Mutate properties or use convenience methods, then call `save()` to persist.
+ * Mutate via {@link setLevel} / {@link clearLevel} /
+ * {@link clearAllEnvironmentLevels} (with `environment` option for per-env
+ * overrides), then call {@link save} to persist.
  */
 declare class Logger {
     /** Unique identifier (dot-separated hierarchy, e.g. `"sqlalchemy.engine"`). */
@@ -1186,105 +2005,475 @@ declare class Logger {
     /** Id of the parent log group, or null. */
     group: string | null;
     /** Whether this logger is managed by the platform. */
-    managed: boolean;
+    managed: boolean | null;
     /** Observed sources (services that report this logger). */
     sources: Array<Record<string, any>>;
-    /** Per-environment level overrides. */
-    environments: Record<string, any>;
     /** When the logger was created. */
     createdAt: string | null;
     /** When the logger was last updated. */
     updatedAt: string | null;
     /** @internal */
-    readonly _client: LoggingClient;
+    protected _environments: Record<string, LoggerEnvironment>;
     /** @internal */
-    constructor(client: LoggingClient, fields: {
+    readonly _client: LoggerModelClient | null;
+    /** @internal */
+    constructor(client: LoggerModelClient | null, fields: {
         id: string | null;
         name: string;
-        level: LogLevel | null;
-        group: string | null;
-        managed: boolean;
-        sources: Array<Record<string, any>>;
-        environments: Record<string, any>;
-        createdAt: string | null;
-        updatedAt: string | null;
+        level?: LogLevel | null;
+        group?: string | null;
+        managed?: boolean | null;
+        sources?: Array<Record<string, any>>;
+        environments?: Record<string, unknown> | null;
+        createdAt?: string | null;
+        updatedAt?: string | null;
     });
     /**
-     * Persist this logger to the server.
+     * Read-only view of per-environment level overrides.
      *
-     * Creates if new, updates if existing.
+     * Mutate via {@link setLevel} / {@link clearLevel} /
+     * {@link clearAllEnvironmentLevels} (with `environment` option).
      */
+    get environments(): Record<string, LoggerEnvironment>;
+    /** @internal — direct typed environments dict for serialization. */
+    get _environmentsDirect(): Record<string, LoggerEnvironment>;
+    /** Persist this logger to the server (create or update). */
     save(): Promise<void>;
-    /** Set the base log level. Call `save()` to persist. */
-    setLevel(level: LogLevel): void;
-    /** Clear the base log level. Call `save()` to persist. */
-    clearLevel(): void;
-    /** Set an environment-specific log level. Call `save()` to persist. */
-    setEnvironmentLevel(env: string, level: LogLevel): void;
-    /** Clear an environment-specific log level. Call `save()` to persist. */
-    clearEnvironmentLevel(env: string): void;
-    /** Clear all environment-specific log levels. Call `save()` to persist. */
+    /** Delete this logger from the server. */
+    delete(): Promise<void>;
+    /**
+     * Set the log level.
+     *
+     * With `environment` undefined (the default), sets the base log level
+     * used when no environment-specific override applies. With `environment`,
+     * sets the per-environment override.
+     */
+    setLevel(level: LogLevel, options?: {
+        environment?: string;
+    }): void;
+    /**
+     * Remove a log level.
+     *
+     * With `environment` undefined (the default), removes the base log level
+     * (the logger then inherits from its group / dot-notation ancestor /
+     * system default). With `environment`, removes only that env's override.
+     */
+    clearLevel(options?: {
+        environment?: string;
+    }): void;
+    /** Remove all per-environment level overrides. */
     clearAllEnvironmentLevels(): void;
-    /** @internal — copy all fields from another Logger instance. */
+    /** @internal */
     _apply(other: Logger): void;
     toString(): string;
 }
 /**
  * A log group resource for organizing loggers.
  *
- * Management: mutate properties and call `save()` to persist.
+ * Mutate via {@link setLevel} / {@link clearLevel} /
+ * {@link clearAllEnvironmentLevels} (with `environment` option), then
+ * call {@link save} to persist.
  */
 declare class LogGroup {
-    /** Unique identifier (slug), or `null` if unsaved. */
     id: string | null;
-    /** Human-readable key (slug), or `null` if not set. */
-    key: string | null;
-    /** Human-readable display name. */
     name: string;
-    /** Base log level, or null if inherited. */
     level: LogLevel | null;
-    /** Id of the parent log group, or null. */
     group: string | null;
-    /** Per-environment level overrides. */
-    environments: Record<string, any>;
-    /** When the log group was created. */
     createdAt: string | null;
-    /** When the log group was last updated. */
     updatedAt: string | null;
     /** @internal */
-    readonly _client: LoggingClient;
+    protected _environments: Record<string, LoggerEnvironment>;
     /** @internal */
-    constructor(client: LoggingClient, fields: {
+    readonly _client: LogGroupModelClient | null;
+    /** @internal */
+    constructor(client: LogGroupModelClient | null, fields: {
         id: string | null;
-        key: string | null;
         name: string;
-        level: LogLevel | null;
-        group: string | null;
-        environments: Record<string, any>;
-        createdAt: string | null;
-        updatedAt: string | null;
+        level?: LogLevel | null;
+        group?: string | null;
+        environments?: Record<string, unknown> | null;
+        createdAt?: string | null;
+        updatedAt?: string | null;
     });
-    /**
-     * Persist this log group to the server.
-     *
-     * Creates if new, updates if existing.
-     */
+    /** Read-only view of per-environment level overrides. */
+    get environments(): Record<string, LoggerEnvironment>;
+    /** @internal */
+    get _environmentsDirect(): Record<string, LoggerEnvironment>;
     save(): Promise<void>;
-    /** Set the base log level. Call `save()` to persist. */
-    setLevel(level: LogLevel): void;
-    /** Clear the base log level. Call `save()` to persist. */
-    clearLevel(): void;
-    /** Set an environment-specific log level. Call `save()` to persist. */
-    setEnvironmentLevel(env: string, level: LogLevel): void;
-    /** Clear an environment-specific log level. Call `save()` to persist. */
-    clearEnvironmentLevel(env: string): void;
-    /** Clear all environment-specific log levels. Call `save()` to persist. */
+    delete(): Promise<void>;
+    setLevel(level: LogLevel, options?: {
+        environment?: string;
+    }): void;
+    clearLevel(options?: {
+        environment?: string;
+    }): void;
     clearAllEnvironmentLevels(): void;
-    /** @internal — copy all fields from another LogGroup instance. */
+    /** @internal */
     _apply(other: LogGroup): void;
     toString(): string;
 }
 
+type LoggingHttp$1 = ReturnType<typeof createClient<___generated_logging_d_ts.paths>>;
+/** Buffer pending logger sources for bulk registration. @internal */
+declare class LoggerRegistrationBuffer {
+    private _seen;
+    private _pending;
+    add(source: LoggerSource): void;
+    drain(): Array<components$1["schemas"]["LoggerBulkItem"]>;
+    get pendingCount(): number;
+}
+/**
+ * `mgmt.loggers.*` — CRUD client for individual loggers + bulk registration.
+ */
+declare class LoggersClient {
+    private readonly _http;
+    /** @internal */
+    readonly _buffer: LoggerRegistrationBuffer;
+    /** @internal */
+    constructor(_http: LoggingHttp$1);
+    /**
+     * Construct an unsaved {@link Logger}. Call `.save()` to persist.
+     *
+     * The id doubles as the display name. `managed` defaults to `true`
+     * (every customer using the management API is doing so to manage it).
+     */
+    new(id: string, options?: {
+        managed?: boolean;
+    }): Logger;
+    list(): Promise<Logger[]>;
+    get(id: string): Promise<Logger>;
+    delete(id: string): Promise<void>;
+    /** @internal — called by `Logger.delete()`. */
+    _deleteLogger(id: string): Promise<void>;
+    /**
+     * Queue logger source(s) for bulk registration; optionally flush.
+     */
+    register(items: LoggerSource | LoggerSource[], options?: {
+        flush?: boolean;
+    }): Promise<void>;
+    flush(): Promise<void>;
+    get pendingCount(): number;
+    /** @internal — called by `Logger.save()`. PUT /loggers/{id} is upsert. */
+    _saveLogger(logger: Logger): Promise<Logger>;
+}
+/**
+ * `mgmt.logGroups.*` — CRUD client for log groups.
+ */
+declare class LogGroupsClient {
+    private readonly _http;
+    /** @internal */
+    constructor(_http: LoggingHttp$1);
+    /** Construct an unsaved {@link LogGroup}. Call `.save()` to persist. */
+    new(id: string, options?: {
+        name?: string;
+        group?: string;
+    }): LogGroup;
+    list(): Promise<LogGroup[]>;
+    get(id: string): Promise<LogGroup>;
+    delete(id: string): Promise<void>;
+    /** @internal — called by `LogGroup.delete()`. */
+    _deleteGroup(id: string): Promise<void>;
+    /** @internal — called by `LogGroup.save()`. PUT /log_groups/{id} is upsert. */
+    _saveGroup(group: LogGroup): Promise<LogGroup>;
+}
+
+type AppHttp = ReturnType<typeof createClient<___generated_app_d_ts.paths>>;
+type ConfigHttp = ReturnType<typeof createClient<___generated_config_d_ts.paths>>;
+type FlagsHttp = ReturnType<typeof createClient<___generated_flags_d_ts.paths>>;
+type LoggingHttp = ReturnType<typeof createClient<___generated_logging_d_ts.paths>>;
+/** `mgmt.environments.*` — CRUD for environments. */
+declare class EnvironmentsClient {
+    private readonly _http;
+    /** @internal */
+    constructor(_http: AppHttp);
+    /**
+     * Construct an unsaved {@link Environment}. Call `.save()` to persist.
+     */
+    new(id: string, options: {
+        name: string;
+        color?: Color | string | null;
+        classification?: EnvironmentClassification;
+    }): Environment;
+    list(): Promise<Environment[]>;
+    get(id: string): Promise<Environment>;
+    delete(id: string): Promise<void>;
+    /** @internal */
+    _create(env: Environment): Promise<Environment>;
+    /** @internal */
+    _update(env: Environment): Promise<Environment>;
+}
+/** `mgmt.contextTypes.*` — CRUD for context types. */
+declare class ContextTypesClient {
+    private readonly _http;
+    /** @internal */
+    constructor(_http: AppHttp);
+    /**
+     * Construct an unsaved {@link ContextType}. Call `.save()` to persist.
+     *
+     * `name` defaults to the id when omitted.
+     */
+    new(id: string, options?: {
+        name?: string;
+        attributes?: Record<string, Record<string, any>>;
+    }): ContextType;
+    list(): Promise<ContextType[]>;
+    get(id: string): Promise<ContextType>;
+    delete(id: string): Promise<void>;
+    /** @internal */
+    _create(ct: ContextType): Promise<ContextType>;
+    /** @internal */
+    _update(ct: ContextType): Promise<ContextType>;
+}
+/**
+ * Buffer pending context observations for bulk registration.
+ *
+ * Backed by an LRU of size {@link CONTEXT_REGISTRATION_LRU_SIZE} so the
+ * dedup window doesn't grow unbounded for long-lived processes.
+ * @internal
+ */
+declare class ContextRegistrationBuffer {
+    private _seen;
+    private _pending;
+    observe(contexts: Context[]): void;
+    drain(): Array<{
+        type: string;
+        key: string;
+        attributes: Record<string, unknown>;
+    }>;
+    get pendingCount(): number;
+}
+/** `mgmt.contexts.*` — register/list/get/delete for context instances. */
+declare class ContextsClient {
+    private readonly _http;
+    /** @internal */
+    readonly _buffer: ContextRegistrationBuffer;
+    /** @internal */
+    constructor(_http: AppHttp, buffer?: ContextRegistrationBuffer);
+    /**
+     * Buffer context(s) for registration; optionally flush immediately.
+     *
+     * When `flush` is false (default), contexts are queued for the SDK's
+     * background flush. When `flush` is true the call awaits the round-trip.
+     */
+    register(items: Context | Context[], options?: {
+        flush?: boolean;
+    }): Promise<void>;
+    /** Send any pending context observations to the server. */
+    flush(): Promise<void>;
+    /** Number of contexts awaiting flush. */
+    get pendingCount(): number;
+    /** List all contexts of a given type. */
+    list(type: string): Promise<Context[]>;
+    /** Fetch a context by composite id (`"type:key"`) or by separate type and key. */
+    get(idOrType: string, key?: string): Promise<Context>;
+    /** Delete a context by composite id (`"type:key"`) or by separate type and key. */
+    delete(idOrType: string, key?: string): Promise<void>;
+    /** @internal — called by `Context.save()`. */
+    _saveContext(ctx: Context): Promise<Context>;
+}
+/** `mgmt.accountSettings.*` — get/save for account-level settings. */
+declare class AccountSettingsClient {
+    private readonly _appBaseUrl;
+    private readonly _headers;
+    /** @internal */
+    constructor(_appBaseUrl: string, apiKey: string);
+    get(): Promise<AccountSettings>;
+    /** @internal */
+    _save(data: Record<string, any>): Promise<AccountSettings>;
+}
+/** Configuration options for the {@link SmplManagementClient}. */
+interface SmplManagementClientOptions {
+    /** API key. Resolves from `SMPLKIT_API_KEY` / `~/.smplkit` if omitted. */
+    apiKey?: string;
+    /** Configuration profile to use from `~/.smplkit`. Default `"default"`. */
+    profile?: string;
+    /** Base domain for service URLs. Default `"smplkit.com"`. */
+    baseDomain?: string;
+    /** URL scheme. Default `"https"`. */
+    scheme?: string;
+    /** Enable debug logging to stderr. */
+    debug?: boolean;
+}
+/**
+ * Standalone management/CRUD entry point — zero construction side effects.
+ *
+ * Construction does **not**:
+ *   - register the service or environment as context instances
+ *   - start a metrics thread
+ *   - open the WebSocket
+ *   - install logger discovery
+ *
+ * Use this for setup scripts, CI, admin tooling, and one-off CRUD.
+ *
+ * @example
+ * ```typescript
+ * import { SmplManagementClient } from "@smplkit/sdk";
+ *
+ * const mgmt = new SmplManagementClient();
+ * const env = mgmt.environments.new("production", { name: "Production" });
+ * await env.save();
+ * await mgmt.close();
+ * ```
+ */
+declare class SmplManagementClient {
+    /** Context entity CRUD. */
+    readonly contexts: ContextsClient;
+    /** Context-type schemas. */
+    readonly contextTypes: ContextTypesClient;
+    /** Environment CRUD. */
+    readonly environments: EnvironmentsClient;
+    /** Account-level settings. */
+    readonly accountSettings: AccountSettingsClient;
+    /** Config CRUD (singular — matches runtime `client.config`). */
+    readonly config: ManagementConfigClient;
+    /** Flag CRUD + bulk registration. */
+    readonly flags: ManagementFlagsClient;
+    /** Logger CRUD + bulk registration. */
+    readonly loggers: LoggersClient;
+    /** Log group CRUD. */
+    readonly logGroups: LogGroupsClient;
+    /** @internal — shared HTTP transports (so SmplClient can alias them). */
+    readonly _appHttp: AppHttp;
+    /** @internal */
+    readonly _configHttp: ConfigHttp;
+    /** @internal */
+    readonly _flagsHttp: FlagsHttp;
+    /** @internal */
+    readonly _loggingHttp: LoggingHttp;
+    constructor(options?: SmplManagementClientOptions);
+    private _contextsRef;
+    private _contextTypesRef;
+    private _environmentsRef;
+    private _accountSettingsRef;
+    private _configRef;
+    private _flagsRef;
+    private _loggersRef;
+    private _logGroupsRef;
+    private _appHttpRef;
+    private _configHttpRef;
+    private _flagsHttpRef;
+    private _loggingHttpRef;
+    private _sharedContextBuffer;
+    private _init;
+    /** @internal — used by SmplClient to share the buffer. */
+    get _contextBuffer(): ContextRegistrationBuffer;
+    /** Release resources. Drains pending bulk registrations one last time. */
+    close(): Promise<void>;
+}
+
+/**
+ * Describes a single config value change detected on refresh. Frozen —
+ * fields are set at construction and cannot be mutated afterward.
+ */
+declare class ConfigChangeEvent {
+    /** The config id that changed. */
+    readonly configId: string;
+    /** The item key within the config that changed. */
+    readonly itemKey: string;
+    /** The previous value (null if the key was absent). */
+    readonly oldValue: unknown;
+    /** The updated value (null if the key was removed). */
+    readonly newValue: unknown;
+    /** How the change was delivered. */
+    readonly source: "websocket" | "manual";
+    constructor(fields: {
+        configId: string;
+        itemKey: string;
+        oldValue: unknown;
+        newValue: unknown;
+        source: "websocket" | "manual";
+    });
+}
+/**
+ * Runtime client for the smplkit Config service.
+ *
+ * Obtained via `SmplClient.config`. Provides live config values, change
+ * listeners, and lazy initialization. Management/CRUD lives on
+ * `SmplClient.manage.config` (or use a standalone {@link SmplManagementClient}).
+ */
+declare class ConfigClient {
+    /** @internal */
+    readonly _apiKey: string;
+    /** @internal */
+    readonly _baseUrl: string;
+    /** @internal */
+    private readonly _http;
+    /** @internal — returns the shared WebSocket for real-time updates. */
+    _getSharedWs?: () => SharedWebSocket;
+    /** @internal — set by SmplClient after construction. */
+    _parent: {
+        readonly _environment: string;
+        readonly _service: string | null;
+        readonly _metrics: MetricsReporter | null;
+    } | null;
+    /** @internal — resolves the management config sub-client used by lazy-init/refresh. */
+    _resolveManagement?: () => SmplManagementClient;
+    private _configCache;
+    private _initialized;
+    private _listeners;
+    /** @internal */
+    constructor(apiKey: string, timeout?: number, baseUrl?: string);
+    /**
+     * Return a live, dict-like view of the resolved values for *id*.
+     *
+     * Without `model`, returns a {@link LiveConfigProxy} that behaves like a
+     * `Record<string, unknown>` (`proxy["key"]`, iteration, `proxy.items()`,
+     * `Object.keys(proxy)`) and updates automatically as the server pushes
+     * changes.
+     *
+     * With `model`, the return value type-checks as `model` — attribute
+     * access (`cfg.database.host`) walks a model rebuilt from the current
+     * values on each read, so the customer sees the model's type signature
+     * in their IDE while still tracking live data.
+     *
+     * Mirrors Python's `client.config.get(id)` / `client.config.get(id, ModelCls)`.
+     * There is no `subscribe()` — it was unified into `get()`.
+     */
+    get<T = Record<string, unknown>>(id: string, model?: new (data: any) => T): Promise<LiveConfigProxy<T>>;
+    /**
+     * Register a change listener.
+     *
+     * - `onChange(callback)` — fires for any config change (global).
+     * - `onChange(configId, callback)` — fires for changes to a specific config.
+     * - `onChange(configId, itemKey, callback)` — fires for a specific item.
+     */
+    onChange(callbackOrConfigId: string | ((event: ConfigChangeEvent) => void), callbackOrItemKey?: string | ((event: ConfigChangeEvent) => void), callback?: (event: ConfigChangeEvent) => void): void;
+    /**
+     * Refresh all config values from the server.
+     * Fires change listeners for any values that changed.
+     */
+    refresh(): Promise<void>;
+    /**
+     * @internal — fetch the full config list. Prefers the management plane
+     * (set via `_resolveManagement`) so runtime + management share one HTTP
+     * client; falls back to a direct GET when running without `SmplClient`
+     * bootstrap (e.g. unit tests that construct `ConfigClient` directly).
+     */
+    private _listConfigs;
+    /**
+     * Eagerly initialize the config subclient — fetch all configs, resolve
+     * environment-scoped values into the local cache, and subscribe to the
+     * shared WebSocket for live updates. Idempotent. Called automatically
+     * on first `client.config.get(...)` if not invoked manually.
+     */
+    start(): Promise<void>;
+    /** @internal */
+    private _ensureInitialized;
+    /** @internal — called by SmplClient for backward compat. */
+    _connectInternal(environment: string): Promise<void>;
+    /** @internal — get resolved config from cache. Used by LiveConfigProxy. */
+    _getCachedConfig(key: string): Record<string, unknown> | undefined;
+    private _handleConfigChanged;
+    private _handleConfigDeleted;
+    private _handleConfigsChanged;
+    /** Fetch a single config by key. Returns null if not found. @internal */
+    private _fetchSingleConfig;
+    /** Resolve a config's values for an environment (no parent chain). @internal */
+    private _resolveConfigValues;
+    /** @internal */
+    private _diffAndFire;
+}
+
 /**
  * Contract for logging framework adapters.
  */
@@ -1315,52 +2504,12 @@ interface LoggingAdapter {
 }
 
 /**
- * LoggingClient — management and runtime for Smpl Logging.
- */
-
-/**
- * Management API for smplkit Logging — CRUD operations on Logger and LogGroup models.
- *
- * Access via `SmplClient.logging.management`.
- */
-declare class LoggingManagement {
-    private readonly _client;
-    constructor(_client: LoggingClient);
-    /** Create an unsaved logger. Call `.save()` to persist. */
-    new(id: string, options?: {
-        name?: string;
-        managed?: boolean;
-    }): Logger;
-    /** Fetch a logger by id. */
-    get(id: string): Promise<Logger>;
-    /** List all loggers. */
-    list(): Promise<Logger[]>;
-    /** Delete a logger by id. */
-    delete(id: string): Promise<void>;
-    /** Create an unsaved log group. Call `.save()` to persist. */
-    newGroup(id: string, options?: {
-        name?: string;
-        group?: string;
-    }): LogGroup;
-    /** Fetch a log group by id. */
-    getGroup(id: string): Promise<LogGroup>;
-    /** List all log groups. */
-    listGroups(): Promise<LogGroup[]>;
-    /** Delete a log group by id. */
-    deleteGroup(id: string): Promise<void>;
-    /**
-     * Bulk-register explicit logger sources with the logging service.
-     *
-     * Unlike `start()`, which auto-discovers loggers from the current
-     * process, this method accepts explicit `service` and `environment`
-     * overrides — useful for sample-data seeding and test fixtures.
-     */
-    registerSources(sources: LoggerSource[]): Promise<void>;
-}
-/**
- * Client for the smplkit Logging API.
+ * Runtime client for the smplkit Logging service.
  *
- * Obtained via `SmplClient.logging`.
+ * Obtained via `SmplClient.logging`. Provides adapter integration, level
+ * resolution, and live-updates for logger/group changes. Management/CRUD
+ * lives on `SmplClient.manage.loggers` / `SmplClient.manage.logGroups` (or
+ * use a standalone {@link SmplManagementClient}).
  */
 declare class LoggingClient {
     /** @internal */
@@ -1375,8 +2524,8 @@ declare class LoggingClient {
         readonly _service: string | null;
         readonly _metrics: MetricsReporter | null;
     } | null;
-    /** Management API — CRUD operations on Logger and LogGroup models. */
-    readonly management: LoggingManagement;
+    /** @internal — resolves the management plane sub-clients used by install/refresh. */
+    _resolveManagement?: () => SmplManagementClient;
     private readonly _ensureWs;
     private _wsManager;
     private _started;
@@ -1397,42 +2546,34 @@ declare class LoggingClient {
      * registered adapters will be used.
      */
     registerAdapter(adapter: LoggingAdapter): void;
-    /** @internal */
-    _mgNew(id: string, options?: {
-        name?: string;
-        managed?: boolean;
-    }): Logger;
-    /** @internal */
-    _mgGet(id: string): Promise<Logger>;
-    /** @internal */
-    _mgList(): Promise<Logger[]>;
-    /** @internal */
-    _mgDelete(id: string): Promise<void>;
-    /** @internal */
-    _mgNewGroup(id: string, options?: {
-        name?: string;
-        group?: string;
-    }): LogGroup;
-    /** @internal */
-    _mgGetGroup(id: string): Promise<LogGroup>;
-    /** @internal */
-    _mgListGroups(): Promise<LogGroup[]>;
-    /** @internal */
-    _mgRegisterSources(sources: LoggerSource[]): Promise<void>;
-    /** @internal */
-    _mgDeleteGroup(id: string): Promise<void>;
-    /** @internal — PUT a logger (upsert: server creates if not found). */
-    _saveLogger(logger: Logger): Promise<Logger>;
-    /** @internal — POST or PUT a log group. */
-    _saveLogGroup(group: LogGroup): Promise<LogGroup>;
     /**
-     * Start the logging runtime.
+     * @internal — fetch the full logger list. Prefers the management plane
+     * (set via `_resolveManagement`); falls back to a direct GET when running
+     * without `SmplClient` bootstrap (e.g. unit tests that construct
+     * `LoggingClient` directly).
+     */
+    private _listLoggers;
+    /** @internal — see {@link _listLoggers}. */
+    private _listLogGroups;
+    /**
+     * Install the smplkit logging integration into the running process.
      *
-     * Synchronizes loggers with the server and subscribes to live level
-     * updates. Idempotent — safe to call multiple times.
-     * Management methods work without calling `start()`.
+     * Loads any adapters that haven't been registered explicitly, discovers
+     * existing loggers from each adapter, hooks new-logger creation, and
+     * subscribes to live level updates over the shared WebSocket. Idempotent —
+     * safe to call multiple times. Management methods work without calling
+     * `install()`.
+     *
+     * Mirrors Python's `client.logging.install()`. There is no `stop()`.
+     */
+    install(): Promise<void>;
+    /**
+     * @deprecated Use {@link LoggingClient.install}. Retained as a backwards-
+     * compatible alias.
      */
     start(): Promise<void>;
+    /** @internal — shared body of install()/start(). */
+    _installInternal(): Promise<void>;
     /**
      * Register a change listener.
      *
@@ -1459,289 +2600,12 @@ declare class LoggingClient {
     private _fetchSingleLogger;
     /** Fetch a single log group by key. Returns null if not found. @internal */
     private _fetchSingleGroup;
+    /** @internal — runtime models are read-only (no save/delete). */
     private _loggerToModel;
+    /** @internal — runtime models are read-only (no save/delete). */
     private _groupToModel;
 }
 
-/**
- * Shared types for the management namespace.
- */
-/** Whether an environment participates in the canonical ordering.
- *
- * STANDARD environments are the customer's deploy targets (production,
- * staging, development, etc.) and appear in the environment_order list.
- * AD_HOC environments are transient targets (preview branches,
- * developer sandboxes) that are excluded from the standard ordering.
- */
-declare enum EnvironmentClassification {
-    STANDARD = "STANDARD",
-    AD_HOC = "AD_HOC"
-}
-
-/**
- * Active-record models for client.management.* resources.
- */
-
-/**
- * An environment resource managed by the smplkit platform.
- *
- * Mutate fields, then call `save()` to create or update.
- */
-declare class Environment {
-    /** Unique slug identifier (e.g. `"production"`). */
-    id: string | null;
-    /** Human-readable display name. */
-    name: string;
-    /** Hex color code, or null. */
-    color: string | null;
-    /** Whether this is a STANDARD or AD_HOC environment. */
-    classification: EnvironmentClassification;
-    /** When the environment was created. */
-    createdAt: string | null;
-    /** When the environment was last updated. */
-    updatedAt: string | null;
-    /** @internal */
-    readonly _client: EnvironmentsClient | null;
-    /** @internal */
-    constructor(client: EnvironmentsClient | null, fields: {
-        id: string | null;
-        name: string;
-        color: string | null;
-        classification: EnvironmentClassification;
-        createdAt: string | null;
-        updatedAt: string | null;
-    });
-    /** Persist this environment to the server (creates if new, updates if existing). */
-    save(): Promise<void>;
-    /** @internal */
-    _apply(other: Environment): void;
-    toString(): string;
-}
-/**
- * A context-type resource managed by the smplkit platform.
- *
- * Mutate fields or use `addAttribute`/`removeAttribute`/`updateAttribute`,
- * then call `save()` to persist.
- */
-declare class ContextType {
-    /** Unique slug identifier (e.g. `"user"`). */
-    id: string | null;
-    /** Human-readable display name. */
-    name: string;
-    /** Known attribute keys with metadata objects. */
-    attributes: Record<string, Record<string, any>>;
-    /** When the context type was created. */
-    createdAt: string | null;
-    /** When the context type was last updated. */
-    updatedAt: string | null;
-    /** @internal */
-    readonly _client: ContextTypesClient | null;
-    /** @internal */
-    constructor(client: ContextTypesClient | null, fields: {
-        id: string | null;
-        name: string;
-        attributes: Record<string, Record<string, any>>;
-        createdAt: string | null;
-        updatedAt: string | null;
-    });
-    /** Add a known-attribute slot. Local; call `save()` to persist. */
-    addAttribute(name: string, metadata?: Record<string, any>): void;
-    /** Remove a known-attribute slot. Local; call `save()` to persist. */
-    removeAttribute(name: string): void;
-    /** Replace a known-attribute slot's metadata. Local; call `save()` to persist. */
-    updateAttribute(name: string, metadata: Record<string, any>): void;
-    /** Persist this context type to the server (creates if new, updates if existing). */
-    save(): Promise<void>;
-    /** @internal */
-    _apply(other: ContextType): void;
-    toString(): string;
-}
-/**
- * A context instance as returned by the management API.
- *
- * The write path is `client.management.contexts.register([...])`.
- * This model is what comes back from `list`/`get`.
- */
-declare class ContextEntity {
-    /** Context type key (e.g. `"user"`). */
-    type: string;
-    /** Entity key (e.g. `"user-123"`). */
-    key: string;
-    /** Human-readable display name, or null. */
-    name: string | null;
-    /** Observed attributes. */
-    attributes: Record<string, any>;
-    /** When the context was created. */
-    createdAt: string | null;
-    /** When the context was last updated. */
-    updatedAt: string | null;
-    /** @internal */
-    constructor(fields: {
-        type: string;
-        key: string;
-        name: string | null;
-        attributes: Record<string, any>;
-        createdAt: string | null;
-        updatedAt: string | null;
-    });
-    /** Composite `"type:key"` identifier. */
-    get id(): string;
-    toString(): string;
-}
-/**
- * Active-record account-settings model.
- *
- * The wire format is opaque JSON. Documented keys are exposed as typed
- * properties; unknown keys live in `raw`. Call `save()` to write back.
- */
-declare class AccountSettings {
-    /** @internal */
-    private _data;
-    /** @internal */
-    readonly _client: AccountSettingsClient | null;
-    /** @internal */
-    constructor(client: AccountSettingsClient | null, data: Record<string, any>);
-    /** The full settings dict. Direct mutations are reflected in `save()`. */
-    get raw(): Record<string, any>;
-    set raw(value: Record<string, any>);
-    /** Canonical ordering of STANDARD environments. Empty array if unset. */
-    get environmentOrder(): string[];
-    set environmentOrder(value: string[]);
-    /** Persist the settings to the server. */
-    save(): Promise<void>;
-    /** @internal */
-    _apply(other: AccountSettings): void;
-    /** @internal — expose raw data for _save(). */
-    get _rawData(): Record<string, any>;
-    toString(): string;
-}
-
-type AppClient = ReturnType<typeof createClient<___generated_app_d_ts.paths>>;
-/**
- * CRUD client for environments.
- *
- * Accessed via `client.management.environments`.
- */
-declare class EnvironmentsClient {
-    private readonly _http;
-    /** @internal */
-    constructor(_http: AppClient);
-    /**
-     * Return an unsaved `Environment`. Call `.save()` to persist.
-     */
-    new(id: string, options: {
-        name: string;
-        color?: string | null;
-        classification?: EnvironmentClassification;
-    }): Environment;
-    /** List all environments. */
-    list(): Promise<Environment[]>;
-    /** Fetch an environment by id. */
-    get(id: string): Promise<Environment>;
-    /** Delete an environment by id. */
-    delete(id: string): Promise<void>;
-    /** @internal — called by Environment.save() for new resources. */
-    _create(env: Environment): Promise<Environment>;
-    /** @internal — called by Environment.save() for existing resources. */
-    _update(env: Environment): Promise<Environment>;
-}
-/**
- * CRUD client for context types.
- *
- * Accessed via `client.management.context_types`.
- */
-declare class ContextTypesClient {
-    private readonly _http;
-    /** @internal */
-    constructor(_http: AppClient);
-    /**
-     * Return an unsaved `ContextType`. Call `.save()` to persist.
-     */
-    new(id: string, options?: {
-        name?: string;
-        attributes?: Record<string, Record<string, any>>;
-    }): ContextType;
-    /** List all context types. */
-    list(): Promise<ContextType[]>;
-    /** Fetch a context type by id. */
-    get(id: string): Promise<ContextType>;
-    /** Delete a context type by id. */
-    delete(id: string): Promise<void>;
-    /** @internal — called by ContextType.save() for new resources. */
-    _create(ct: ContextType): Promise<ContextType>;
-    /** @internal — called by ContextType.save() for existing resources. */
-    _update(ct: ContextType): Promise<ContextType>;
-}
-/**
- * Context registration + read/delete client.
- *
- * Accessed via `client.management.contexts`.
- */
-declare class ContextsClient {
-    private readonly _http;
-    private readonly _buffer;
-    /** @internal */
-    constructor(_http: AppClient, _buffer: ContextRegistrationBuffer);
-    /**
-     * Buffer context(s) for registration; optionally flush immediately.
-     *
-     * When `flush` is false (default), contexts are queued for the SDK's
-     * background flush — right for high-frequency observation from a live
-     * request handler. When `flush` is true the call awaits the round-trip
-     * — right for IaC scripts.
-     */
-    register(items: Context | Context[], options?: {
-        flush?: boolean;
-    }): Promise<void>;
-    /** Send any pending context observations to the server. */
-    flush(): Promise<void>;
-    /** List all contexts of a given type. */
-    list(type: string): Promise<ContextEntity[]>;
-    /** Fetch a context by composite id (`"type:key"`) or by separate type and key. */
-    get(idOrType: string, key?: string): Promise<ContextEntity>;
-    /** Delete a context by composite id (`"type:key"`) or by separate type and key. */
-    delete(idOrType: string, key?: string): Promise<void>;
-}
-/**
- * Account-settings get/save client.
- *
- * The settings endpoint is not JSON:API — body is a raw JSON object — so
- * we use fetch directly rather than the typed openapi-fetch client.
- *
- * Accessed via `client.management.account_settings`.
- */
-declare class AccountSettingsClient {
-    private readonly _appBaseUrl;
-    private readonly _headers;
-    /** @internal */
-    constructor(_appBaseUrl: string, apiKey: string);
-    /** Fetch the current account settings. */
-    get(): Promise<AccountSettings>;
-    /** @internal — called by AccountSettings.save(). */
-    _save(data: Record<string, any>): Promise<AccountSettings>;
-}
-/**
- * Top-level management namespace.
- *
- * Accessed via `client.management`.
- */
-declare class ManagementClient {
-    /** CRUD for environments. */
-    readonly environments: EnvironmentsClient;
-    /** Registration, list, get, and delete for context instances. */
-    readonly contexts: ContextsClient;
-    /** CRUD for context types (entity schemas). */
-    readonly context_types: ContextTypesClient;
-    /** Get/save for account-level settings. */
-    readonly account_settings: AccountSettingsClient;
-    /** @internal */
-    constructor(options: {
-        appBaseUrl: string;
-        apiKey: string;
-        buffer: ContextRegistrationBuffer;
-    });
-}
-
 /**
  * Top-level SDK client — SmplClient.
  *
@@ -1834,8 +2698,12 @@ declare class SmplClient {
     readonly flags: FlagsClient;
     /** Client for logging management and runtime. */
     readonly logging: LoggingClient;
-    /** Client for app-plane management (environments, contexts, context types, account settings). */
-    readonly management: ManagementClient;
+    /**
+     * Standalone management/CRUD entry point — mirrors Python's
+     * `client.manage`. Construction is side-effect-free; safe to use even
+     * when the runtime plane is dormant.
+     */
+    readonly manage: SmplManagementClient;
     private _wsManager;
     private readonly _apiKey;
     /** @internal */
@@ -1852,6 +2720,28 @@ declare class SmplClient {
     private _registerServiceContext;
     /** Lazily create and start the shared WebSocket. @internal */
     private _ensureWs;
+    /**
+     * Eagerly initialize the SDK and wait until it is fully ready.
+     *
+     * Pre-fetches all flags and configs into the local cache, opens the
+     * live-updates WebSocket, and waits for the handshake to complete.
+     * After this returns, `flag.get()` / `client.config.get()` hit cache
+     * (no first-request connect tax) and any `onChange` listeners receive
+     * every server event from this point forward.
+     *
+     * Logging integration is _not_ installed here — call
+     * `client.logging.install()` separately if you want it (it installs
+     * adapters and hooks into your application's logger, which should be
+     * opt-in).
+     *
+     * Mirrors Python's `await client.wait_until_ready()`.
+     *
+     * @throws SmplTimeoutError If the WebSocket fails to connect within
+     *   `timeoutMs` milliseconds.
+     */
+    waitUntilReady(options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
     /** Close the shared WebSocket and release resources. */
     close(): void;
 }
@@ -1911,12 +2801,16 @@ declare class PinoAdapter implements LoggingAdapter {
 /**
  * Structured SDK error types.
  *
- * All smplkit errors extend {@link SmplError}, allowing callers to catch
- * the base class for generic handling or specific subclasses for
- * fine-grained control.
+ * All smplkit errors extend {@link SmplError}. The TypeScript SDK keeps
+ * the `Smpl` prefix on its public error names because TypeScript's
+ * built-in `Error`/`TypeError`/etc. preclude bare names. The Python
+ * canonical names (`Error`, `NotFoundError`, ...) line up via
+ * `Smpl{X}Error` ↔ Python `{X}Error`. The `Smplkit{X}Error` names are
+ * exported as aliases (introduced in PR #103) for callers that prefer
+ * the longer prefix.
  */
 /** A single error object from a JSON:API error response. */
-interface ApiErrorObject {
+interface ApiErrorDetail {
     status?: string;
     title?: string;
     detail?: string;
@@ -1929,29 +2823,32 @@ declare class SmplError extends Error {
     /** The raw response body, if available. */
     readonly responseBody?: string;
     /** Structured JSON:API error objects from the server response, if available. */
-    readonly errors: ReadonlyArray<ApiErrorObject>;
-    constructor(message: string, statusCode?: number, responseBody?: string, errors?: ApiErrorObject[]);
+    readonly errors: ReadonlyArray<ApiErrorDetail>;
+    constructor(message: string, statusCode?: number, responseBody?: string, errors?: ApiErrorDetail[]);
     toString(): string;
 }
 /** Raised when a network request fails (e.g., DNS resolution, connection refused). */
 declare class SmplConnectionError extends SmplError {
-    constructor(message: string, statusCode?: number, responseBody?: string, errors?: ApiErrorObject[]);
+    constructor(message: string, statusCode?: number, responseBody?: string, errors?: ApiErrorDetail[]);
 }
 /** Raised when an operation exceeds its timeout. */
 declare class SmplTimeoutError extends SmplError {
-    constructor(message: string, statusCode?: number, responseBody?: string, errors?: ApiErrorObject[]);
+    constructor(message: string, statusCode?: number, responseBody?: string, errors?: ApiErrorDetail[]);
 }
 /** Raised when a requested resource does not exist (HTTP 404). */
 declare class SmplNotFoundError extends SmplError {
-    constructor(message: string, statusCode?: number, responseBody?: string, errors?: ApiErrorObject[]);
+    constructor(message: string, statusCode?: number, responseBody?: string, errors?: ApiErrorDetail[]);
 }
 /** Raised when an operation conflicts with current state (HTTP 409). */
 declare class SmplConflictError extends SmplError {
-    constructor(message: string, statusCode?: number, responseBody?: string, errors?: ApiErrorObject[]);
+    constructor(message: string, statusCode?: number, responseBody?: string, errors?: ApiErrorDetail[]);
 }
-/** Raised when the server rejects a request due to validation errors (HTTP 422). */
+/** Raised when the server rejects a request due to validation errors (HTTP 400/422). */
 declare class SmplValidationError extends SmplError {
-    constructor(message: string, statusCode?: number, responseBody?: string, errors?: ApiErrorObject[]);
+    constructor(message: string, statusCode?: number, responseBody?: string, errors?: ApiErrorDetail[]);
 }
 
-export { AccountSettings, AccountSettingsClient, type ApiErrorObject, BooleanFlag, Config, type ConfigChangeEvent, ConfigClient, ConfigManagement, Context, ContextEntity, ContextType, ContextTypesClient, ContextsClient, Environment, EnvironmentClassification, EnvironmentsClient, Flag, FlagChangeEvent, FlagStats, FlagsClient, FlagsManagement, JsonFlag, LiveConfigProxy, LogGroup, LogLevel, Logger, type LoggerChangeEvent, LoggerSource, type LoggingAdapter, LoggingClient, LoggingManagement, ManagementClient, NumberFlag, PinoAdapter, type PinoAdapterConfig, Rule, SharedWebSocket, SmplClient, type SmplClientOptions, SmplConflictError, SmplConnectionError, SmplError, SmplNotFoundError, SmplTimeoutError, SmplValidationError, StringFlag, WinstonAdapter, type WinstonAdapterConfig };
+/** @deprecated Use {@link ApiErrorDetail}. */
+type ApiErrorObject = ApiErrorDetail;
+
+export { AccountSettings, AccountSettingsClient, type ApiErrorDetail, type ApiErrorObject, BooleanFlag, Color, Config, ConfigChangeEvent, ConfigClient, ConfigEnvironment, ConfigItem, Context, ContextType, ContextTypesClient, ContextsClient, Environment, EnvironmentClassification, EnvironmentsClient, Flag, FlagChangeEvent, FlagDeclaration, FlagEnvironment, FlagRule, FlagStats, FlagValue, FlagsClient, ItemType, JsonFlag, LiveConfigProxy, LogGroup, LogLevel, Logger, LoggerChangeEvent, LoggerEnvironment, LoggerSource, type LoggingAdapter, LoggingClient, NumberFlag, Op, PinoAdapter, type PinoAdapterConfig, Rule, SharedWebSocket, SmplClient, type SmplClientOptions, SmplConflictError, SmplConnectionError, SmplError, SmplManagementClient, type SmplManagementClientOptions, SmplNotFoundError, SmplTimeoutError, SmplValidationError, SmplConflictError as SmplkitConflictError, SmplConnectionError as SmplkitConnectionError, SmplError as SmplkitError, SmplNotFoundError as SmplkitNotFoundError, SmplTimeoutError as SmplkitTimeoutError, SmplValidationError as SmplkitValidationError, StringFlag, WinstonAdapter, type WinstonAdapterConfig };