@devp0nt/error0 1.0.0-next.41 → 1.0.0-next.42

package/dist/esm/index.d.ts

@@ -1,44 +1,52 @@
-type ErrorExtensionPropOptions<TInputValue, TOutputValue, TError extends Error0 = Error0> = {
-    init: (input: TInputValue) => TOutputValue;
+type IsUnknown<T> = unknown extends T ? ([T] extends [unknown] ? true : false) : false;
+type NormalizeUnknownToUndefined<T> = IsUnknown<T> extends true ? undefined : T;
+type IsOnlyUndefined<T> = [Exclude<T, undefined>] extends [never] ? true : false;
+type InferFirstArg<TFn> = TFn extends (...args: infer TArgs) => unknown ? TArgs extends [infer TFirst, ...unknown[]] ? TFirst : undefined : undefined;
+type InferPluginPropInput<TProp extends ErrorPluginPropOptions<any, any, any>> = NormalizeUnknownToUndefined<InferFirstArg<TProp['init']>>;
+type ErrorPluginPropInit<TInputValue, TOutputValue> = ((input: TInputValue) => TOutputValue) | (() => TOutputValue);
+type ErrorPluginPropSerialize<TOutputValue, TError extends Error0> = ((options: {
+    value: TOutputValue;
+    error: TError;
+    isPublic: boolean;
+}) => unknown) | false;
+type ErrorPluginPropDeserialize<TOutputValue> = ((options: {
+    value: unknown;
+    serialized: Record<string, unknown>;
+}) => TOutputValue | undefined) | false;
+type ErrorPluginPropOptions<TInputValue, TOutputValue, TError extends Error0 = Error0> = {
+    init: ErrorPluginPropInit<TInputValue, TOutputValue>;
     resolve: (options: {
         value: TOutputValue | undefined;
         flow: Array<TOutputValue | undefined>;
         error: TError;
     }) => TOutputValue | undefined;
-    serialize: (options: {
-        value: TOutputValue;
-        error: TError;
-        isPublic: boolean;
-    }) => unknown;
-    deserialize: (options: {
-        value: unknown;
-        serialized: Record<string, unknown>;
-    }) => TOutputValue | undefined;
+    serialize: ErrorPluginPropSerialize<TOutputValue, TError>;
+    deserialize: ErrorPluginPropDeserialize<TOutputValue>;
 };
-type ErrorExtensionMethodFn<TOutputValue, TArgs extends unknown[] = unknown[], TError extends Error0 = Error0> = (error: TError, ...args: TArgs) => TOutputValue;
-type ErrorExtensionRefineResult<TOutputProps extends Record<string, unknown>> = Partial<TOutputProps> | undefined;
-type ErrorExtensionRefineFn<TError extends Error0 = Error0, TOutputProps extends Record<string, unknown> = Record<never, never>> = ((error: TError) => void) | ((error: TError) => ErrorExtensionRefineResult<TOutputProps>);
+type ErrorPluginMethodFn<TOutputValue, TArgs extends unknown[] = unknown[], TError extends Error0 = Error0> = (error: TError, ...args: TArgs) => TOutputValue;
+type ErrorPluginAdaptResult<TOutputProps extends Record<string, unknown>> = Partial<TOutputProps> | undefined;
+type ErrorPluginAdaptFn<TError extends Error0 = Error0, TOutputProps extends Record<string, unknown> = Record<never, never>> = ((error: TError) => void) | ((error: TError) => ErrorPluginAdaptResult<TOutputProps>);
 type ErrorMethodRecord = {
     args: unknown[];
     output: unknown;
 };
-type ErrorExtensionProps = {
-    [key: string]: ErrorExtensionPropOptions<any, any>;
+type ErrorPluginProps = {
+    [key: string]: ErrorPluginPropOptions<any, any>;
 };
-type ErrorExtensionMethods = {
-    [key: string]: ErrorExtensionMethodFn<any, any[]>;
+type ErrorPluginMethods = {
+    [key: string]: ErrorPluginMethodFn<any, any[]>;
 };
-type ErrorExtension<TProps extends ErrorExtensionProps = Record<never, never>, TMethods extends ErrorExtensionMethods = Record<never, never>> = {
+type ErrorPlugin<TProps extends ErrorPluginProps = Record<never, never>, TMethods extends ErrorPluginMethods = Record<never, never>> = {
     props?: TProps;
     methods?: TMethods;
-    refine?: Array<ErrorExtensionRefineFn<Error0, ExtensionOutputProps<TProps>>>;
+    adapt?: Array<ErrorPluginAdaptFn<Error0, PluginOutputProps<TProps>>>;
 };
-type AddPropToExtensionProps<TProps extends ErrorExtensionProps, TKey extends string, TInputValue, TOutputValue> = TProps & Record<TKey, ErrorExtensionPropOptions<TInputValue, TOutputValue>>;
-type AddMethodToExtensionMethods<TMethods extends ErrorExtensionMethods, TKey extends string, TArgs extends unknown[], TOutputValue> = TMethods & Record<TKey, ErrorExtensionMethodFn<TOutputValue, TArgs>>;
-type ExtensionOutputProps<TProps extends ErrorExtensionProps> = {
-    [TKey in keyof TProps]: TProps[TKey] extends ErrorExtensionPropOptions<any, infer TOutputValue> ? TOutputValue : never;
+type AddPropToPluginProps<TProps extends ErrorPluginProps, TKey extends string, TInputValue, TOutputValue> = TProps & Record<TKey, ErrorPluginPropOptions<TInputValue, TOutputValue>>;
+type AddMethodToPluginMethods<TMethods extends ErrorPluginMethods, TKey extends string, TArgs extends unknown[], TOutputValue> = TMethods & Record<TKey, ErrorPluginMethodFn<TOutputValue, TArgs>>;
+type PluginOutputProps<TProps extends ErrorPluginProps> = {
+    [TKey in keyof TProps]: TProps[TKey] extends ErrorPluginPropOptions<any, infer TOutputValue> ? TOutputValue : never;
 };
-type ErrorExtensionsMap = {
+type ErrorPluginsMap = {
     props: Record<string, {
         init: unknown;
         resolve: unknown;
@@ -49,103 +57,104 @@ type IsEmptyObject<T> = keyof T extends never ? true : false;
 type ErrorInputBase = {
     cause?: unknown;
 };
-type ErrorInput<TExtensionsMap extends ErrorExtensionsMap> = IsEmptyObject<TExtensionsMap['props']> extends true ? ErrorInputBase : ErrorInputBase & Partial<{
-    [TKey in keyof TExtensionsMap['props']]: TExtensionsMap['props'][TKey]['init'];
-}>;
-type ErrorOutputProps<TExtensionsMap extends ErrorExtensionsMap> = {
-    [TKey in keyof TExtensionsMap['props']]?: TExtensionsMap['props'][TKey]['resolve'];
+type ErrorInputPluginProps<TPluginsMap extends ErrorPluginsMap> = {
+    [TKey in keyof TPluginsMap['props'] as IsOnlyUndefined<TPluginsMap['props'][TKey]['init']> extends true ? never : TKey]?: TPluginsMap['props'][TKey]['init'];
+};
+type ErrorInput<TPluginsMap extends ErrorPluginsMap> = IsEmptyObject<TPluginsMap['props']> extends true ? ErrorInputBase : ErrorInputBase & ErrorInputPluginProps<TPluginsMap>;
+type ErrorOutputProps<TPluginsMap extends ErrorPluginsMap> = {
+    [TKey in keyof TPluginsMap['props']]: TPluginsMap['props'][TKey]['resolve'] | undefined;
 };
-type ErrorOutputMethods<TExtensionsMap extends ErrorExtensionsMap> = {
-    [TKey in keyof TExtensionsMap['methods']]: TExtensionsMap['methods'][TKey] extends {
+type ErrorOutputMethods<TPluginsMap extends ErrorPluginsMap> = {
+    [TKey in keyof TPluginsMap['methods']]: TPluginsMap['methods'][TKey] extends {
         args: infer TArgs extends unknown[];
         output: infer TOutput;
     } ? (...args: TArgs) => TOutput : never;
 };
-type ErrorOutput<TExtensionsMap extends ErrorExtensionsMap> = ErrorOutputProps<TExtensionsMap> & ErrorOutputMethods<TExtensionsMap>;
-type ErrorStaticMethods<TExtensionsMap extends ErrorExtensionsMap> = {
-    [TKey in keyof TExtensionsMap['methods']]: TExtensionsMap['methods'][TKey] extends {
+type ErrorOutput<TPluginsMap extends ErrorPluginsMap> = ErrorOutputProps<TPluginsMap> & ErrorOutputMethods<TPluginsMap>;
+type ErrorStaticMethods<TPluginsMap extends ErrorPluginsMap> = {
+    [TKey in keyof TPluginsMap['methods']]: TPluginsMap['methods'][TKey] extends {
         args: infer TArgs extends unknown[];
         output: infer TOutput;
     } ? (error: unknown, ...args: TArgs) => TOutput : never;
 };
-type EmptyExtensionsMap = {
+type EmptyPluginsMap = {
     props: Record<never, {
         init: never;
         resolve: never;
     }>;
     methods: Record<never, ErrorMethodRecord>;
 };
-type ExtensionPropsMapOf<TExtension extends ErrorExtension> = {
-    [TKey in keyof NonNullable<TExtension['props']>]: NonNullable<TExtension['props']>[TKey] extends ErrorExtensionPropOptions<infer TInputValue, infer TOutputValue> ? {
-        init: TInputValue;
+type PluginPropsMapOf<TPlugin extends ErrorPlugin> = {
+    [TKey in keyof NonNullable<TPlugin['props']>]: NonNullable<TPlugin['props']>[TKey] extends ErrorPluginPropOptions<any, infer TOutputValue> ? {
+        init: InferPluginPropInput<NonNullable<TPlugin['props']>[TKey]>;
         resolve: TOutputValue;
     } : never;
 };
-type ExtensionMethodsMapOf<TExtension extends ErrorExtension> = {
-    [TKey in keyof NonNullable<TExtension['methods']>]: NonNullable<TExtension['methods']>[TKey] extends (error: Error0, ...args: infer TArgs extends unknown[]) => infer TOutput ? {
+type PluginMethodsMapOf<TPlugin extends ErrorPlugin> = {
+    [TKey in keyof NonNullable<TPlugin['methods']>]: NonNullable<TPlugin['methods']>[TKey] extends (error: Error0, ...args: infer TArgs extends unknown[]) => infer TOutput ? {
         args: TArgs;
         output: TOutput;
     } : never;
 };
-type ErrorExtensionsMapOfExtension<TExtension extends ErrorExtension> = {
-    props: ExtensionPropsMapOf<TExtension>;
-    methods: ExtensionMethodsMapOf<TExtension>;
-};
-type ExtendErrorExtensionsMap<TMap extends ErrorExtensionsMap, TExtension extends ErrorExtension> = {
-    props: TMap['props'] & ErrorExtensionsMapOfExtension<TExtension>['props'];
-    methods: TMap['methods'] & ErrorExtensionsMapOfExtension<TExtension>['methods'];
-};
-type ExtendErrorExtensionsMapWithProp<TMap extends ErrorExtensionsMap, TKey extends string, TInputValue, TOutputValue> = ExtendErrorExtensionsMap<TMap, ErrorExtension<Record<TKey, ErrorExtensionPropOptions<TInputValue, TOutputValue>>>>;
-type ExtendErrorExtensionsMapWithMethod<TMap extends ErrorExtensionsMap, TKey extends string, TArgs extends unknown[], TOutputValue> = ExtendErrorExtensionsMap<TMap, ErrorExtension<Record<never, never>, Record<TKey, ErrorExtensionMethodFn<TOutputValue, TArgs>>>>;
-type ExtensionsMapOf<TClass> = TClass extends {
-    __extensionsMap?: infer TExtensionsMap;
-} ? TExtensionsMap extends ErrorExtensionsMap ? TExtensionsMap : EmptyExtensionsMap : EmptyExtensionsMap;
-type ExtensionsMapFromParts<TProps extends ErrorExtensionProps, TMethods extends ErrorExtensionMethods> = ErrorExtensionsMapOfExtension<ErrorExtension<TProps, TMethods>>;
-type ErrorInstanceOfMap<TMap extends ErrorExtensionsMap> = Error0 & ErrorOutput<TMap>;
-type BuilderError0<TProps extends ErrorExtensionProps, TMethods extends ErrorExtensionMethods> = Error0 & ErrorOutput<ExtensionsMapFromParts<TProps, TMethods>>;
-type ExtensionOfBuilder<TBuilder> = TBuilder extends ExtensionError0<infer TProps, infer TMethods> ? ErrorExtension<TProps, TMethods> : never;
-declare class ExtensionError0<TProps extends ErrorExtensionProps = Record<never, never>, TMethods extends ErrorExtensionMethods = Record<never, never>> {
-    private readonly _extension;
+type ErrorPluginsMapOfPlugin<TPlugin extends ErrorPlugin> = {
+    props: PluginPropsMapOf<TPlugin>;
+    methods: PluginMethodsMapOf<TPlugin>;
+};
+type ExtendErrorPluginsMap<TMap extends ErrorPluginsMap, TPlugin extends ErrorPlugin> = {
+    props: TMap['props'] & ErrorPluginsMapOfPlugin<TPlugin>['props'];
+    methods: TMap['methods'] & ErrorPluginsMapOfPlugin<TPlugin>['methods'];
+};
+type ExtendErrorPluginsMapWithProp<TMap extends ErrorPluginsMap, TKey extends string, TInputValue, TOutputValue> = ExtendErrorPluginsMap<TMap, ErrorPlugin<Record<TKey, ErrorPluginPropOptions<TInputValue, TOutputValue>>>>;
+type ExtendErrorPluginsMapWithMethod<TMap extends ErrorPluginsMap, TKey extends string, TArgs extends unknown[], TOutputValue> = ExtendErrorPluginsMap<TMap, ErrorPlugin<Record<never, never>, Record<TKey, ErrorPluginMethodFn<TOutputValue, TArgs>>>>;
+type PluginsMapOf<TClass> = TClass extends {
+    __pluginsMap?: infer TPluginsMap;
+} ? TPluginsMap extends ErrorPluginsMap ? TPluginsMap : EmptyPluginsMap : EmptyPluginsMap;
+type PluginsMapFromParts<TProps extends ErrorPluginProps, TMethods extends ErrorPluginMethods> = ErrorPluginsMapOfPlugin<ErrorPlugin<TProps, TMethods>>;
+type ErrorInstanceOfMap<TMap extends ErrorPluginsMap> = Error0 & ErrorOutput<TMap>;
+type BuilderError0<TProps extends ErrorPluginProps, TMethods extends ErrorPluginMethods> = Error0 & ErrorOutput<PluginsMapFromParts<TProps, TMethods>>;
+type PluginOfBuilder<TBuilder> = TBuilder extends PluginError0<infer TProps, infer TMethods> ? ErrorPlugin<TProps, TMethods> : never;
+declare class PluginError0<TProps extends ErrorPluginProps = Record<never, never>, TMethods extends ErrorPluginMethods = Record<never, never>> {
+    private readonly _plugin;
     readonly Infer: {
         props: TProps;
         methods: TMethods;
     };
-    constructor(extension?: ErrorExtension<ErrorExtensionProps, ErrorExtensionMethods>);
-    prop<TKey extends string, TInputValue, TOutputValue>(key: TKey, value: ErrorExtensionPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>>): ExtensionError0<AddPropToExtensionProps<TProps, TKey, TInputValue, TOutputValue>, TMethods>;
-    method<TKey extends string, TArgs extends unknown[], TOutputValue>(key: TKey, value: ErrorExtensionMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>): ExtensionError0<TProps, AddMethodToExtensionMethods<TMethods, TKey, TArgs, TOutputValue>>;
-    refine(value: ErrorExtensionRefineFn<BuilderError0<TProps, TMethods>, ExtensionOutputProps<TProps>>): ExtensionError0<TProps, TMethods>;
-    extend<TKey extends string, TInputValue, TOutputValue>(kind: 'prop', key: TKey, value: ErrorExtensionPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>>): ExtensionError0<AddPropToExtensionProps<TProps, TKey, TInputValue, TOutputValue>, TMethods>;
-    extend<TKey extends string, TArgs extends unknown[], TOutputValue>(kind: 'method', key: TKey, value: ErrorExtensionMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>): ExtensionError0<TProps, AddMethodToExtensionMethods<TMethods, TKey, TArgs, TOutputValue>>;
-    extend(kind: 'refine', value: ErrorExtensionRefineFn<BuilderError0<TProps, TMethods>, ExtensionOutputProps<TProps>>): ExtensionError0<TProps, TMethods>;
+    constructor(plugin?: ErrorPlugin<ErrorPluginProps, ErrorPluginMethods>);
+    prop<TKey extends string, TInputValue, TOutputValue>(key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>>): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue>, TMethods>;
+    method<TKey extends string, TArgs extends unknown[], TOutputValue>(key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>): PluginError0<TProps, AddMethodToPluginMethods<TMethods, TKey, TArgs, TOutputValue>>;
+    adapt(value: ErrorPluginAdaptFn<BuilderError0<TProps, TMethods>, PluginOutputProps<TProps>>): PluginError0<TProps, TMethods>;
+    use<TKey extends string, TInputValue, TOutputValue>(kind: 'prop', key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>>): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue>, TMethods>;
+    use<TKey extends string, TArgs extends unknown[], TOutputValue>(kind: 'method', key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>): PluginError0<TProps, AddMethodToPluginMethods<TMethods, TKey, TArgs, TOutputValue>>;
+    use(kind: 'adapt', value: ErrorPluginAdaptFn<BuilderError0<TProps, TMethods>, PluginOutputProps<TProps>>): PluginError0<TProps, TMethods>;
 }
-type ClassError0<TExtensionsMap extends ErrorExtensionsMap = EmptyExtensionsMap> = {
-    new (message: string, input?: ErrorInput<TExtensionsMap>): Error0 & ErrorOutput<TExtensionsMap>;
+type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> = {
+    new (message: string, input?: ErrorInput<TPluginsMap>): Error0 & ErrorOutput<TPluginsMap>;
     new (input: {
         message: string;
-    } & ErrorInput<TExtensionsMap>): Error0 & ErrorOutput<TExtensionsMap>;
-    readonly __extensionsMap?: TExtensionsMap;
-    from: (error: unknown) => Error0 & ErrorOutput<TExtensionsMap>;
+    } & ErrorInput<TPluginsMap>): Error0 & ErrorOutput<TPluginsMap>;
+    readonly __pluginsMap?: TPluginsMap;
+    from: (error: unknown) => Error0 & ErrorOutput<TPluginsMap>;
     serialize: (error: unknown, isPublic?: boolean) => Record<string, unknown>;
-    prop: <TKey extends string, TInputValue, TOutputValue>(key: TKey, value: ErrorExtensionPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TExtensionsMap>>) => ClassError0<ExtendErrorExtensionsMapWithProp<TExtensionsMap, TKey, TInputValue, TOutputValue>>;
-    method: <TKey extends string, TArgs extends unknown[], TOutputValue>(key: TKey, value: ErrorExtensionMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TExtensionsMap>>) => ClassError0<ExtendErrorExtensionsMapWithMethod<TExtensionsMap, TKey, TArgs, TOutputValue>>;
-    refine: (value: ErrorExtensionRefineFn<ErrorInstanceOfMap<TExtensionsMap>, ErrorOutputProps<TExtensionsMap>>) => ClassError0<TExtensionsMap>;
-    extend: {
-        <TBuilder extends ExtensionError0>(extension: TBuilder): ClassError0<ExtendErrorExtensionsMap<TExtensionsMap, ExtensionOfBuilder<TBuilder>>>;
-        <TKey extends string, TInputValue, TOutputValue>(kind: 'prop', key: TKey, value: ErrorExtensionPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TExtensionsMap>>): ClassError0<ExtendErrorExtensionsMapWithProp<TExtensionsMap, TKey, TInputValue, TOutputValue>>;
-        <TKey extends string, TArgs extends unknown[], TOutputValue>(kind: 'method', key: TKey, value: ErrorExtensionMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TExtensionsMap>>): ClassError0<ExtendErrorExtensionsMapWithMethod<TExtensionsMap, TKey, TArgs, TOutputValue>>;
-        (kind: 'refine', value: ErrorExtensionRefineFn<ErrorInstanceOfMap<TExtensionsMap>, ErrorOutputProps<TExtensionsMap>>): ClassError0<TExtensionsMap>;
+    prop: <TKey extends string, TInputValue, TOutputValue>(key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>>) => ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue>>;
+    method: <TKey extends string, TArgs extends unknown[], TOutputValue>(key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TPluginsMap>>) => ClassError0<ExtendErrorPluginsMapWithMethod<TPluginsMap, TKey, TArgs, TOutputValue>>;
+    adapt: (value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorOutputProps<TPluginsMap>>) => ClassError0<TPluginsMap>;
+    use: {
+        <TBuilder extends PluginError0>(plugin: TBuilder): ClassError0<ExtendErrorPluginsMap<TPluginsMap, PluginOfBuilder<TBuilder>>>;
+        <TKey extends string, TInputValue, TOutputValue>(kind: 'prop', key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>>): ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue>>;
+        <TKey extends string, TArgs extends unknown[], TOutputValue>(kind: 'method', key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TPluginsMap>>): ClassError0<ExtendErrorPluginsMapWithMethod<TPluginsMap, TKey, TArgs, TOutputValue>>;
+        (kind: 'adapt', value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorOutputProps<TPluginsMap>>): ClassError0<TPluginsMap>;
     };
-    extension: () => ExtensionError0;
-} & ErrorStaticMethods<TExtensionsMap>;
+    plugin: () => PluginError0;
+} & ErrorStaticMethods<TPluginsMap>;
 declare class Error0 extends Error {
-    static readonly __extensionsMap?: EmptyExtensionsMap;
-    protected static _extensions: ErrorExtension[];
-    private static readonly _emptyExtension;
-    private static _getResolvedExtension;
-    constructor(message: string, input?: ErrorInput<EmptyExtensionsMap>);
+    static readonly __pluginsMap?: EmptyPluginsMap;
+    protected static _plugins: ErrorPlugin[];
+    private static readonly _emptyPlugin;
+    private static _getResolvedPlugin;
+    constructor(message: string, input?: ErrorInput<EmptyPluginsMap>);
     constructor(input: {
         message: string;
-    } & ErrorInput<EmptyExtensionsMap>);
+    } & ErrorInput<EmptyPluginsMap>);
     private static readonly isSelfProperty;
     static own(error: object, key: string): unknown;
     own(key: string): unknown;
@@ -158,22 +167,22 @@ declare class Error0 extends Error {
     static is<T extends typeof Error0>(this: T, error: unknown): error is InstanceType<T>;
     static isSerialized(error: unknown): error is Record<string, unknown>;
     static from(error: unknown): Error0;
-    private static _applyRefine;
+    private static _applyAdapt;
     private static _fromSerialized;
     private static _fromNonError0;
     private static _extractMessage;
-    private static _extendWithExtension;
-    private static _extensionFromBuilder;
-    static prop<TThis extends typeof Error0, TKey extends string, TInputValue, TOutputValue>(this: TThis, key: TKey, value: ErrorExtensionPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<ExtensionsMapOf<TThis>>>): ClassError0<ExtendErrorExtensionsMapWithProp<ExtensionsMapOf<TThis>, TKey, TInputValue, TOutputValue>>;
-    static method<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(this: TThis, key: TKey, value: ErrorExtensionMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<ExtensionsMapOf<TThis>>>): ClassError0<ExtendErrorExtensionsMapWithMethod<ExtensionsMapOf<TThis>, TKey, TArgs, TOutputValue>>;
-    static refine<TThis extends typeof Error0>(this: TThis, value: ErrorExtensionRefineFn<ErrorInstanceOfMap<ExtensionsMapOf<TThis>>, ErrorOutputProps<ExtensionsMapOf<TThis>>>): ClassError0<ExtensionsMapOf<TThis>>;
-    static extend<TThis extends typeof Error0, TBuilder extends ExtensionError0>(this: TThis, extension: TBuilder): ClassError0<ExtendErrorExtensionsMap<ExtensionsMapOf<TThis>, ExtensionOfBuilder<TBuilder>>>;
-    static extend<TThis extends typeof Error0, TKey extends string, TInputValue, TOutputValue>(this: TThis, kind: 'prop', key: TKey, value: ErrorExtensionPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<ExtensionsMapOf<TThis>>>): ClassError0<ExtendErrorExtensionsMapWithProp<ExtensionsMapOf<TThis>, TKey, TInputValue, TOutputValue>>;
-    static extend<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(this: TThis, kind: 'method', key: TKey, value: ErrorExtensionMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<ExtensionsMapOf<TThis>>>): ClassError0<ExtendErrorExtensionsMapWithMethod<ExtensionsMapOf<TThis>, TKey, TArgs, TOutputValue>>;
-    static extend<TThis extends typeof Error0>(this: TThis, kind: 'refine', value: ErrorExtensionRefineFn<ErrorInstanceOfMap<ExtensionsMapOf<TThis>>, ErrorOutputProps<ExtensionsMapOf<TThis>>>): ClassError0<ExtensionsMapOf<TThis>>;
-    static extension(): ExtensionError0;
+    private static _useWithPlugin;
+    private static _pluginFromBuilder;
+    static prop<TThis extends typeof Error0, TKey extends string, TInputValue, TOutputValue>(this: TThis, key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue>>;
+    static method<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(this: TThis, key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TArgs, TOutputValue>>;
+    static adapt<TThis extends typeof Error0>(this: TThis, value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorOutputProps<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
+    static use<TThis extends typeof Error0, TBuilder extends PluginError0>(this: TThis, plugin: TBuilder): ClassError0<ExtendErrorPluginsMap<PluginsMapOf<TThis>, PluginOfBuilder<TBuilder>>>;
+    static use<TThis extends typeof Error0, TKey extends string, TInputValue, TOutputValue>(this: TThis, kind: 'prop', key: TKey, value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue>>;
+    static use<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(this: TThis, kind: 'method', key: TKey, value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<PluginsMapOf<TThis>>>): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TArgs, TOutputValue>>;
+    static use<TThis extends typeof Error0>(this: TThis, kind: 'adapt', value: ErrorPluginAdaptFn<ErrorInstanceOfMap<PluginsMapOf<TThis>>, ErrorOutputProps<PluginsMapOf<TThis>>>): ClassError0<PluginsMapOf<TThis>>;
+    static plugin(): PluginError0;
     static serialize(error: unknown, isPublic?: boolean): Record<string, unknown>;
     serialize(isPublic?: boolean): object;
 }
 
-export { type ClassError0, Error0, type ErrorExtension, type ErrorExtensionMethodFn, type ErrorExtensionMethods, type ErrorExtensionPropOptions, type ErrorExtensionProps, type ErrorExtensionRefineFn, type ErrorExtensionRefineResult, type ErrorExtensionsMap, type ErrorInput, type ErrorInputBase, type ErrorOutput, ExtensionError0, type IsEmptyObject };
+export { type ClassError0, Error0, type ErrorInput, type ErrorInputBase, type ErrorOutput, type ErrorPlugin, type ErrorPluginAdaptFn, type ErrorPluginAdaptResult, type ErrorPluginMethodFn, type ErrorPluginMethods, type ErrorPluginPropOptions, type ErrorPluginProps, type ErrorPluginsMap, type IsEmptyObject, PluginError0 };

package/dist/esm/index.js

@@ -1,68 +1,66 @@
-class ExtensionError0 {
-  _extension;
+class PluginError0 {
+  _plugin;
   Infer = void 0;
-  constructor(extension) {
-    this._extension = {
-      props: { ...extension?.props ?? {} },
-      methods: { ...extension?.methods ?? {} },
-      refine: [...extension?.refine ?? []]
+  constructor(plugin) {
+    this._plugin = {
+      props: { ...plugin?.props ?? {} },
+      methods: { ...plugin?.methods ?? {} },
+      adapt: [...plugin?.adapt ?? []]
     };
   }
   prop(key, value) {
-    return this.extend("prop", key, value);
+    return this.use("prop", key, value);
   }
   method(key, value) {
-    return this.extend("method", key, value);
+    return this.use("method", key, value);
   }
-  refine(value) {
-    return this.extend("refine", value);
+  adapt(value) {
+    return this.use("adapt", value);
   }
-  extend(kind, keyOrValue, value) {
-    const nextProps = { ...this._extension.props ?? {} };
-    const nextMethods = { ...this._extension.methods ?? {} };
-    const nextRefine = [
-      ...this._extension.refine ?? []
-    ];
+  use(kind, keyOrValue, value) {
+    const nextProps = { ...this._plugin.props ?? {} };
+    const nextMethods = { ...this._plugin.methods ?? {} };
+    const nextAdapt = [...this._plugin.adapt ?? []];
     if (kind === "prop") {
       const key = keyOrValue;
       if (value === void 0) {
-        throw new Error('ExtensionError0.extend("prop", key, value) requires value');
+        throw new Error('PluginError0.use("prop", key, value) requires value');
       }
       nextProps[key] = value;
     } else if (kind === "method") {
       const key = keyOrValue;
       if (value === void 0) {
-        throw new Error('ExtensionError0.extend("method", key, value) requires value');
+        throw new Error('PluginError0.use("method", key, value) requires value');
       }
       nextMethods[key] = value;
     } else {
-      nextRefine.push(keyOrValue);
+      nextAdapt.push(keyOrValue);
     }
-    return new ExtensionError0({
+    return new PluginError0({
       props: nextProps,
       methods: nextMethods,
-      refine: nextRefine
+      adapt: nextAdapt
     });
   }
 }
 class Error0 extends Error {
-  static __extensionsMap;
-  static _extensions = [];
-  static _emptyExtension = {
+  static __pluginsMap;
+  static _plugins = [];
+  static _emptyPlugin = {
     props: {},
     methods: {},
-    refine: []
+    adapt: []
   };
-  static _getResolvedExtension() {
+  static _getResolvedPlugin() {
     const resolved = {
       props: {},
       methods: {},
-      refine: []
+      adapt: []
     };
-    for (const extension of this._extensions) {
-      Object.assign(resolved.props, extension.props ?? this._emptyExtension.props);
-      Object.assign(resolved.methods, extension.methods ?? this._emptyExtension.methods);
-      resolved.refine.push(...extension.refine ?? this._emptyExtension.refine);
+    for (const plugin of this._plugins) {
+      Object.assign(resolved.props, plugin.props ?? this._emptyPlugin.props);
+      Object.assign(resolved.methods, plugin.methods ?? this._emptyPlugin.methods);
+      resolved.adapt.push(...plugin.adapt ?? this._emptyPlugin.adapt);
     }
     return resolved;
   }
@@ -72,8 +70,8 @@ class Error0 extends Error {
     super(input.message, { cause: input.cause });
     this.name = "Error0";
     const ctor = this.constructor;
-    const extension = ctor._getResolvedExtension();
-    for (const [key, prop] of Object.entries(extension.props)) {
+    const plugin = ctor._getResolvedPlugin();
+    for (const [key, prop] of Object.entries(plugin.props)) {
       if (key in input) {
         const ownValue = input[key];
         this[key] = prop.init(ownValue);
@@ -167,12 +165,12 @@ class Error0 extends Error {
     }
     return this._fromNonError0(error);
   }
-  static _applyRefine(error) {
-    const extension = this._getResolvedExtension();
-    for (const refine of extension.refine) {
-      const refined = refine(error);
-      if (refined && typeof refined === "object") {
-        Object.assign(error, refined);
+  static _applyAdapt(error) {
+    const plugin = this._getResolvedPlugin();
+    for (const adapt of plugin.adapt) {
+      const adapted = adapt(error);
+      if (adapted && typeof adapted === "object") {
+        Object.assign(error, adapted);
       }
     }
     return error;
@@ -180,13 +178,16 @@ class Error0 extends Error {
   static _fromSerialized(error) {
     const message = this._extractMessage(error);
     if (typeof error !== "object" || error === null) {
-      return this._applyRefine(new this(message, { cause: error }));
+      return this._applyAdapt(new this(message, { cause: error }));
     }
     const errorRecord = error;
     const recreated = new this(message);
-    const extension = this._getResolvedExtension();
-    const propsEntries = Object.entries(extension.props);
+    const plugin = this._getResolvedPlugin();
+    const propsEntries = Object.entries(plugin.props);
     for (const [key, prop] of propsEntries) {
+      if (prop.deserialize === false) {
+        continue;
+      }
       if (!(key in errorRecord)) {
         continue;
       }
@@ -204,17 +205,17 @@ class Error0 extends Error {
   }
   static _fromNonError0(error) {
     const message = this._extractMessage(error);
-    return this._applyRefine(new this(message, { cause: error }));
+    return this._applyAdapt(new this(message, { cause: error }));
   }
   static _extractMessage(error) {
     return (typeof error === "string" ? error : typeof error === "object" && error !== null && "message" in error && typeof error.message === "string" ? error.message : void 0) || "Unknown error";
   }
-  static _extendWithExtension(extension) {
+  static _useWithPlugin(plugin) {
     const Base = this;
     const Error0Extended = class Error0 extends Base {
     };
-    Error0Extended._extensions = [...Base._extensions, extension];
-    const resolved = Error0Extended._getResolvedExtension();
+    Error0Extended._plugins = [...Base._plugins, plugin];
+    const resolved = Error0Extended._getResolvedPlugin();
     for (const [key, method] of Object.entries(resolved.methods)) {
       Object.defineProperty(Error0Extended.prototype, key, {
         value: function(...args) {
@@ -235,61 +236,64 @@ class Error0 extends Error {
     }
     return Error0Extended;
   }
-  static _extensionFromBuilder(extension) {
-    const extensionRecord = extension;
+  static _pluginFromBuilder(plugin) {
+    const pluginRecord = plugin;
     return {
-      props: { ...extensionRecord._extension.props ?? {} },
-      methods: { ...extensionRecord._extension.methods ?? {} },
-      refine: [...extensionRecord._extension.refine ?? []]
+      props: { ...pluginRecord._plugin.props ?? {} },
+      methods: { ...pluginRecord._plugin.methods ?? {} },
+      adapt: [...pluginRecord._plugin.adapt ?? []]
     };
   }
   static prop(key, value) {
-    return this.extend("prop", key, value);
+    return this.use("prop", key, value);
   }
   static method(key, value) {
-    return this.extend("method", key, value);
+    return this.use("method", key, value);
   }
-  static refine(value) {
-    return this.extend("refine", value);
+  static adapt(value) {
+    return this.use("adapt", value);
   }
-  static extend(first, key, value) {
-    if (first instanceof ExtensionError0) {
-      return this._extendWithExtension(this._extensionFromBuilder(first));
+  static use(first, key, value) {
+    if (first instanceof PluginError0) {
+      return this._useWithPlugin(this._pluginFromBuilder(first));
     }
-    if (first === "refine") {
+    if (first === "adapt") {
       if (typeof key !== "function") {
-        throw new Error('Error0.extend("refine", value) requires refine function');
+        throw new Error('Error0.use("adapt", value) requires adapt function');
       }
-      return this._extendWithExtension({
-        refine: [key]
+      return this._useWithPlugin({
+        adapt: [key]
       });
     }
     if (typeof key !== "string" || value === void 0) {
-      throw new Error("Error0.extend(kind, key, value) requires key and value");
+      throw new Error("Error0.use(kind, key, value) requires key and value");
     }
     if (first === "prop") {
-      return this._extendWithExtension({
+      return this._useWithPlugin({
         props: { [key]: value }
       });
     }
-    return this._extendWithExtension({
+    return this._useWithPlugin({
       methods: { [key]: value }
     });
   }
-  static extension() {
-    return new ExtensionError0();
+  static plugin() {
+    return new PluginError0();
   }
   static serialize(error, isPublic = true) {
     const error0 = this.from(error);
     const json = {
       name: error0.name,
       message: error0.message
-      // we do not serialize causes, it is enough that we have floated props and refine helper
+      // we do not serialize causes, it is enough that we have floated props and adapt helper
       // cause: error0.cause,
     };
-    const extension = this._getResolvedExtension();
-    const propsEntries = Object.entries(extension.props);
+    const plugin = this._getResolvedPlugin();
+    const propsEntries = Object.entries(plugin.props);
     for (const [key, prop] of propsEntries) {
+      if (prop.serialize === false) {
+        continue;
+      }
       try {
         const value = prop.resolve({ value: error0.own(key), flow: error0.flow(key), error: error0 });
         const jsonValue = prop.serialize({ value, error: error0, isPublic });
@@ -312,6 +316,6 @@ class Error0 extends Error {
 }
 export {
   Error0,
-  ExtensionError0
+  PluginError0
 };
 //# sourceMappingURL=index.js.map