@nice-code/error 0.7.0 → 0.9.0

package/build/index.d.ts

@@ -0,0 +1,913 @@
+//#region src/utils/packError/packError.enums.d.ts
+declare enum EErrorPackType {
+  no_pack = "no_pack",
+  msg_pack = "msg_pack",
+  cause_pack = "cause_pack"
+}
+//#endregion
+//#region src/NiceError/NiceError.enums.d.ts
+declare enum EContextSerializedState {
+  serde_unset = "serde_unset",
+  unhydrated = "unhydrated",
+  hydrated = "hydrated"
+}
+//#endregion
+//#region src/NiceError/NiceError.types.d.ts
+interface IRegularErrorJsonObject extends Omit<Error, "stack"> {
+  name: string;
+  message: string;
+  stack?: string | undefined;
+  cause?: unknown;
+}
+type JSONSerializableValue = string | number | boolean | null | {
+  [key: string]: JSONSerializableValue;
+} | JSONSerializableValue[];
+interface ISerializationDefinition<C, D extends JSONSerializableValue> {
+  toJsonSerializable: (context: C) => D;
+  fromJsonSerializable: (obj: D) => C;
+}
+/** Describes the context attached to a single error id. */
+interface INiceErrorContextDefinition<C, D extends JSONSerializableValue = JSONSerializableValue> {
+  required?: boolean;
+  serialization?: ISerializationDefinition<C, D>;
+}
+/**
+ * A single entry in a NiceErrorDefined schema.
+ * `C` is the context value type (defaults to `never` = no context).
+ */
+interface INiceErrorIdMetadata<C = never, D extends JSONSerializableValue = JSONSerializableValue> {
+  context?: [C] extends [never] ? never : INiceErrorContextDefinition<C, D>;
+  /** Static message string OR a function that receives the context value and returns a string. */
+  message?: [C] extends [never] ? string : string | ((context: C) => string);
+  httpStatusCode?: [C] extends [never] ? number : number | ((context: C) => number);
+}
+/** A record mapping error-id string keys to their metadata. */
+type TNiceErrorSchema = Record<string, INiceErrorIdMetadata<any>>;
+/** Extracts the raw context value type `C` from a single schema entry. */
+type TExtractContextType<M> = M extends INiceErrorIdMetadata<infer C> ? C : never;
+/**
+ * Given a schema entry M, returns the context argument type expected by `fromId`:
+ *
+ * - `C = never`                     → `undefined`  (no context field on this id)
+ * - `C` defined, `required: true`   → `C`          (context is a required argument)
+ * - `C` defined, `required` absent/false → `C | undefined` (context is optional)
+ *
+ * Note: `required: true` must be a literal `true` for TypeScript to narrow correctly.
+ * Use the `err()` helper (which preserves literal types) rather than writing schema
+ * entries inline without `as const`.
+ */
+type ExtractFromIdContextArg<M> = M extends INiceErrorIdMetadata<infer C> ? [C] extends [never] ? undefined : M extends {
+  context: {
+    required: true;
+  };
+} ? C : C | undefined : undefined;
+/**
+ * No custom serializer is defined for this error id's context.
+ * `value` holds the typed context directly (plain JSON-safe value, or `undefined`
+ * if the context was optional and not provided).
+ *
+ * This state is safe across a JSON round-trip because no type information is lost.
+ */
+type TContextStateNoSerialization<C> = {
+  kind: EContextSerializedState.serde_unset; /** The typed context value (or `undefined` if optional and not provided). */
+  value: C | undefined;
+};
+/**
+ * A custom serializer is defined, but the context has **not** been deserialized
+ * from its JSON-wire form yet.
+ *
+ * This state occurs after `castNiceError` reconstructs an error from a serialized
+ * payload. `value` is absent — the raw serialized representation is in `serialized`.
+ *
+ * Call `niceErrorDefined.hydrate(error)` to reconstruct the typed context via
+ * `fromJsonSerializable` and advance to the `"hydrated"` state.
+ */
+type TContextStateUnhydrated = {
+  kind: EContextSerializedState.unhydrated; /** The JSON-serializable representation of the original context. */
+  serialized: JSONSerializableValue;
+};
+/**
+ * A custom serializer is defined, and the context is fully deserialized to its
+ * original typed value.
+ *
+ * This state is set when the error is first created via `fromId`/`fromContext`,
+ * or after `niceErrorDefined.hydrate(error)` reconstructs it.
+ *
+ * Note: `toJsonObject()` intentionally downgrades this to `"unhydrated"` on
+ * output so the flag cannot survive a JSON round-trip as a false positive.
+ */
+type TContextStateHydrated<C> = {
+  kind: EContextSerializedState.hydrated; /** The typed context value — the original value as provided at error creation. */
+  value: C; /** The JSON-serializable representation (produced by `toJsonSerializable`). */
+  serialized: JSONSerializableValue;
+};
+/**
+ * Runtime context state — union of all three lifecycle states.
+ * Stored in `_errorDataMap` on a live `NiceError` instance.
+ */
+type TContextState<C> = TContextStateNoSerialization<C> | TContextStateUnhydrated | TContextStateHydrated<C>;
+/**
+ * Wire-safe context state — excludes `"hydrated"` because `toJsonObject()` downgrades
+ * it to `"unhydrated"` before serialization. This is the only state that appears in
+ * `INiceErrorJsonObject` and on errors reconstructed via `castNiceError`.
+ */
+type TSerializedContextState<C> = TContextStateNoSerialization<C> | TContextStateUnhydrated;
+/**
+ * Runtime reconciled data for a single error id, stored in `_errorDataMap`.
+ * Uses the full `TContextState` union (including `"hydrated"`).
+ */
+type TErrorReconciledData<SCHEMA extends TNiceErrorSchema, K extends keyof SCHEMA> = {
+  contextState: TContextState<TExtractContextType<SCHEMA[K]>>;
+  message: string;
+  httpStatusCode: number;
+  timeAdded: number;
+};
+/**
+ * Wire-safe reconciled data — uses `TSerializedContextState` (no `"hydrated"`).
+ * This is the shape stored in `INiceErrorJsonObject.errorData` and transmitted
+ * over the wire. `"hydrated"` is excluded so that the serialization state can
+ * never be trusted after a JSON round-trip.
+ */
+type TSerializedErrorReconciledData<SCHEMA extends TNiceErrorSchema, K extends TSchemaNiceErrorId<SCHEMA>> = {
+  contextState: TSerializedContextState<TExtractContextType<SCHEMA[K]>>;
+  message: string;
+  httpStatusCode: number;
+  timeAdded: number;
+};
+type TErrorDataForIdMap<SCHEMA extends TNiceErrorSchema, K extends TSchemaNiceErrorId<SCHEMA> = TSchemaNiceErrorId<SCHEMA>> = { [key in K]?: TErrorReconciledData<SCHEMA, K> };
+/** Wire-safe version of `TErrorDataForIdMap`. Used in `INiceErrorJsonObject`. */
+type TSerializedErrorDataMap<SCHEMA extends TNiceErrorSchema> = { [K in TSchemaNiceErrorId<SCHEMA>]?: TSerializedErrorReconciledData<SCHEMA, K> };
+/**
+ * The Partial record that `fromContext` accepts: callers supply one or more
+ * { [errorId]: contextValue } entries and NiceError stores them all.
+ */
+type TFromContextInput<SCHEMA extends TNiceErrorSchema> = { [K in TSchemaNiceErrorId<SCHEMA>]?: TExtractContextType<SCHEMA[K]> | undefined };
+/**
+ * Resolves the args tuple for `fromId` / `addId`:
+ *
+ * - No context on this id                  → `[id]`
+ * - Context defined, `required: true`      → `[id, context]`
+ * - Context defined, `required` absent/false → `[id] | [id, context]`
+ */
+type FromIdArgs<ERR_DEF extends INiceErrorDomainProps, K extends TDomainNiceErrorId<ERR_DEF>> = [ExtractFromIdContextArg<ERR_DEF["schema"][K]>] extends [undefined] ? [id: K] : [undefined] extends [ExtractFromIdContextArg<ERR_DEF["schema"][K]>] ? [id: K] | [id: K, context: NonNullable<ExtractFromIdContextArg<ERR_DEF["schema"][K]>>] : [id: K, context: ExtractFromIdContextArg<ERR_DEF["schema"][K]>];
+interface IPackErrorAs_Base {
+  packAs: EErrorPackType;
+}
+interface IPackErrorAs_MatchEnvVar extends IPackErrorAs_Base {
+  matchEnvVar: string;
+}
+interface IDefineNewNiceErrorDomainOptions<ERR_DOMAIN extends string = string, SCHEMA extends TNiceErrorSchema = TNiceErrorSchema> {
+  defaultHttpStatusCode?: number;
+  defaultMessage?: string;
+  packAs?: () => EErrorPackType | void;
+  domain: ERR_DOMAIN;
+  schema: SCHEMA;
+}
+interface INiceErrorDomainProps<ERR_DOMAINS extends string[] = string[], SCHEMA extends TNiceErrorSchema = TNiceErrorSchema> {
+  packAs?: () => EErrorPackType | void;
+  defaultHttpStatusCode?: number;
+  defaultMessage?: string;
+  domain: ERR_DOMAINS[number];
+  allDomains: ERR_DOMAINS;
+  schema: SCHEMA;
+}
+interface INiceErrorJsonObject<ERR_DEF extends INiceErrorDomainProps = INiceErrorDomainProps, ID extends TDomainNiceErrorId<ERR_DEF> = TDomainNiceErrorId<ERR_DEF>> {
+  name: "NiceError";
+  def: Omit<ERR_DEF, "schema">;
+  ids: ID[];
+  /** Wire-safe error data — context is in `"raw_unset"` or `"unhydrated"` state only. */
+  errorData: TSerializedErrorDataMap<ERR_DEF["schema"]>;
+  wasntNice: boolean;
+  message: string;
+  httpStatusCode: number;
+  /** The stack trace of the NiceError at the point it was created. */
+  stack?: string;
+  cause?: unknown;
+  originError?: IRegularErrorJsonObject | undefined;
+  timeCreated: number;
+}
+type TSchemaNiceErrorId<SCHEMA extends TNiceErrorSchema> = keyof SCHEMA & string;
+type TDomainNiceErrorId<ERR_DEF extends INiceErrorDomainProps> = TSchemaNiceErrorId<ERR_DEF["schema"]>;
+/**
+ * The widest ERR_DEF used when creating a NiceError without a definition
+ * (bare construction, castNiceError, etc.).
+ *
+ * Uses the base `INiceErrorDefinedProps` defaults (`string[]` domains,
+ * `TNiceErrorSchema` schema) so that type-guard narrowing via `is()` works
+ * correctly — `string & "specific_domain"` narrows to `"specific_domain"`
+ * instead of collapsing the intersection to `never`.
+ */
+type TUnknownNiceErrorDef = INiceErrorDomainProps;
+/**
+ * Wide id type for bare / cast NiceErrors that have no schema.
+ * Using `string` (rather than a literal `"unknown"`) ensures that
+ * `is()` type-guard intersections narrow cleanly: `string & K` = `K`.
+ */
+type TUnknownNiceErrorId = string;
+//#endregion
+//#region src/NiceError/NiceErrorHydrated.d.ts
+/**
+ * Resolves the args tuple for `addId` — mirrors `FromIdArgs` exactly so that
+ * optional vs required context is consistent across both `fromId` and `addId`.
+ *
+ * - No context on this id                   → `[id]`
+ * - Context defined, `required: true`       → `[id, context]`
+ * - Context defined, `required` absent/false → `[id] | [id, context]`
+ */
+type AddIdArgs<ERR_DEF extends INiceErrorDomainProps, K extends TDomainNiceErrorId<ERR_DEF>> = [ExtractFromIdContextArg<ERR_DEF["schema"][K]>] extends [undefined] ? [id: K] : [undefined] extends [ExtractFromIdContextArg<ERR_DEF["schema"][K]>] ? [id: K] | [id: K, context: NonNullable<ExtractFromIdContextArg<ERR_DEF["schema"][K]>>] : [id: K, context: ExtractFromIdContextArg<ERR_DEF["schema"][K]>];
+/** Full-featured construction from NiceErrorDefined.fromId / fromContext. */
+interface INiceErrorHydratedOptions<ERR_DEF extends INiceErrorDomainProps, ID extends TDomainNiceErrorId<ERR_DEF>> extends INiceErrorOptions<ERR_DEF, ID> {
+  def: ERR_DEF;
+  niceErrorDefined: NiceErrorDomain<ERR_DEF>;
+}
+declare class NiceErrorHydrated<ERR_DEF extends INiceErrorDomainProps = TUnknownNiceErrorDef,
+/**
+ * Union of active error-id keys.
+ * - After `fromId(id)`: exactly one key.
+ * - After `fromContext({...})`: a union of all supplied keys.
+ * - After `hasOneOfIds([a,b])`: narrows to that subset.
+ * - Default (bare construction / castNiceError): `TUnknownNiceErrorId`.
+ */
+ACTIVE_IDS extends TDomainNiceErrorId<ERR_DEF> = TDomainNiceErrorId<ERR_DEF>> extends NiceError<ERR_DEF, ACTIVE_IDS> {
+  readonly def: ERR_DEF;
+  private readonly niceErrorDefined;
+  constructor(options: INiceErrorHydratedOptions<ERR_DEF, ACTIVE_IDS>);
+  /**
+   * Returns a **new** `NiceErrorHydrated` with additional id+context entries merged in.
+   * The returned error's `ACTIVE_IDS` is the union of the original ids and the
+   * newly supplied keys.
+   *
+   * ```ts
+   * const err = errDef.fromId("id_a", { a: 1 })
+   *   .addContext({ id_b: { b: "x" } });
+   * err.getIds(); // ["id_a", "id_b"]
+   * ```
+   */
+  addContext<INPUT extends TFromContextInput<ERR_DEF["schema"]>>(context: INPUT & Record<Exclude<keyof INPUT, keyof ERR_DEF["schema"] & string>, never>): NiceErrorHydrated<ERR_DEF, ACTIVE_IDS | (keyof INPUT & string)>;
+  /**
+   * Returns a **new** `NiceErrorHydrated` with an additional error id (and its context,
+   * if the schema requires one). Equivalent to `addContext({ [id]: context })`
+   * but mirrors the `fromId` ergonomics for single-id additions.
+   */
+  addId<K extends TDomainNiceErrorId<ERR_DEF>>(...args: AddIdArgs<ERR_DEF, K>): NiceErrorHydrated<ERR_DEF, ACTIVE_IDS | K>;
+}
+//#endregion
+//#region src/NiceErrorDefined/NiceErrorDefined.d.ts
+type ChildDef<PARENT_DEF extends INiceErrorDomainProps, SUB extends IDefineNewNiceErrorDomainOptions> = {
+  domain: SUB["domain"];
+  allDomains: [SUB["domain"], ...PARENT_DEF["allDomains"]];
+  schema: SUB["schema"];
+};
+/**
+ * Extracts the union of keys present in a `TFromContextInput` object.
+ * e.g. `{ invalid_credentials: {...} }` → `"invalid_credentials"`
+ */
+type KeysOfContextInput<INPUT> = keyof INPUT & string;
+/**
+ * Infers the strongly-typed `NiceError` class type from a `NiceErrorDefined` instance.
+ *
+ * `ACTIVE_IDS` is set to the full union of all schema keys. Use `hasId` /
+ * `hasOneOfIds` to narrow further at the call site.
+ *
+ * @example
+ * ```ts
+ * const err_user_auth = defineNiceError({ domain: "err_user_auth", schema: { ... } });
+ * type TUserAuthError = InferNiceError<typeof err_user_auth>;
+ * // → NiceError<{ domain: "err_user_auth"; ... }, keyof schema>
+ * ```
+ */
+type InferNiceError<T extends NiceErrorDomain<any>> = T extends NiceErrorDomain<infer ERR_DEF> ? NiceError<ERR_DEF, keyof ERR_DEF["schema"] & string> : never;
+/**
+ * Infers the strongly-typed `NiceErrorHydrated` class type from a `NiceErrorDefined` instance.
+ *
+ * Use this when you need the builder methods (`addId`, `addContext`) as part of
+ * the inferred type — e.g. for function return types or variable annotations.
+ *
+ * @example
+ * ```ts
+ * const err_user_auth = defineNiceError({ domain: "err_user_auth", schema: { ... } });
+ * type TUserAuthErrorHydrated = InferNiceErrorHydrated<typeof err_user_auth>;
+ * // → NiceErrorHydrated<{ domain: "err_user_auth"; ... }, keyof schema>
+ * ```
+ */
+type InferNiceErrorHydrated<T extends NiceErrorDomain<any>> = T extends NiceErrorDomain<infer ERR_DEF> ? NiceErrorHydrated<ERR_DEF, keyof ERR_DEF["schema"] & string> : never;
+declare class NiceErrorDomain<ERR_DEF extends INiceErrorDomainProps = INiceErrorDomainProps> {
+  readonly domain: ERR_DEF["domain"];
+  readonly allDomains: ERR_DEF["allDomains"];
+  readonly defaultHttpStatusCode?: number;
+  readonly defaultMessage?: string;
+  /** Kept for runtime use (message resolution, httpStatusCode, context serialization, etc.). */
+  private readonly _schema;
+  private _definedChildNiceErrors;
+  private _definedParentNiceError?;
+  /** Set by `.packAs()` — explicit per-instance override, takes priority over `_packAsFn`. */
+  private _setPack?;
+  /** Set at definition time — called dynamically each time an error is created. */
+  private _packAsFn?;
+  constructor(definition: ERR_DEF);
+  /**
+   * Creates a child domain that inherits this domain in `allDomains`.
+   * The child has its own schema and its own domain string.
+   */
+  createChildDomain<SUB extends IDefineNewNiceErrorDomainOptions>(subErrorDef: SUB & { [K in Exclude<keyof SUB, keyof IDefineNewNiceErrorDomainOptions>]: never }): NiceErrorDomain<ChildDef<ERR_DEF, SUB>>;
+  protected addParentNiceErrorDefined<PARENT_DEF extends INiceErrorDomainProps>(parentError: NiceErrorDomain<PARENT_DEF>): void;
+  protected addChildNiceErrorDefined<CHILD_DEF extends INiceErrorDomainProps>(child: NiceErrorDomain<CHILD_DEF>): void;
+  packAs(pack: EErrorPackType): this;
+  private createError;
+  /**
+   * Promotes a plain `NiceError<ERR_DEF>` back into a `NiceErrorHydrated` so
+   * that builder methods (`addId`, `addContext`, etc.) are available again.
+   *
+   * For each active id, if the context is in the `"unhydrated"` state (i.e. the
+   * error was reconstructed from a JSON payload), `hydrate` calls
+   * `fromJsonSerializable` to reconstruct the typed value and advances the state
+   * to `"hydrated"`. Ids already in `"hydrated"` or `"raw_unset"` state
+   * are passed through unchanged.
+   *
+   * @throws If `error.def.domain` does not match this definition's domain. Use
+   * `niceErrorDefined.is(error)` before calling `hydrate` to ensure compatibility.
+   *
+   * ```ts
+   * const raw = castNiceError(apiResponseBody);
+   *
+   * if (err_user_auth.is(raw)) {
+   *   const hydrated = err_user_auth.hydrate(raw);
+   *   // hydrated.getContext("invalid_credentials") — fully typed, no throw
+   *   // hydrated.addId / addContext — available again
+   * }
+   * ```
+   */
+  hydrate<ACTIVE_IDS extends TDomainNiceErrorId<ERR_DEF> = TDomainNiceErrorId<ERR_DEF>>(error: NiceError<ERR_DEF, ACTIVE_IDS> | INiceErrorJsonObject<ERR_DEF, ACTIVE_IDS>): NiceErrorHydrated<ERR_DEF, ACTIVE_IDS>;
+  /**
+   * Creates a `NiceErrorHydrated` for a single error id.
+   *
+   * - `id` autocompletes to the schema keys.
+   * - The second argument `context` is required / optional / absent based on
+   *   whether the schema entry declares `context.required: true`.
+   * - The returned error has `ACTIVE_IDS` narrowed to exactly `K`, so
+   *   `getContext(id)` is immediately strongly typed.
+   */
+  fromId<K extends keyof ERR_DEF["schema"] & string>(...args: FromIdArgs<ERR_DEF, K>): NiceErrorHydrated<ERR_DEF, K>;
+  fromContext<INPUT extends TFromContextInput<ERR_DEF["schema"]>>(context: INPUT & Record<Exclude<keyof INPUT, keyof ERR_DEF["schema"]>, never>): NiceErrorHydrated<ERR_DEF, KeysOfContextInput<INPUT>>;
+  /**
+   * Returns `true` if `error` is a `NiceError` whose `def.domain` exactly matches
+   * this definition's domain.
+   *
+   * Use this after `castNiceError` to narrow an unknown error to this specific
+   * domain before accessing its typed ids/context:
+   *
+   * ```ts
+   * const caught = castNiceError(e);
+   *
+   * if (err_user_auth.is(caught)) {
+   *   // caught is now NiceError<typeof err_user_auth's ERR_DEF>
+   *   const hydrated = err_user_auth.hydrate(caught);
+   *   const { username } = hydrated.getContext("invalid_credentials");
+   * }
+   * ```
+   */
+  isExact(error: unknown): error is NiceError<ERR_DEF, keyof ERR_DEF["schema"] & string>;
+  isThisOrChild(error: unknown): boolean;
+  /**
+   * Returns `true` if this domain appears anywhere in the target's ancestry
+   * chain (including an exact domain match).
+   *
+   * Accepts either a `NiceErrorDefined` (domain definition) or a `NiceError`
+   * instance (extracts the domain from its `def`).
+   */
+  isParentOf(target: NiceErrorDomain<any> | NiceError<any, any>): boolean;
+  private _buildDef;
+  private _resolveMessage;
+  private _resolveHttpStatusCode;
+  reconcileErrorDataForId(id: keyof ERR_DEF["schema"] & string, context: TFromContextInput<ERR_DEF["schema"]>[typeof id]): TErrorReconciledData<ERR_DEF["schema"], typeof id>;
+}
+//#endregion
+//#region src/NiceErrorHandler/NiceErrorHandler.types.d.ts
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Broad handler signature used internally for storage and dispatch.
+ */
+type TBroadErrorHandler<E extends NiceError = NiceError, RES = unknown> = (action: E) => MaybePromise<RES>;
+/**
+ * Handler registered via forDomain.
+ *
+ * `act.input` is typed as the union of input types for every action in `ACT_DOM`,
+ * and `act.coreAction` carries the matching schema — the same narrowing you get
+ * from `forActionIds` over all action IDs in the domain.
+ */
+type TErrorHandlerForDomain<ERR_DOM extends INiceErrorDomainProps> = (error: NiceErrorHydrated<ERR_DOM>) => MaybePromise<unknown>;
+/**
+ * Handler registered via forActionId — receives a specific action ID, with
+ * the primed action's input narrowed to that ID's schema.
+ */
+type TErrorIdHandlerForDomain<ERR_DOM extends INiceErrorDomainProps, ID extends TDomainNiceErrorId<ERR_DOM>> = (error: NiceErrorHydrated<ERR_DOM, ID>) => MaybePromise<unknown>;
+declare enum EErrorHandlerTargetType {
+  ids = "ids",
+  domain = "domain",
+  default = "default"
+}
+type TErrorHandlerTarget = ({
+  type: EErrorHandlerTargetType.ids;
+  domain: string;
+  ids: string[];
+} | {
+  type: EErrorHandlerTargetType.domain;
+  domain: string;
+} | {
+  type: EErrorHandlerTargetType.default;
+}) & {
+  identifier: string;
+};
+/**
+ * A single case in a `handleWith` / `handleWithAsync` call.
+ *
+ * Construct via `forDomain` or `forIds` — do not build this object directly.
+ */
+interface IErrorHandlerConfig<ERR extends NiceError<any, any> = NiceError<any, any>, RES = unknown> {
+  /**
+   * Duck-typed reference to the domain definition.
+   * Needs only `isExact()` and `hydrate()` at runtime — avoids any circular value import.
+   * @internal
+   */
+  readonly target: TErrorHandlerTarget;
+  readonly _matcher: (action: ERR) => boolean;
+  readonly _requester: TBroadErrorHandler<ERR, RES>;
+}
+interface IErrorHandleAttempt_Success<RES = void> {
+  handled: true;
+  result: RES;
+  target: TErrorHandlerTarget;
+}
+interface IErrorHandleAttempt_Failure {
+  handled: false;
+  result?: undefined;
+  targets: TErrorHandlerTarget[];
+}
+type TErrorHandleAttempt<RES = void> = IErrorHandleAttempt_Success<RES> | IErrorHandleAttempt_Failure;
+interface IHandleErrorOptions {
+  throwOnUnhandled?: boolean;
+}
+type THandleErrorWithPromiseInspection<RES = void> = {
+  isPromise: false;
+  matched: true;
+  target: TErrorHandlerTarget;
+  handlerResponse: RES;
+} | {
+  isPromise: true;
+  matched: true;
+  target: TErrorHandlerTarget;
+  handlerPromise: Promise<RES>;
+} | {
+  matched: false;
+  attemptedTargets: TErrorHandlerTarget[];
+};
+type THandleResponse<RES = unknown> = {
+  handled: false;
+} | {
+  handled: true;
+  isPromise: boolean;
+  response: RES;
+};
+//#endregion
+//#region src/NiceErrorHandler/NiceErrorHandler.d.ts
+declare class NiceErrorHandler<RES_DEF = never, RES = never> {
+  private handlerConfigs;
+  private _defaultRequester?;
+  handleErrorWithPromiseInspection(error: NiceError<any, any>, options?: IHandleErrorOptions): THandleErrorWithPromiseInspection<RES | RES_DEF>;
+  /**
+   * Register a handler that fires for **any** error whose domain matches `domain`.
+   * The handler receives a fully hydrated error — `getContext`, `addId`, and `addContext`
+   * are all available. First matching case wins.
+   */
+  forDomain<DEF extends INiceErrorDomainProps, H_RES = void>(domain: NiceErrorDomain<DEF>, handler: (error: NiceErrorHydrated<DEF, TDomainNiceErrorId<DEF>>) => MaybePromise<H_RES>): NiceErrorHandler<RES_DEF, RES | H_RES>;
+  forId<DEF extends INiceErrorDomainProps, ID extends TDomainNiceErrorId<DEF>, H_RES = void>(domain: NiceErrorDomain<DEF>, id: ID, handler: (error: NiceErrorHydrated<DEF, ID>) => MaybePromise<H_RES>): NiceErrorHandler<RES_DEF, RES | H_RES>;
+  forIds<DEF extends INiceErrorDomainProps, IDS extends TDomainNiceErrorId<DEF>[], H_RES = void>(domain: NiceErrorDomain<DEF>, ids: IDS, handler: (error: NiceErrorHydrated<DEF, IDS[number]>) => MaybePromise<H_RES>): NiceErrorHandler<RES_DEF, RES | H_RES>;
+  /**
+   * Register a fallback handler that fires when no other case matches.
+   * Only one default handler can be registered — calling this twice replaces the previous one.
+   */
+  setDefaultHandler<H_RES>(handler: (error: NiceError<any, any>) => MaybePromise<H_RES>): NiceErrorHandler<H_RES, RES>;
+}
+//#endregion
+//#region src/NiceError/NiceError.d.ts
+type ContextOf<S extends TNiceErrorSchema, K extends keyof S> = TExtractContextType<S[K]>;
+/** Full-featured construction from NiceErrorDefined.fromId / fromContext. */
+interface INiceErrorOptions<ERR_DEF extends INiceErrorDomainProps, ID extends TDomainNiceErrorId<ERR_DEF> = TDomainNiceErrorId<ERR_DEF>> {
+  def: Omit<ERR_DEF, "schema">;
+  /** Primary id is first entry in ids. */
+  ids: ID[];
+  /** All active ids with their messages, http status codes, and context state. */
+  errorData: TErrorDataForIdMap<ERR_DEF["schema"]>;
+  message: string;
+  wasntNice?: boolean;
+  httpStatusCode?: number;
+  originError?: IRegularErrorJsonObject | undefined;
+  timeCreated?: number;
+}
+declare class NiceError<ERR_DEF extends INiceErrorDomainProps = TUnknownNiceErrorDef,
+/**
+ * Union of active error-id keys.
+ * - After `fromId(id)`: exactly one key.
+ * - After `fromContext({...})`: a union of all supplied keys.
+ * - After `hasOneOfIds([a,b])`: narrows to that subset.
+ * - Default (bare construction / castNiceError): `TUnknownNiceErrorId`.
+ */
+ACTIVE_IDS extends TDomainNiceErrorId<ERR_DEF> = TDomainNiceErrorId<ERR_DEF>> extends Error {
+  readonly name: "NiceError";
+  readonly def: Omit<ERR_DEF, "schema">;
+  /** Primary id is first entry in ids. */
+  readonly ids: ACTIVE_IDS[];
+  readonly wasntNice: boolean;
+  readonly httpStatusCode: number;
+  readonly timeCreated: number;
+  readonly cleanMessage: string;
+  originError?: IRegularErrorJsonObject;
+  _packedState?: {
+    packedAs: EErrorPackType.cause_pack;
+    cause: unknown;
+  } | {
+    packedAs: EErrorPackType.msg_pack;
+    message: string;
+  } | undefined;
+  /** Internal: all active id → reconciled data pairs. */
+  protected readonly _errorDataMap: TErrorDataForIdMap<ERR_DEF["schema"]>;
+  constructor(options: INiceErrorOptions<ERR_DEF, ACTIVE_IDS>);
+  /**
+   * Type guard: returns `true` if this error was created with (or contains) the
+   * given `id`. After the guard, `getContext(id)` will be strongly typed.
+   */
+  hasId<ID extends keyof ERR_DEF["schema"] & string>(id: ID): this is NiceError<ERR_DEF, ID>;
+  /**
+   * Returns `true` if this error contains **at least one** of the supplied ids.
+   * Narrows `ACTIVE_IDS` to the matching subset of `IDS`.
+   */
+  hasOneOfIds<IDS extends ReadonlyArray<keyof ERR_DEF["schema"] & string>>(ids: IDS): this is NiceError<ERR_DEF, IDS[number]>;
+  /** `true` when this error was created with more than one id (via `fromContext`). */
+  get hasMultiple(): boolean;
+  /** Returns all active error ids on this instance. */
+  getIds(): Array<ACTIVE_IDS>;
+  /**
+   * Returns the typed context value for the given error id.
+   *
+   * TypeScript will only allow you to call this with an id that is part of
+   * `ACTIVE_IDS` (i.e. an id confirmed via `hasId` / `hasOneOfIds`, or passed
+   * to `fromId` / `fromContext`).
+   *
+   * @throws If the context is in the `"unhydrated"` state — the error was
+   * reconstructed from a JSON payload and its context has a custom serializer
+   * that hasn't been run yet. Call `niceErrorDefined.hydrate(error)` first.
+   */
+  getContext<ID extends ACTIVE_IDS>(id: ID): ContextOf<ERR_DEF["schema"], ID>;
+  getErrorDataForId<ID extends ACTIVE_IDS>(id: ID): TErrorReconciledData<ERR_DEF["schema"], ID> | undefined;
+  withOriginError(error: unknown): this;
+  /**
+   * Returns `true` if `other` has the same domain and the exact same set of
+   * active error ids as this error (order-independent).
+   *
+   * Useful for deduplication, retry logic, and asserting that two errors
+   * represent the same "kind" of problem without comparing context values.
+   *
+   * ```ts
+   * const a = err_auth.fromId("invalid_credentials", { username: "alice" });
+   * const b = err_auth.fromId("invalid_credentials", { username: "bob" });
+   * a.matches(b); // true  — same domain + same id set
+   *
+   * const c = err_auth.fromId("account_locked");
+   * a.matches(c); // false — same domain, different id
+   * ```
+   */
+  matches(other: NiceError<any, any>): boolean;
+  toJsonObject(): INiceErrorJsonObject<ERR_DEF>;
+  toJSON(): INiceErrorJsonObject<ERR_DEF>;
+  toJsonString(): string;
+  toHttpResponse(): Response;
+  hydrate(definedNiceError: NiceErrorDomain<ERR_DEF>): NiceErrorHydrated<ERR_DEF, ACTIVE_IDS>;
+  /**
+   * Iterates `cases` in order, finds the first whose domain matches this error
+   * (via `is()`), optionally further filters by active ids, hydrates the error,
+   * calls the handler, and returns `true`. Returns `false` if no case matched.
+   *
+   * Build cases with `forDomain` (any id in the domain) or `forIds` (specific
+   * id subset). Handlers are invoked synchronously — any returned Promise is
+   * not awaited. Use `handleWithAsync` when handlers are async.
+   *
+   * @example
+   * ```ts
+   * const handled = error.handleWith([
+   *   forIds(err_feature, ["not_found"], (h) => {
+   *     res.status(404).json({ missing: h.getContext("not_found").resource });
+   *   }),
+   *   forDomain(err_feature, (h) => {
+   *     matchFirst(h, {
+   *       forbidden: ({ userId }) => res.status(403).json({ userId }),
+   *       _: () => res.status(500).end(),
+   *     });
+   *   }),
+   *   forDomain(err_service, (h) => {
+   *     res.status(h.httpStatusCode).json({ error: h.message });
+   *   }),
+   * ]);
+   * if (!handled) next(error);
+   * ```
+   */
+  handleWithSync<RD, R>(handlerInput: NiceErrorHandler<RD, R> | ReadonlyArray<NiceErrorHandler<RD, R>>, handlerOptions?: IHandleErrorOptions): R | RD | undefined;
+  /**
+   * Same matching logic as `handleWith`, but `await`s the handler's returned
+   * Promise before resolving. Use this when your handlers perform async work
+   * (database writes, HTTP calls, etc.).
+   *
+   * @example
+   * ```ts
+   * const handled = await error.handleWithAsync([
+   *   forDomain(err_payments, async (h) => {
+   *     await db.logFailedPayment(h);
+   *     await notifyOps(h.message);
+   *   }),
+   * ]);
+   * ```
+   */
+  handleWithAsync<RD, R>(handlerInput: NiceErrorHandler<RD, R> | ReadonlyArray<NiceErrorHandler<RD, R>>, handlerOptions?: IHandleErrorOptions): Promise<R | RD | undefined>;
+  get isPacked(): boolean;
+  pack(packType?: EErrorPackType): this;
+  unpack(): this;
+}
+//#endregion
+//#region src/utils/inspectPotentialError/inspectPotentialError.enums.d.ts
+declare enum EInspectErrorResultType {
+  nullish = "nullish",
+  niceErrorObject = "niceErrorObject",
+  niceError = "niceError",
+  jsError = "jsError",
+  jsErrorObject = "jsErrorObject",
+  jsDataType = "jsDataType",
+  jsOther = "jsOther"
+}
+//#endregion
+//#region src/utils/inspectPotentialError/inspectPotentialError.types.d.ts
+interface IInspectErrorResult_Base<T extends EInspectErrorResultType> {
+  type: T;
+}
+interface IInspectErrorResult_Nullish extends IInspectErrorResult_Base<EInspectErrorResultType.nullish> {
+  value: null | undefined;
+}
+interface IInspectErrorResult_JsError extends IInspectErrorResult_Base<EInspectErrorResultType.jsError> {
+  jsError: Error;
+}
+interface IInspectErrorResult_JsErrorObject extends IInspectErrorResult_Base<EInspectErrorResultType.jsErrorObject> {
+  jsErrorObject: IRegularErrorJsonObject;
+}
+/**
+ * JS DATA TYPES
+ */
+interface IInspectErrorResult_JsDataType_String extends IInspectErrorResult_Base<EInspectErrorResultType.jsDataType> {
+  jsDataType: "string";
+  jsDataValue: string;
+}
+interface IInspectErrorResult_JsDataType_Number extends IInspectErrorResult_Base<EInspectErrorResultType.jsDataType> {
+  jsDataType: "number";
+  jsDataValue: number;
+}
+interface IInspectErrorResult_JsDataType_Boolean extends IInspectErrorResult_Base<EInspectErrorResultType.jsDataType> {
+  jsDataType: "boolean";
+  jsDataValue: boolean;
+}
+interface IInspectErrorResult_JsDataType_Object extends IInspectErrorResult_Base<EInspectErrorResultType.jsDataType> {
+  jsDataType: "object";
+  jsDataValue: object;
+}
+type TInspectErrorResult_JsDataType = IInspectErrorResult_JsDataType_String | IInspectErrorResult_JsDataType_Number | IInspectErrorResult_JsDataType_Boolean | IInspectErrorResult_JsDataType_Object;
+/**
+ * Catch-all for any other JS data type that doesn't fit the above categories (e.g. symbol, bigint, function, etc.)
+ */
+interface IInspectErrorResult_JsOther extends IInspectErrorResult_Base<EInspectErrorResultType.jsOther> {
+  jsDataValue: unknown;
+}
+//#endregion
+//#region src/internal/nice_core_errors.d.ts
+declare const err_nice: NiceErrorDomain<{
+  domain: "err_nice";
+  allDomains: ["err_nice"];
+  schema: {};
+}>;
+declare enum EErrId_CastNotNice {
+  js_error = "native_error",
+  js_error_like_object = "js_error_like_object",
+  nullish_value = "nullish_value",
+  js_data_type = "js_data_type",
+  js_other = "js_other"
+}
+declare const err_cast_not_nice: NiceErrorDomain<{
+  domain: string;
+  allDomains: [string, "err_nice"];
+  schema: {
+    native_error: INiceErrorIdMetadata<IInspectErrorResult_JsError, JSONSerializableValue> & {
+      context: {
+        required: true;
+      };
+    };
+    js_error_like_object: INiceErrorIdMetadata<IInspectErrorResult_JsErrorObject, JSONSerializableValue> & {
+      context: {
+        required: true;
+      };
+    };
+    nullish_value: INiceErrorIdMetadata<IInspectErrorResult_Nullish, JSONSerializableValue> & {
+      context: {
+        required: true;
+      };
+    };
+    js_data_type: INiceErrorIdMetadata<TInspectErrorResult_JsDataType, JSONSerializableValue> & {
+      context: {
+        required: true;
+      };
+    };
+    js_other: INiceErrorIdMetadata<IInspectErrorResult_JsOther, JSONSerializableValue> & {
+      context: {
+        required: true;
+      };
+    };
+  };
+}>;
+declare const err_nice_handler: NiceErrorDomain<{
+  domain: string;
+  allDomains: [string, "err_nice"];
+  schema: {};
+}>;
+//#endregion
+//#region src/NiceErrorDefined/defineNiceError.d.ts
+declare const defineNiceError: <ERR_DOMAIN extends string, SCHEMA extends TNiceErrorSchema>(definition: IDefineNewNiceErrorDomainOptions<ERR_DOMAIN, SCHEMA>) => NiceErrorDomain<{
+  domain: ERR_DOMAIN;
+  allDomains: [ERR_DOMAIN];
+  schema: SCHEMA;
+}>;
+//#endregion
+//#region src/NiceErrorDefined/err.d.ts
+/**
+ * Schema entry factory — the idiomatic way to define a single error id in a
+ * `NiceErrorDefined` schema.
+ *
+ * Using `err()` instead of writing schema entries as plain object literals
+ * ensures TypeScript resolves the context argument as **required** vs **optional**
+ * correctly in `fromId` / `addId` call sites.
+ *
+ * How `required` affects the call site:
+ *
+ * | Schema entry                       | `fromId("id")` | `fromId("id", ctx)` |
+ * |------------------------------------|----------------|---------------------|
+ * | `err()`  /  `err({ ... })`         | ✓              | ✗ (no context)      |
+ * | `err<C>({ context: {} })`          | ✓              | ✓ (optional ctx)    |
+ * | `err<C>({ context: { required: true } })` | ✗     | ✓ (required ctx)    |
+ *
+ * @example
+ * ```ts
+ * // No context — `fromId("not_found")` takes no second argument.
+ * not_found: err({ message: "Resource not found", httpStatusCode: 404 }),
+ *
+ * // Optional context — second arg accepted but not required.
+ * rate_limited: err<{ retryAfter: number }>({
+ *   message: (ctx) => ctx ? `Retry after ${ctx.retryAfter}s` : "Rate limited",
+ *   httpStatusCode: 429,
+ *   context: {},
+ * }),
+ *
+ * // Required context — `fromId("invalid_input", { field: "email" })` (second arg is required).
+ * invalid_input: err<{ field: string }>({
+ *   message: ({ field }) => `Invalid value for field: ${field}`,
+ *   httpStatusCode: 422,
+ *   context: { required: true },
+ * }),
+ *
+ * // Required context with custom serialization (for non-JSON-safe context values).
+ * fs_error: err<{ cause: NodeJS.ErrnoException }>({
+ *   message: ({ cause }) => `File system error: ${cause.message}`,
+ *   context: {
+ *     required: true,
+ *     serialization: {
+ *       toJsonSerializable: ({ cause }) => ({ code: cause.code, message: cause.message }),
+ *       fromJsonSerializable: (obj) => ({ cause: Object.assign(new Error(obj.message), obj) }),
+ *     },
+ *   },
+ * }),
+ * ```
+ */
+declare function err<C, D extends JSONSerializableValue = Record<string, any>>(meta: INiceErrorIdMetadata<C, D> & {
+  context: INiceErrorContextDefinition<C, D> & {
+    required: true;
+  };
+}): INiceErrorIdMetadata<C> & {
+  context: {
+    required: true;
+  };
+};
+declare function err<C = never>(meta?: INiceErrorIdMetadata<C>): INiceErrorIdMetadata<C>;
+//#endregion
+//#region src/NiceErrorHandler/handleWith.d.ts
+declare function forDomain<DEF extends INiceErrorDomainProps, H_RES = void>(domain: NiceErrorDomain<DEF>, handler: (error: NiceErrorHydrated<DEF, TDomainNiceErrorId<DEF>>) => MaybePromise<H_RES>): NiceErrorHandler<never, H_RES>;
+declare function forId<DEF extends INiceErrorDomainProps, ID extends TDomainNiceErrorId<DEF>, H_RES = void>(domain: NiceErrorDomain<DEF>, id: ID, handler: (error: NiceErrorHydrated<DEF, ID>) => MaybePromise<H_RES>): NiceErrorHandler<never, H_RES>;
+declare function forIds<DEF extends INiceErrorDomainProps, IDS extends TDomainNiceErrorId<DEF>[], H_RES = void>(domain: NiceErrorDomain<DEF>, ids: IDS, handler: (error: NiceErrorHydrated<DEF, IDS[number]>) => MaybePromise<H_RES>): NiceErrorHandler<never, H_RES>;
+//#endregion
+//#region src/utils/castAndHydrate.d.ts
+/**
+ * Combines `castNiceError`, `is()`, and `hydrate()` in a single call — the
+ * idiomatic way to handle an unknown value arriving from a remote boundary
+ * (API response, message queue, IPC, etc.) when you have a specific domain in mind.
+ *
+ * - Casts `value` to a `NiceError` using `castNiceError`.
+ * - If the result belongs to `niceErrorDefined`'s domain (`is()` returns `true`),
+ *   hydrates it and returns a fully-typed `NiceErrorHydrated`.
+ * - Otherwise returns the raw cast `NiceError` (which may be a `wasntNice` error
+ *   if `value` was not a NiceError at all).
+ *
+ * @example
+ * ```ts
+ * // In an Express error handler:
+ * app.use((err, req, res, next) => {
+ *   const error = castAndHydrate(err, err_user_auth);
+ *
+ *   if (err_user_auth.is(error)) {
+ *     // error is NiceErrorHydrated — getContext / addId available
+ *     const result = matchFirst(error, {
+ *       invalid_credentials: ({ username }) => res.status(401).json({ username }),
+ *       account_locked:      ()             => res.status(403).json({ locked: true }),
+ *     });
+ *     if (result) return;
+ *   }
+ *
+ *   next(err);
+ * });
+ * ```
+ */
+declare function castAndHydrate<ERR_DEF extends INiceErrorDomainProps>(value: unknown, niceErrorDefined: NiceErrorDomain<ERR_DEF>): NiceErrorHydrated<ERR_DEF, keyof ERR_DEF["schema"] & string> | NiceError;
+//#endregion
+//#region src/utils/castNiceError.d.ts
+/**
+ * Casts any unknown value into a `NiceError`.
+ *
+ * - If the value is already a `NiceError` instance, it is returned as-is.
+ * - If the value is a plain `Error`, it is wrapped with the original as `originError`.
+ * - If the value is a JSON-serialised `NiceError` object (e.g. from an API
+ *   response), a best-effort `NiceError` is re-created from it.
+ * - For all other values, a generic `NiceError` is created with a descriptive
+ *   message.
+ *
+ * After casting, use `NiceErrorDefined.is(error)` to narrow the error to a
+ * specific domain and access its strongly-typed ids and context.
+ */
+declare const castNiceError: (error: unknown) => NiceError;
+//#endregion
+//#region src/utils/isNiceErrorObject.d.ts
+/**
+ * Returns `true` if `obj` is a JSON-serialised `NiceError` object matching the
+ * current wire format (contextState-based errorData entries).
+ *
+ * Validates:
+ * - Top-level shape (`name`, `message`, `wasntNice`, `httpStatusCode`, `def`)
+ * - Each `errorData` entry has a `contextState` with a valid `kind` discriminant
+ *   (`"no_serialization"` or `"unhydrated"`) — rejecting payloads in the old
+ *   format (`context` / `serialized` fields) to prevent silent data corruption.
+ */
+declare function isNiceErrorObject(obj: unknown): obj is INiceErrorJsonObject;
+//#endregion
+//#region src/utils/isRegularErrorObject.d.ts
+declare function isRegularErrorJsonObject(obj: unknown): obj is IRegularErrorJsonObject;
+//#endregion
+//#region src/utils/matchFirst.d.ts
+/**
+ * Handler map for `matchFirst`. Each key is an error id (from `ACTIVE_IDS`) and
+ * the value is a function that receives the typed context for that id.
+ *
+ * The `_` key is an optional fallback that runs when no id-specific handler matched.
+ */
+type TMatchFirstHandlers<ERR_DEF extends INiceErrorDomainProps, ACTIVE_IDS extends keyof ERR_DEF["schema"] & string, RESULT> = { [K in ACTIVE_IDS]?: (context: TExtractContextType<ERR_DEF["schema"][K]>) => RESULT } & {
+  _?: () => RESULT;
+};
+/**
+ * Pattern-matches an error against a map of id → handler functions, returning the
+ * result of the first handler whose id is active on the error.
+ *
+ * - Ids are tested in the order returned by `error.getIds()`.
+ * - If no id-specific handler matched and `_` is provided, the fallback is called.
+ * - Returns `undefined` when neither any id handler nor the fallback fires.
+ *
+ * **Requires hydrated context.** If any matched id is in the `"unhydrated"` state,
+ * `getContext` will throw. Call `niceErrorDefined.hydrate(error)` beforehand when
+ * working with errors deserialized from a JSON payload.
+ *
+ * @example
+ * ```ts
+ * const result = matchFirst(error, {
+ *   invalid_credentials: ({ username }) => `Wrong password for ${username}`,
+ *   account_locked:      ()             => "Account is locked",
+ *   _:                   ()             => "Unknown auth error",
+ * });
+ * ```
+ */
+declare function matchFirst<ERR_DEF extends INiceErrorDomainProps, ACTIVE_IDS extends keyof ERR_DEF["schema"] & string, RESULT>(error: NiceError<ERR_DEF, ACTIVE_IDS>, handlers: TMatchFirstHandlers<ERR_DEF, ACTIVE_IDS, RESULT>): RESULT | undefined;
+//#endregion
+//#region src/utils/packError/causePack.d.ts
+declare const causePack: <E extends NiceError<any, any>>(error: E) => E;
+//#endregion
+//#region src/utils/packError/msgPack.d.ts
+declare const msgPack: <E extends NiceError<any, any>>(error: E) => E;
+//#endregion
+export { EErrId_CastNotNice, EErrorHandlerTargetType, EErrorPackType, ExtractFromIdContextArg, FromIdArgs, IDefineNewNiceErrorDomainOptions, IErrorHandleAttempt_Failure, IErrorHandleAttempt_Success, IErrorHandlerConfig, IHandleErrorOptions, INiceErrorContextDefinition, INiceErrorDomainProps, INiceErrorHydratedOptions, INiceErrorIdMetadata, INiceErrorJsonObject, INiceErrorOptions, IPackErrorAs_Base, IPackErrorAs_MatchEnvVar, IRegularErrorJsonObject, InferNiceError, InferNiceErrorHydrated, JSONSerializableValue, MaybePromise, NiceError, NiceErrorDomain, NiceErrorHandler, NiceErrorHydrated, TBroadErrorHandler, TContextState, TContextStateHydrated, TContextStateNoSerialization, TContextStateUnhydrated, TDomainNiceErrorId, TErrorDataForIdMap, TErrorHandleAttempt, TErrorHandlerForDomain, TErrorHandlerTarget, TErrorIdHandlerForDomain, TErrorReconciledData, TExtractContextType, TFromContextInput, THandleErrorWithPromiseInspection, THandleResponse, TMatchFirstHandlers, TNiceErrorSchema, TSchemaNiceErrorId, TSerializedContextState, TSerializedErrorDataMap, TSerializedErrorReconciledData, TUnknownNiceErrorDef, TUnknownNiceErrorId, castAndHydrate, castNiceError, causePack, defineNiceError, err, err_cast_not_nice, err_nice, err_nice_handler, forDomain, forId, forIds, isNiceErrorObject, isRegularErrorJsonObject, matchFirst, msgPack };
+//# sourceMappingURL=index.d.ts.map