import { LessThan, Subtract, UnionToTuple } from 'type-fest';

type Split<S extends string, Delimiter extends string = "/"> = S extends `${infer Head}${Delimiter}${infer Tail}` ? [Head, ...Split<Tail, Delimiter>] : [S];

type Join<T extends string[], Delimiter extends string = "/"> = T extends [
    infer First extends string,
    ...infer Rest extends string[]
] ? Rest["length"] extends 0 ? First : `${First}${Delimiter}${Join<Rest, Delimiter>}` : "";

type ContainsWildcard<T extends string> = T extends `${string}/*/${string}` ? true : T extends `${string}/*` ? true : T extends `*/${string}` ? true : T extends `*` | `**` ? true : T extends `${string}/**` ? true : false;

type IsAny<T> = 0 extends 1 & T ? true : false;

/**
 * 断言类型为字符串类型
 * @description 如果类型 T 是 string 的子类型，返回 T；否则返回 string
 * @example
 * type Result1 = AssertString<"hello">;
 * // Result1 = "hello"
 * type Result2 = AssertString<number>;
 * // Result2 = string
 */
type AssertString<T> = T extends string ? T : string;

type KeyOf<T extends Record<string, any>> = Exclude<keyof T, number | symbol> extends never ? string : Exclude<keyof T, number | symbol>;

/**
 * 展开类型，使交集类型合并为单一对象类型
 * @description 展开交叉类型和映射类型，使类型更容易阅读
 * @example
 * type Result = Expand<{ a: 1 } & { b: 2 }>;
 * // Result = { a: 1; b: 2 }
 */
type Expand<T> = T extends infer O ? {
    [K in keyof O]: O[K];
} : never;

/**
 * 检查类型是否为多级通配符（包含 **）
 * @description 判断字符串类型是否包含多级通配符 "**"
 * @example
 * type Result1 = IsMultiWildcard<"user/**">;
 * // Result1 = true
 * type Result2 = IsMultiWildcard<"user/*">;
 * // Result2 = false
 * type Result3 = IsMultiWildcard<**">;
 * // Result3 = true
 */
type IsMultiWildcard<T extends string> = T extends `${string}/**` | "**" ? true : false;

/**
 * 在数字前面追加数字
 * @example PrefixNumber<123, 99> = 99123
 */
type PrefixNumber<T extends number, P extends number> = `${P}${T}` extends `${infer R extends number}` ? R : never;

/**
 * 将记录类型转换为键值对联合类型
 * @example ExpandRecord<{ a: 1; b: 2 }> = ["a", 1] | ["b", 2]
 */
type ExpandRecord<T extends Record<string, any>> = {
    [K in keyof T]: [K, T[K]];
}[keyof T];

/**
 * 检查类型是否为 never
 * @description 判断类型是否为 TypeScript 的 never 类型
 * @example
 * type Result1 = IsNever<never>;
 * // Result1 = true
 * type Result2 = IsNever<string>;
 * // Result2 = false
 */
type IsNever<T> = [T] extends [never] ? true : false;

/**
 * 如果类型为 never，返回默认值；否则返回原类型
 * @description 条件类型工具，当类型为 never 时提供默认值
 * @example
 * type Result1 = IfNever<never, string>;
 * // Result1 = string
 * type Result2 = IfNever<number, string>;
 * // Result2 = number
 */
type IfNever<T, Default> = IsNever<T> extends true ? Default : T;

/**
 * 分割路径为数组（支持没有 / 的情况）
 *
 * 处理逻辑：
 * - 如果有 /，按 / 分割成多段数组
 * - 如果没有 /，返回包含单个元素的数组 [原字符串]
 * - 空字符串会返回 [""]
 *
 * @example
 * - SplitPath<"a/b/c"> => ["a", "b", "c"]
 * - SplitPath<"click"> => ["click"]
 * - SplitPath<"*"> => ["*"]
 * - SplitPath<""> => [""]
 */

type SplitPath<T extends string> = Split<T>;

type Min<T extends number[], M extends number = T[0]> = T extends [infer F, ...infer R] ? F extends number ? R extends number[] ? LessThan<F, M> extends true ? Min<R, F> : Min<R, M> : M : M : M;

type IndexOfMin<T extends number[], M = Min<T>, Idx extends any[] = []> = T extends [
    infer F,
    ...infer R extends number[]
] ? F extends M ? Idx["length"] : IndexOfMin<R, M, [...Idx, any]> : never;

type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

type ValueOf<R extends Record<string, any>> = R[keyof R];

type OptionalKeys<T, K extends keyof T> = Expand<Omit<T, K> & {
    [P in K]?: T[P];
}>;

type StrictEqual<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;

type IsAnyRecord<T> = StrictEqual<T, Record<string, any>>;

type ProcessSegment<S extends string> = S extends "*" ? `${string}` : S;
type ProcessSegments<Arr extends string[]> = Arr extends [] ? [] : Arr extends [infer First extends string, ...infer Rest extends string[]] ? [ProcessSegment<First>, ...ProcessSegments<Rest>] : [];
type ReplaceWildcard<T> = T extends string ? IsMultiWildcard<T> extends true ? T extends "**" ? `${string}/${string}` : T extends "*" ? string : T extends `${infer Head}/**` ? `${ReplaceWildcard<Head>}/${string}` : T : Join<ProcessSegments<Split<T>>> : T;

/**
 * 判断单个路径段是否为通配符
 *
 * 示例：
 * - IsWildcardSegment 星号 → true
 * - IsWildcardSegment "rooms" → false
 */
type IsWildcardPart<S extends string> = S extends "*" | "**" ? true : false;

/**
 * CountWildcardSegments 的辅助实现
 * 使用累加器模式计算通配符段数量
 * @param Arr - 路径段数组
 * @param Acc - 累加器（元组），长度即为当前计数
 */
type CountWildcardSegmentsAcc<Arr extends string[], Acc extends any[]> = Arr extends [] ? Acc["length"] : Arr extends [infer First extends string, ...infer Rest extends string[]] ? IsWildcardPart<First> extends true ? CountWildcardSegmentsAcc<Rest, [...Acc, any]> : CountWildcardSegmentsAcc<Rest, Acc> : Acc["length"];
/**
 * 计算路径中通配符段的数量
 *
 * 通配符段是指完全等于星号或双星号的段
 *
 * @example
 *
 * GetWildcardCount<"*">
 *
 *
 */
type GetWildcardCount<T extends string> = IsMultiWildcard<T> extends true ? 99 : CountWildcardSegmentsAcc<SplitPath<T>, []>;

/**
 * 通配符优先级计算工具
 *
 * 用于区分通配符模式的具体程度，解决
 * 核心规则：固定段多的优先级更高
 */

type GetPartCountAcc<Arr extends string[], Acc extends any[]> = Arr extends [] ? Acc["length"] : Arr extends [infer _First extends string, ...infer Rest extends string[]] ? GetPartCountAcc<Rest, [...Acc, any]> : Acc["length"];

/**
 * 计算输入的Key元组的优先级元组
 *
 * 用于匹配时使用
 */
type ToKeyPrioritys<T extends any[]> = {
    [i in keyof T]: IsMultiWildcard<T[i]> extends true ? PrefixNumber<Subtract<10, GetPartCount<T[i]>>, 99> : GetWildcardCount<T[i]>;
};

type ClosestMatch<T> = UnionToTuple<T> extends infer Tuple extends any[] ? Tuple[IndexOfMin<ToKeyPrioritys<Tuple>>] : never;

type GetPartCount<T extends string> = GetPartCountAcc<SplitPath<T>, []>;

type MatchSegment<Input extends string, Pattern extends string> = Pattern extends "*" ? true : Pattern extends "**" ? true : Input extends Pattern ? true : false;
type MatchPatternArray<InputArr extends string[], PatternArr extends string[]> = InputArr extends [
    infer InputHead extends string,
    ...infer InputTail extends string[]
] ? PatternArr extends [infer PatternHead extends string, ...infer PatternTail extends string[]] ? PatternHead extends "**" ? MatchPatternArray<InputArr, PatternTail> extends true ? true : InputArr extends [infer _First, ...infer Rest extends string[]] ? MatchPatternArray<Rest, PatternTail> extends true ? true : MatchPatternArray<Rest, PatternArr> extends true ? true : false : false : MatchSegment<InputHead, PatternHead> extends true ? MatchPatternArray<InputTail, PatternTail> : false : false : PatternArr extends [infer PatternHead extends string, ...infer PatternTail extends string[]] ? PatternHead extends "**" ? PatternTail extends [] ? false : MatchPatternArray<InputArr, PatternTail> : false : true;
/**
 * 判断输入路径是否匹配通配符模式
 * @param Input 输入路径
 * @param Pattern 通配符模式（支持 `*` 单级匹配和 `**` 末尾多级匹配）
 * @returns 匹配返回 true，否则返回 false
 *
 * @example true
 * IsWildcardMatched<"api/v1/users", "users/**"> // false
 */
type IsWildcardMatched<Input extends string, Pattern extends string> = MatchPatternArray<Split<Input>, Split<Pattern>> extends true ? true : false;

/**
 *
 *  列出与T匹配的事件名称
 *
 * {<通配符数量>:<事件名称>}
 *
     type Events = {
        "users/* /login": { userId: number };
        "* /* /login": { userId: number };
        "users/* /profile": { username: string };
    };
 
    type S2 = GetClosestEventNames<Events, "users/123/login">;
    {
        1: "users/* /login";
        2: "* /* /login";
    }
 */
type GetMatchedEventNames<Events extends Record<string, any>, T extends string> = {
    [Key in Exclude<keyof Events, number | symbol> as IsWildcardMatched<T, Key> extends true ? IsMultiWildcard<Key> extends true ? GetPartCount<Key> extends 9 ? 9 : GetPartCount<Key> extends 8 ? 8 : GetPartCount<Key> extends 7 ? 7 : GetPartCount<Key> extends 6 ? 6 : GetPartCount<Key> extends 5 ? 5 : GetPartCount<Key> extends 4 ? 4 : GetPartCount<Key> extends 3 ? 3 : GetPartCount<Key> extends 2 ? 2 : 1 : GetPartCount<Key> extends GetPartCount<T> ? GetWildcardCount<Key> extends 0 ? 0 : GetWildcardCount<Key> extends 1 ? 1 : GetWildcardCount<Key> extends 2 ? 2 : GetWildcardCount<Key> extends 3 ? 3 : GetWildcardCount<Key> extends 4 ? 4 : GetWildcardCount<Key> extends 5 ? 5 : GetWildcardCount<Key> extends 6 ? 6 : GetWildcardCount<Key> extends 7 ? 7 : GetWildcardCount<Key> extends 8 ? 8 : GetWildcardCount<Key> extends 9 ? 9 : never : never : T extends Key ? 0 : never]: Key;
};

/**
 *
 *
 * 返回匹配T的所有Key的元素
 *
 * @example
 *
 *
 */
type GetClosestEventNameTuple<Events extends Record<string, any>, T extends string> = (GetMatchedEventNames<Events, T> extends {
    0: infer V;
} ? V extends never ? never : V : never) | (GetMatchedEventNames<Events, T> extends {
    1: infer V;
} ? V extends never ? never : V : never) | (GetMatchedEventNames<Events, T> extends {
    2: infer V;
} ? V extends never ? never : V : never) | (GetMatchedEventNames<Events, T> extends {
    3: infer V;
} ? V extends never ? never : V : never) | (GetMatchedEventNames<Events, T> extends {
    4: infer V;
} ? V extends never ? never : V : never) | (GetMatchedEventNames<Events, T> extends {
    5: infer V;
} ? V extends never ? never : V : never) | (GetMatchedEventNames<Events, T> extends {
    6: infer V;
} ? V extends never ? never : V : never) | (GetMatchedEventNames<Events, T> extends {
    7: infer V;
} ? V extends never ? never : V : never) | (GetMatchedEventNames<Events, T> extends {
    8: infer V;
} ? V extends never ? never : V : never) | (GetMatchedEventNames<Events, T> extends {
    9: infer V;
} ? V extends never ? never : V : never);

/**
 * 返回最接近的Key
 */
type GetClosestEventName<Events extends Record<string, any>, T extends string> = GetMatchedEventNames<Events, T> extends never ? never : ClosestMatch<GetClosestEventNameTuple<Events, T>>;

/**
 
 type Events = {
        "users/* /login": { userId: number };
        "* /* /login": { userId: number };
        "users/* /profile": { username: string };
    };

type Result1 = GetClosestEvents<Events, "users/123/login">;

 {
    "users/* /login": {
        userId: number;
    };
}
 */
type GetClosestEvents<Events extends Record<string, any>, T extends string, D = Record<string, any>> = GetClosestEventName<Events, T> extends never ? D : Record<AssertString<GetClosestEventName<Events, T>>, Events[AssertString<GetClosestEventName<Events, T>>]>;

/**
 * 返回最匹配的事件元组
 *
 * [事件名称，事件负载]
 *
 * type Events = {
  *   "users/* /login": string;
    "users/* /logout": number;
    "users/* /*": { name: string };
};
 
type Result =GetClosestEventTuple<Events,"users/fisher/login">
type Result = ["users/* /login", string]

 *
 */
type GetClosestEventTuple<Events extends Record<string, any>, T extends string> = ExpandRecord<GetClosestEvents<Events, T>>;

/**
 *
 * - 当K不包括通配符时,直接返回K
 * - 当包括通配符时，返回K | Omit<ReplaceWildcard<K>, K>
 *   这样操作的目的是为了能让IDE提供"users/* /login"并且能适配通配符
 *   如果不这样操作，IDE不会提示
 *
 *
 *
 */
type EnsureEventType<K extends string> = ContainsWildcard<K> extends true ? K | ReplaceWildcard<K> : K;
type MutableMessage<Events extends Record<string, any>, Meta extends Record<string, any> = Record<string, any>> = IsAnyRecord<Events> extends true ? OptionalKeys<FastEventMessage<string, any, Meta>, "meta"> & FastEventMessageExtends : {
    [K in KeyOf<Events>]: Events[K] extends FastMessagePayload ? IfNever<Events[K]["type"], any> : {
        type: ReplaceWildcard<K extends "*" ? string : EnsureEventType<K>>;
        payload: IfNever<Events[K], any>;
        meta?: Meta;
    } & FastEventMessageExtends;
}[KeyOf<Events>];

/**
 * 返回最匹配的事件元组
 *
 * [事件名称，事件负载]
 *
 * type Events = {
  *   "users/* /login": string;
    "users/* /logout": number;
    "users/* /*": { name: string };
};
 
type Result =GetClosestEventTuple<Events,"users/fisher/login">
type Result = ["users/* /login", string]

 *
 */
type GetClosestMessage<Events extends Record<string, any>, T extends string, Meta extends Record<string, any> = never> = FastEventMessage<ContainsWildcard<T> extends true ? ReplaceWildcard<Exclude<ExpandRecord<GetClosestEvents<Events, T>>[0], number | symbol>> : T, ExpandRecord<GetClosestEvents<Events, T>>[1], Meta>;

/**
 * 事件消息相关
 */

interface FastEventMeta {
}
interface FastEventMessageExtends {
}
type FastEventMessage<T extends string = string, P = any, M extends Record<string, any> = Record<string, any>> = {
    type: T;
    payload: P;
    meta?: FastEventMeta & M & Record<string, any>;
} & FastEventMessageExtends;
/**
 * 用于emit方法，允许meta可选，更加宽泛
 */
type FastEventEmitMessage<T extends string = string, P = any, M extends Record<string, any> = Record<string, any>> = OptionalKeys<FastEventMessage<T, P, M>, "meta">;
type WildcardStyle = `*` | `**` | `${string}/*` | `*/${string}` | `${string}/*/${string}` | `${string}/**`;
type TypedFastEventMessage<Events extends Record<string, any> = Record<string, any>, M = any> = ({
    [K in keyof Events as K extends WildcardStyle ? ReplaceWildcard<K> : never]: {
        type: ReplaceWildcard<K>;
        payload: Events[K];
        meta?: Partial<FastEventMeta & M> & Record<string, any>;
    };
} & {
    [K in keyof Events as K extends WildcardStyle ? never : K]: {
        type: Exclude<K, number | symbol>;
        payload: Events[K];
        meta?: Partial<FastEventMeta> & M & Record<string, any>;
    };
})[Exclude<keyof Events, number | symbol>] & FastEventMessageExtends;
type FastMessagePayload<P = any> = {
    type: P;
    __IS_FAST_MESSAGE__: true;
};

/**
 * FastEvent 订阅者类型
 *
 * @description
 * 当使用 { iterable: true } 选项时，返回的订阅者对象支持异步迭代，
 * 可以使用 for await...of 语法消费事件消息。
 *
 * @example
 * ```ts
 * // 普通订阅者（不启用 iterable）
 * const subscriber1 = emitter.on('event', listener);
 * subscriber1.off();
 *
 * // 可迭代订阅者（启用 iterable）
 * const subscriber2 = emitter.on('event', null, { iterable: true });
 * for await (const message of subscriber2) {
 *     console.log(message);
 * }
 * ```
 */
type FastEventSubscriber = {
    /**
     * 取消订阅
     */
    off: () => void;
    /**
     * 同步资源释放（支持 using 语句）
     *
     * @example
     * ```ts
     * {
     *     using subscriber = emitter.on('event', listener);
     *     // subscriber 在作用域结束时自动释放
     * }
     * ```
     */
    [Symbol.dispose]: () => void;
    /**
     * 为什么要有一个listener引用? 主要用于移除监听器时使用
     *
     *  - 正常情况下
     *  const subscriber = emitter.on('event', listener)
     *
     *  subscriber.off()
     *  emitter.off('event', listener)
     *  emitter.off(listener)
     *
     *  - 在使用scope时
     *  const scope = emitter.scope("xxx")
     *  const subscriber = scope.on('event', listener)
     *
     *  subscriber.off()        可以正常生效
     *  scope.off('event', listener)    // 无法生效
     *  scope.off(listener) // 无法生效
     *  因为在scope中，为了让监听器可以处理scope的逻辑，对listener进行了包装，
     *  因此在事件注册表中登记的不是listener，而是经过包装的监听器
     *  subscriber.off()        可以正常生效
     *  如果要使用scope.off或emitter.off
     *  需要使用subscriber.listener， subscriber.listener记录了原始的监听器引用
     *   subscriber.listener===listener
     *
     *  scope.off('event', subscriber.listener)    // 生效
     *  scope.off(subscriber.listener) // 生效
     *
     */
    readonly listener: TypedFastEventListener<any, any, any>;
} & {
    /**
     * 将消息加入队列（内部方法，仅当启用 iterable 时可用）
     * @internal
     */
    _enqueue?: (message: TypedFastEventMessage) => void;
    /**
     * 关闭订阅者（内部方法，仅当启用 iterable 时可用）
     * @internal
     */
    _close?: () => void;
};

type FastListenerExecutor = (listeners: FastEventListenerMeta[], message: TypedFastEventMessage, args: FastEventListenerArgs, execute: (this: FastEventListenerMeta, listener: FastEventListenerMeta, message: TypedFastEventMessage, args: FastEventListenerArgs, catchErrors?: boolean) => Promise<any> | any) => Promise<any[]> | any[];

type FastListenerPipe = (listener: TypedFastEventListener) => TypedFastEventListener;

type GetClosestEventPayload<Events extends Record<string, any>, T extends string> = GetClosestEventTuple<Events, T>[1];

type IsTransformedEvent<Events extends Record<string, any>, T extends string> = T extends keyof Events ? IsAny<Events[T]> extends true ? never : Events[T] extends FastMessagePayload<any> ? T : never : IsAny<GetClosestEventPayload<Events, T>> extends true ? never : GetClosestEventPayload<Events, T> extends FastMessagePayload<any> ? T : never;

type PickPayload<M> = [M] extends [FastMessagePayload] ? M["type"] : M;

type InMatchedEvent<Events extends Record<string, any>, T> = T extends KeyOf<Events> | ReplaceWildcard<KeyOf<Events>> ? true : false;

/**
 * 获取指定事件名称的负载类型
 */
type GetPayload<Events extends Record<string, any>, T> = T extends string ? GetClosestEventTuple<Events, T>[1] : any;

/**
 * FastEventIterator - 使用异步迭代器从 FastEvent 或 FastEventScope 订阅事件
 * 重构：使用 queue.ts 中的队列参数和逻辑
 */

type FastQueueOverflows = "drop" | "expand" | "slide" | "throw";
interface FastEventIteratorOptions<T = FastEventMessage> {
    /** 缓冲区默认大小（默认：100） */
    size?: number;
    /** 缓冲区扩展到多大时不再扩展（默认：1000） */
    maxExpandSize?: number;
    /** 当扩展到最大大小后的溢出策略（默认：'slide'） */
    expandOverflow?: Omit<FastQueueOverflows, "expand">;
    /** 溢出策略（默认：'slide'） */
    overflow?: FastQueueOverflows;
    /** 消息生命周期（毫秒），0表示不启用（默认：0） */
    lifetime?: number;
    /** 当新消息到达时触发此回调 */
    onPush?: (newMessage: T, messages: [T, number][]) => void;
    /** 当消息被弹出时触发此回调，可以在此对消息队列进行排序等操作 */
    onPop?: (messages: [T, number][], hasNew: boolean) => [T, number] | undefined;
    /** 当消息被丢弃时触发此回调 */
    onDrop?: (message: T) => void;
    /** 错误处理函数，返回true表示继续迭代，false表示停止迭代 */
    onError?: (error: Error) => boolean | Promise<boolean>;
    /** 信号，用于取消迭代 */
    signal?: AbortSignal;
}

/**
 * 事件相关
 */

type FastEventOptions<Meta = Record<string, any>, Context = never> = {
    id: string;
    title: string;
    debug: boolean;
    delimiter: string;
    context: Context;
    ignoreErrors: boolean;
    meta: Meta;
    onAddBeforeListener?: (type: string, listener: TypedFastEventListener, options: FastEventListenOptions<Record<string, any>, Meta>) => boolean | FastEventSubscriber | void;
    onAddAfterListener?: (type: string, node: FastEventListenerNode) => void;
    onRemoveListener?: (type: string, listener: TypedFastEventListener, node: FastEventListenerNode) => void;
    onClearListeners?: () => void;
    onListenerError?: (error: Error, listener: TypedFastEventListener, message: TypedFastEventMessage<any, Meta>, args: FastEventListenerArgs<Meta> | undefined) => void;
    onBeforeExecuteListener?: (message: TypedFastEventMessage<any, Meta>, args: FastEventListenerArgs<Meta>) => boolean | void | any[];
    onAfterExecuteListener?: (message: TypedFastEventMessage<any, Meta>, returns: any[], listeners: FastEventListenerNode[]) => void;
    /**
     * 全局执行器
     */
    executor?: FastListenerExecutor;
    /**
     * 是否展开emit返回值,默认为false，用于将事件转发给其他FastEvent时使用
     */
    expandEmitResults?: boolean;
    /**
     * 对接收到的消息进行转换，用于将消息转换成其他格式
     *
     * new FastEvent({
     *    transform:(message)=>{
     *        message.payload
     *    }
     * })
     */
    transform?: (message: FastEventMessage) => any;
};
interface FastEvents {
}
type FastEventListenOptions<Events extends Record<string, any> = Record<string, any>, Meta = any> = {
    count?: number;
    prepend?: boolean;
    flags?: number;
    filter?: (message: TypedFastEventMessage<Events, Meta>, args: FastEventListenerArgs<Meta>) => boolean;
    off?: (message: TypedFastEventMessage<Events, Meta>, args: FastEventListenerArgs<Meta>) => boolean;
    pipes?: FastListenerPipe[];
    /**
     * 为监听器添加一个tag，在监听器注册表中记录,用于调试使用
     * emitter.on(type,listener,{tag:"x"})
     * emitter.getListeners(tag)
     */
    tag?: string;
    /**
     * 异步迭代器选项
     *
     * 用于配置返回异步迭代器的参数
     *
     * 默认值是
        {
            overflow: "expand",
            size: 10,
            maxExpandSize: 100,
        }
     */
    iterable?: FastEventIteratorOptions;
};
declare enum FastEventListenerFlags {
    Transformed = 1
}
type FastEventListenerArgs<M = Record<string, any>> = {
    retain?: boolean;
    meta?: DeepPartial<M> & Record<string, any>;
    abortSignal?: AbortSignal;
    /**
     *
     * allSettled: 使用Promise.allSettled()执行所有监听器
     * race: 使用Promise.race()执行所有监听器，只有第一个执行完成就返回,其他监听器执行结果会被忽略
     * balance: 尽可能平均执行各个监听器
     * sequence: 按照监听器添加顺序依次执行
     */
    executor?: FastListenerExecutor;
    /**
     * 当emit参数解析完成后的回调，用于修改emit参数
     */
    parseArgs?: (message: TypedFastEventMessage, args: FastEventListenerArgs) => void;
    /**
     * 额外的标识
     *
     * - 1: transformed 当消息是经过transform转换后的消息时的标识
     *
     */
    flags?: FastEventListenerFlags;
    /**
     * 如果消息经过转换前的原主题
     */
    rawEventType?: string;
    /**
     * 发布端前缀广播(当前仅 FastLiteEvent 实现运行时支持)
     *
     * 开启后,本次 emit 除命中自身路径外,同时唤醒 emit 终点节点
     * 子树(不含终点自身)内所有已订阅监听器——含通配符订阅
     * (`*` / `**`)与具体后代路径,每个后代收到改写为自身订阅
     * 路径的事件消息。方向仅向下。
     *
     * - `true`:默认改写,自动把后代监听器的 message.type 替换为
     *   该后代完整路径,其余字段原样透传。
     * - 函数:逐个后代调用(后代按 DFS 先序),返回
     *   `[message, args]` 覆盖原消息与参数;返回 `null`/falsy 跳过该后代。
     *
     * 注:正常匹配(emit 路径直接命中)不经 broadcast 改写。
     */
    broadcast?: true | ((type: string, message: FastEventMessage, args: FastEventListenerArgs) => [FastEventMessage, FastEventListenerArgs] | FastEventMessage | null);
};

/**
 * 将对象中值是FastMessagePayload的类型提取出来
 */
type UnTransformedEvents<Events extends Record<string, any>> = {
    [K in keyof Events]: Events[K] extends FastMessagePayload<infer P> ? P : Events[K];
};

type TypedFastEventListener<T extends string = string, P = any, M = any, C = any> = (this: C, message: TypedFastEventMessage<Record<T, P>, M>, args: FastEventListenerArgs<M>) => any | Promise<any>;
type FastEventCommonListener<Message = FastEventMessage, Meta extends Record<string, any> = Record<string, any>, Context = any> = (this: Context, message: Message, args: FastEventListenerArgs<Meta>) => any | Promise<any>;
/**
 * [
 *      0: 监听器函数引用，
 *      1: 需要执行多少次，                     =0代表不限
 *      2: 实际执行的次数(用于负载均衡时记录)
 *      3: 标签            用于调试一般可以标识监听器类型或任意信息
 *      4: 标识,
 *      5: 监听器最后一次执行结果，仅仅在debug时启用，如果结果是对象则是一个WeakRef
 * ]
 */
type FastEventListenerMeta = [
    TypedFastEventListener<any, any>,
    number,
    number,
    string,
    number,
    any?
];
type FastEventListenerNode = {
    __listeners: FastEventListenerMeta[];
} & {
    [key: string]: FastEventListenerNode;
};
type FastListeners = FastEventListenerNode;

/**
 * FastLiteEvent 轻量级事件发射器
 *
 * 从 FastEvent 派生的精简版本，移除了以下高级特性：
 *   scope / hook / meta / pipe / executor / 异步迭代 / context
 *   debug / abortSignal / 订阅时的 filter+off / 监听优先级 prepend
 *
 * 仅保留核心的事件收发能力：on / once / onAny / off / offAll / clear /
 * emit / emitAsync / waitFor / getListeners / clearRetainMessages，以及通配符
 * （* / **）、retain 保留事件、count / tag / flags、ignoreErrors、transform
 * 消息转换、expandEmitResults 等基础特性。
 *
 * 类型与 FastEvent 同源派生（Omit / 复用），监听器、消息、订阅者与 FastEvent
 * 双向兼容——同一监听器函数可同时挂到 FastEvent 与 FastLiteEvent 上。
 */

type FastLiteMessage<T extends string = string, P = any> = Omit<FastEventMessage<T, P>, "meta">;
type FastLiteListenerArgs = Omit<FastEventListenerArgs, "meta" | "executor" | "parseArgs" | "abortSignal">;
type FastLiteListenOptions<Events extends Record<string, any> = Record<string, any>> = Omit<FastEventListenOptions<Events>, "pipes" | "iterable" | "filter" | "off" | "prepend">;
type FastLiteEventOptions = Omit<FastEventOptions, "context" | "meta" | "executor" | "debug" | "onAddBeforeListener" | "onAddAfterListener" | "onRemoveListener" | "onClearListeners" | "onListenerError" | "onBeforeExecuteListener" | "onAfterExecuteListener">;
type FastLiteSubscriber = FastEventSubscriber;
type FastLiteListener<T extends string = string, P = any> = FastEventCommonListener<FastLiteMessage<T, P>, any, any>;
/**
 * FastLiteEvent 轻量级事件发射器类
 *
 * @template Events - 事件类型定义，继承自 FastEvents 接口
 */
declare class FastLiteEvent<Events extends Record<string, any> = Record<string, any>, AllEvents extends Record<string, any> = Expand<Events & FastEvents>, Types extends keyof AllEvents = KeyOf<AllEvents>> {
    __FastLiteEvent__: boolean;
    /** 事件监听器树结构，存储所有注册的事件监听器 */
    listeners: FastListeners;
    /** 事件发射器的配置选项 */
    private _options;
    /** 事件名称的分隔符，默认为 '/' */
    private _delimiter;
    /** 缓存的 transform 函数（构造时规范化：非函数则 undefined）。emit 热路径直接判断，省属性链 + isFunction */
    private _transform;
    /** 缓存的 expandEmitResults 开关（构造时读取，默认 true） */
    private _expandResults;
    /** 保留的事件消息映射，Key 是事件名称，Value 是保留的事件消息 */
    retainedMessages: Map<string, any>;
    /** 当前注册的监听器总数 */
    listenerCount: number;
    /**
     * 创建 FastLiteEvent 实例
     * @param options - 事件发射器的配置选项
     *
     * 默认配置：
     * - id: 随机字符串 - 实例唯一标识符
     * - delimiter: '/' - 事件名称分隔符
     * - ignoreErrors: true - 是否忽略监听器执行错误
     * - expandEmitResults: true - 是否展开 emit 返回值
     */
    constructor(options?: Partial<FastLiteEventOptions>);
    /** 获取事件发射器的配置选项 */
    get options(): FastLiteEventOptions;
    /** 获取事件发射器的唯一标识符 */
    get id(): string;
    /** 获取事件发射器的标题 */
    get title(): string;
    /**
     * 初始化选项（供子类重载）
     * @param initial - 可选的初始选项
     */
    _initOptions(initial?: Partial<FastLiteEventOptions>): Partial<FastLiteEventOptions> | undefined;
    /**
     * 添加事件监听器到事件树（仅尾插，已移除 prepend 插队）
     * @param parts - 事件路径数组
     * @param listener - 事件监听器函数
     * @param options - 监听器配置（count / tag / flags）
     * @returns [节点, 监听器索引]
     */
    private _addListener;
    /**
     * 根据 parts 路径遍历监听器树，并在最后的节点上执行回调
     */
    private _forEachNodes;
    /**
     * 从监听器节点中移除指定的事件监听器
     */
    private _removeListener;
    /**
     * 注册事件监听器
     * @param type - 事件类型，支持普通字符串、通配符（user/*）、全局监听（**）
     * @param listener - 事件监听器函数
     * @param options - 监听器配置（count / tag / flags）
     * @returns 订阅者对象，包含 off 方法用于取消监听
     */
    on<T extends string = KeyOf<Events> | "**">(type: T, listener: FastEventCommonListener<T extends IsTransformedEvent<AllEvents, T> ? PickPayload<ValueOf<GetClosestEvents<Events, T>>> : T extends "**" ? MutableMessage<Events> : GetClosestMessage<Events, T, any>, any, any>, options?: FastLiteListenOptions): FastEventSubscriber;
    /**
     * 注册一次性事件监听器（触发一次后自动注销）
     */
    once<T extends string = KeyOf<Events> | "**">(type: T, listener: FastEventCommonListener<T extends IsTransformedEvent<AllEvents, T> ? PickPayload<ValueOf<GetClosestEvents<Events, T>>> : T extends "**" ? MutableMessage<Events> : GetClosestMessage<Events, T, any>, any, any>, options?: FastLiteListenOptions): FastEventSubscriber;
    /**
     * 注册一个监听所有事件的监听器（等同 on('**', listener)）
     */
    onAny(listener: FastEventCommonListener<MutableMessage<AllEvents, any>, any, any>, options?: FastLiteListenOptions): FastEventSubscriber;
    /**
     * 移除事件监听器
     */
    off(listener: Function): void;
    off(type: string, listener: Function): void;
    off(type: Types): void;
    off(type: string): void;
    /**
     * 移除所有事件监听器
     * @param entry - 可选的事件前缀，提供则只移除该前缀下的监听器
     */
    offAll(entry?: string): void;
    /**
     * 移除保留的事件
     */
    private _removeRetainedEvents;
    /**
     * 清除所有事件或指定前缀的事件（含保留消息）
     */
    clear(prefix?: string): void;
    /**
     * 发送最后一次事件的消息给对应的监听器（用于 retain）
     */
    private _emitRetainMessage;
    /**
     * 遍历监听器节点树，支持三种匹配模式：精确 / 单层通配 * / 多层通配 **
     */
    private _traverseToPath;
    private _traverseListeners;
    /**
     * 监听器执行出错处理（移除了 ListenerError hook）
     */
    private _onListenerError;
    /**
     * 执行单个监听器函数（移除了 debug / abortSignal 分支，this 指向实例）
     */
    private _executeListener;
    /**
     * 执行监听器节点列表中的所有监听器（移除了 executor，退化为同步顺序执行）
     */
    private _executeListeners;
    /**
     * 同步触发事件
     *
     * 支持两种调用方式：
     *   emit(type, payload, retain?)
     *   emit({ type, payload }, retain?)
     */
    emit<R = any, T extends Types = Types>(type: T, payload?: UnTransformedEvents<AllEvents>[T], retain?: boolean): R[];
    emit<R = any, T extends string = string>(type: ReplaceWildcard<T> | Types, payload?: InMatchedEvent<Events, T> extends true ? GetPayload<UnTransformedEvents<AllEvents>, T> : any, retain?: boolean): R[];
    emit<R = any, T extends KeyOf<AllEvents> = KeyOf<AllEvents>>(message: FastEventEmitMessage<T, UnTransformedEvents<AllEvents>[T], any>, retain?: boolean): R[];
    emit<R = any>(message: MutableMessage<AllEvents, any>, retain?: boolean): R[];
    emit<R = any>(message: {
        type: keyof AllEvents;
    }, retain?: boolean): R[];
    emit<R = any>(message: FastEventMessage, retain?: boolean): R[];
    emit<R = any, T extends string = string>(type: ReplaceWildcard<T> | Types, payload?: InMatchedEvent<Events, T> extends true ? GetPayload<UnTransformedEvents<AllEvents>, T> : any, options?: FastLiteListenerArgs): R[];
    /**
     * 发布端前缀广播快捷方法（等价于 emit(type, payload, { broadcast, retain })）。
     *
     * callback 省略时默认走 broadcast:true（后代监听器的 message.type 改写为
     * 后代完整路径）；传入 callback 则逐个后代改写，返回 null/falsy 跳过该后代。
     */
    broadcast<R = any, T extends string = string>(type: ReplaceWildcard<T> | Types, payload?: InMatchedEvent<Events, T> extends true ? GetPayload<UnTransformedEvents<AllEvents>, T> : any, callback?: (type: string, message: FastLiteMessage, args: FastLiteListenerArgs) => [FastLiteMessage, FastLiteListenerArgs] | FastLiteMessage | null, retain?: boolean): R[];
    /**
     * 异步触发事件（使用 Promise.allSettled，等待所有异步监听器完成）
     */
    emitAsync<R = any, T extends Types = Types>(type: T, payload?: UnTransformedEvents<AllEvents>[T], retain?: boolean): Promise<(R | Error)[]>;
    emitAsync<R = any, T extends string = string>(type: ReplaceWildcard<T> | Types, payload?: InMatchedEvent<Events, T> extends true ? GetPayload<UnTransformedEvents<AllEvents>, T> : any, retain?: boolean): Promise<(R | Error)[]>;
    emitAsync<R = any, T extends KeyOf<AllEvents> = KeyOf<AllEvents>>(message: FastEventEmitMessage<T, UnTransformedEvents<AllEvents>[T], any>, retain?: boolean): Promise<(R | Error)[]>;
    emitAsync<R = any>(message: MutableMessage<AllEvents, any>, retain?: boolean): Promise<(R | Error)[]>;
    emitAsync<R = any>(message: {
        type: keyof AllEvents;
    }, retain?: boolean): Promise<(R | Error)[]>;
}

export { FastLiteEvent, type FastLiteEventOptions, type FastLiteListenOptions, type FastLiteListener, type FastLiteListenerArgs, type FastLiteMessage, type FastLiteSubscriber };