declare const encode: (arraybuffer: ArrayBuffer) => string;
declare const decode: (base64: string) => ArrayBuffer;

/** 运行环境 */
type Env = "wx" | "qq" | "donut" | "js";
/** 运行环境 */
declare const env: Env;

type EventType = string | symbol;
type Handler<T = unknown> = (event: T) => void | Promise<void>;
type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void | Promise<void>;
type EventHandlerList<T = unknown> = Handler<T>[];
type WildCardEventHandlerList<T = Record<string, unknown>> = WildcardHandler<T>[];
type EventHandlerMap<Events> = Map<keyof Events | "*", EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>>;
interface EmitterInstance<Events> {
    all: EventHandlerMap<Events>;
    on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
    on(type: "*", handler: WildcardHandler<Events>): void;
    off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
    off(type: "*", handler: WildcardHandler<Events>): void;
    emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
    emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
    emitAsync<Key extends keyof Events>(type: Key, event: Events[Key]): Promise<void>;
    emitAsync<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): Promise<void>;
}
/**
 * Tiny (~300b) functional event emitter / pubsub.
 * @name emitter
 * @returns Emitter
 */
declare function Emitter<Events>(all?: EventHandlerMap<Events>): EmitterInstance<Events>;

interface MpErrorOptions {
    code?: number;
    message?: string;
}
declare class MpError extends Error {
    code: number | null;
    constructor({ code, message }: MpErrorOptions);
    toString(): string;
}

/** 写入普通日志 */
declare const debug: (...args: any[]) => void;
/** 写入信息日志 */
declare const info: (...args: any[]) => void;
/** 写入警告日志 */
declare const warn: (...args: any[]) => void;
/** 写入错误日志 */
declare const error: (...args: any[]) => void;
/**
 * 写入过滤信息
 *
 * @param filterMsg 过滤信息
 */
declare const filter: (filterMsg: string) => void;

declare const logger_debug: typeof debug;
declare const logger_error: typeof error;
declare const logger_filter: typeof filter;
declare const logger_info: typeof info;
declare const logger_warn: typeof warn;
declare namespace logger {
  export {
    logger_debug as debug,
    logger_error as error,
    logger_filter as filter,
    logger_info as info,
    logger_warn as warn,
  };
}

/**
 * 字符串参数解析
 *
 * @param queryString 需要解析的字符串
 * @param [splitter='&'] 分隔符
 *
 * @returns 参数对象
 */
declare const parse: (queryString?: string, splitter?: string) => Record<string, string>;
/**
 * query 对象转换字符串
 *
 * @param params query 对象
 * @param [splitter='&] 分隔符
 * @param [unencoded=false] 是否已经解码
 *
 * @returns 解析的字符串
 */
declare const stringify: (params?: Record<string, string>, splitter?: string, unencoded?: boolean) => string;
/**
 * URL 添加 query
 *
 * @param path 前部分路径
 * @param queries query对象
 * @param unencoded 是否已经解码，默认为否
 *
 * @returns 处理过的 url
 */
declare const join: (path: string, queries: Record<string, string>, unencoded?: boolean) => string;

declare const query_join: typeof join;
declare const query_parse: typeof parse;
declare const query_stringify: typeof stringify;
declare namespace query {
  export {
    query_join as join,
    query_parse as parse,
    query_stringify as stringify,
  };
}

/**
 * 获取变量类型
 *
 * @param obj 需要辨别的变量
 * @returns 对象的类型
 */
declare const type: (obj: unknown) => string;
declare const isFunction: <T extends Function>(obj: unknown) => obj is T;

/**
 * 包装函数，先执行 wrapper ，然后执行原函数
 *
 * @param original 原函数
 * @param pre 预执行函数
 *
 * @returns 包装函数
 *
 * E.g.:
 *
 * ```ts
 * const a = () => console.log('a');
 * const b = () => console.log('b');
 * const c = wrapFunction(a, b);
 *
 * c(); // expect to output 'a', and then output 'b'
 * ```
 */
declare function wrapFunction<T>(original: ((this: T, ...args: any[]) => void) | undefined, pre: (this: T, ...args: any[]) => void): (this: T, ...args: any[]) => void;
declare function wrapFunction<T>(original: ((this: T, ...args: any[]) => Promise<void>) | undefined, pre: (this: T, ...args: any[]) => void): (this: T, ...args: any[]) => Promise<void>;
/**
 * 锁定某个函数使其无法被再次执行直到函数自己解锁
 *
 * @param fn 需要锁定的函数, 形式为 `(release: () => void, ...args: A) => R`
 * @param ctx 可选的上下文环境
 *
 * @returns 封装函数，形式为 `(...args: A) => R`
 *
 * ```ts
 * let count = 0;
 * const func = (release: () => void) => {
 *   count += 1;
 *   setTimeout(() => {
 *     release();
 *   }, 10)
 * };
 *
 * const fn = tool.lock(func);
 *
 * fn(); // count is 1
 * fn(); // count is still 1 because it's not released
 * setTimeout(() => {
 *   fn(); // count is 2 because it's released
 *   fn(); // count is still 2 because it's locked again
 * }, 15);
 * ```
 */
declare const lock: <T, A extends unknown[], R>(fn: (this: T, release: () => void, ...args: A) => R, ctx?: T) => ((this: T, ...args: A) => R | undefined);
/**
 * 包装函数保证其之被调用一次
 *
 * @param func 调用的函数
 * @param ctx 可选的上下文环境
 *
 * @returns 包装过的函数
 *
 * E.g.:
 *
 * ```ts
 * let count = 0;
 * const counter = once(() => count++ );
 * counter(); // count is 1
 * counter(); // count is still 1
 * ```
 */
declare const once: <T, A extends unknown[], R>(func: (...args: A) => R, ctx?: T) => ((this: T, ...args: A) => R | undefined);
interface Task<ArgType extends unknown[] = unknown[], This = unknown> {
    /** 函数本身 */
    func: (this: This, next: () => void, ...args: ArgType) => void;
    /** 函数的运行上下文 */
    ctx: This;
    /** 函数的参数 */
    args: ArgType;
}
/**
 * 一个队列，在上一个函数执行完毕后执行 `next()`  才会开始执行下一个函数。
 */
declare class Queue {
    /** 允许同时并行的任务数 */
    capacity: number;
    constructor(
    /** 允许同时并行的任务数 */
    capacity?: number);
    /** 回调队列 */
    funcQueue: Task[];
    /** 正在运行的数量 */
    running: number;
    /** 执行下一个函数 */
    next(): void;
    /**
     * 添加函数
     * @param func 函数
     * @param ctx 函数运行上下文
     * @param args 函数参数
     */
    add<A extends any[], T>(func: (next: () => void, ...args: A) => void, ctx?: T, ...args: A): void;
    /** 清除队列，不再执行尚未执行的函数 */
    clear(): void;
}
/**
 * 在调用函数的时候启用队列，在上一个函数执行完毕后执行 `next()`  才会开始执行下一个函数。
 *
 * @param fn 处理的函数
 * @param capacity 允许同时并行的任务数
 *
 * @returns 包装过的函数
 * @async
 */
declare const funcQueue: <A extends unknown[], T = unknown>(fn: (next: () => void, ...args: A) => void, capacity?: number) => ((this: T, ...args: A) => void);

type Props = Record<string, unknown>;
type PropsOptions<Property = Props> = {
    [K in keyof Property]: PropItem<Property[K]> | null;
};
type PropItem<Type, Default = Type> = PropOption<Type, Default> | PropConstructor<Type>;
interface PropOption<Type = any, Default = Type> {
    /** 属性类型 */
    type?: PropType<Type> | null;
    /**
     * 是否必填
     *
     * @description 仅用作类型推导，无检查
     */
    required?: boolean;
    /** 属性初始值 */
    default?: Default | null | undefined | object;
}
type PropMethod<Type, TypeConstructor = any> = Type extends (...args: any) => any ? {
    new (): TypeConstructor;
    (): Type;
    readonly prototype: TypeConstructor;
} : never;
type PropConstructor<Type = any> = (new (...args: any[]) => Type & {}) | (() => Type) | PropMethod<Type>;
type PropType<T> = PropConstructor<T> | PropConstructor<T>[];
type InferFromType<Type> = [Type] extends [null] ? any : [Type] extends [ArrayConstructor] ? any[] : [Type] extends [ObjectConstructor] ? WechatMiniprogram.IAnyObject : [Type] extends [BooleanConstructor] ? boolean : [Type] extends [PropConstructor<infer V>] ? unknown extends V ? any : V : Type;
type RequiredKeys<T> = {
    [K in keyof T]: T[K] extends {
        required: true;
    } | {
        default: any;
    } ? T[K] extends {
        default: undefined | (() => undefined);
    } ? never : K : never;
}[keyof T];
type OptionalKeys<Type> = Exclude<keyof Type, RequiredKeys<Type>>;
type InferPropType<Type> = [Type] extends [null] ? any : [Type] extends [{
    type: null;
}] ? any : [Type] extends [ArrayConstructor | {
    type: ArrayConstructor;
}] ? any[] : [Type] extends [ObjectConstructor | {
    type: ObjectConstructor;
}] ? WechatMiniprogram.IAnyObject : [Type] extends [BooleanConstructor | {
    type: BooleanConstructor;
}] ? boolean : [Type] extends [PropItem<infer Value, infer Default>] ? unknown extends Value ? Default : Value : Type;
type InferPropTypes<O> = O extends object ? {
    [K in keyof O]?: unknown;
} & {
    [K in RequiredKeys<O>]: InferPropType<O[K]>;
} & {
    [K in OptionalKeys<O>]?: InferPropType<O[K]>;
} : Record<string, any>;
interface ComponentLifetimes {
    /** 组件生命周期声明对象 */
    lifetimes: Partial<{
        /**
         * 在组件实例刚刚被创建时执行，注意此时不能调用 `setData`
         *
         * 最低基础库版本：[`1.6.3`](https://developers.weixin.qq.com/miniprogram/dev/framework/compatibility.html)
         */
        created(): void;
        /**
         * 在组件实例进入页面节点树时执行
         *
         * 最低基础库版本：[`1.6.3`](https://developers.weixin.qq.com/miniprogram/dev/framework/compatibility.html)
         */
        attached(): void;
        /**
         * 在组件在视图层布局完成后执行
         *
         * 最低基础库版本：[`1.6.3`](https://developers.weixin.qq.com/miniprogram/dev/framework/compatibility.html)
         */
        ready(): void;
        /**
         * 在组件实例被移动到节点树另一个位置时执行
         *
         * 最低基础库版本：[`1.6.3`](https://developers.weixin.qq.com/miniprogram/dev/framework/compatibility.html)
         */
        moved(): void;
        /**
         * 在组件实例被从页面节点树移除时执行
         *
         * 最低基础库版本：[`1.6.3`](https://developers.weixin.qq.com/miniprogram/dev/framework/compatibility.html)
         */
        detached(): void;
        /**
         * 每当组件方法抛出错误时执行
         *
         * 最低基础库版本：[`2.4.1`](https://developers.weixin.qq.com/miniprogram/dev/framework/compatibility.html)
         */
        error(err: WechatMiniprogram.Error): void;
    }>;
}
interface ExtendedComponentProperty {
    /**
     * 当前组件的唯一标识
     */
    $id: number;
    /**
     * 当前组件上用于索引的 ref ID 值
     */
    $refID: string;
    /**
     * 当前组件所属的页面组件实例
     *
     * @description 只在 `attached`, `ready` 生命周期后生效
     */
    $root: TrivialPageInstance;
    /**
     * 当前组件所属的父组件实例引用
     *
     * @description 只在 `attached`, `ready` 生命周期后生效
     */
    $parent: TrivialPageInstance | TrivialComponentInstance;
    /**
     * 指定了 `ref` 的子组件实例映射
     *
     * 示例:
     *
     * ```html
     * <custom-component binding="$" ref="customComp"/>
     * ```
     *
     * ```js
     * $Component({
     *   lifetimes:{
     *     attached() {
     *       this.$refs.customComp // 根据ref属性获取子组件的实例引用
     *     }
     *   }
     * });
     * ```
     */
    $refs: RefMap;
}
/** 组件实例 */
interface ExtendedComponentMethods extends InstanceEmitterMethods {
    /**
     * 通过消息的方式调用父组件方法，方法不存在也不会报错
     *
     * @param method 方法名称
     * @param args 传递的参数
     */
    $call(method: string, ...args: unknown[]): void;
    /**
     * @private
     */
    $attached(parent: TrivialComponentInstance | TrivialPageInstance): void;
}
type ComponentInstance<Data extends WechatMiniprogram.Component.DataOption, Props extends PropsOptions, Method extends Partial<WechatMiniprogram.Component.MethodOption>, Behavior extends WechatMiniprogram.Component.BehaviorOption, InstanceProps extends WechatMiniprogram.IAnyObject = Record<never, never>, IsPage extends boolean = false> = WechatMiniprogram.Component.InstanceProperties & WechatMiniprogram.Component.InstanceMethods<Data> & ExtendedComponentMethods & Method & (IsPage extends true ? WechatMiniprogram.Page.ILifetime : Record<never, never>) & InstanceProps & ExtendedComponentProperty & ExtendedPageMethods<Data & InferPropTypes<Props>, InstanceProps & Method & WechatMiniprogram.Component.MixinMethods<Behavior> & (IsPage extends true ? WechatMiniprogram.Page.ILifetime : Record<never, never>)> & {
    /** 组件数据，**包括内部数据和属性值** */
    data: Data & InferPropTypes<Props>;
    /**
     * @deprecated 优先使用 `data`
     *
     * 组件数据，**包括内部数据和属性值**（与 `data` 一致）
     */
    properties: Data & InferPropTypes<Props>;
};
type ComponentOptions<Data extends WechatMiniprogram.Component.DataOption, Props extends PropsOptions, Method extends WechatMiniprogram.Component.MethodOption, Behavior extends WechatMiniprogram.Component.BehaviorOption, InstanceProps extends WechatMiniprogram.IAnyObject = Record<never, never>, IsPage extends boolean = false> = Partial<WechatMiniprogram.Component.Data<Data>> & Partial<{
    /** 组件属性 */
    props: Props;
}> & Partial<WechatMiniprogram.Component.Behavior<Behavior>> & Partial<WechatMiniprogram.Component.Method<Method, IsPage>> & Partial<WechatMiniprogram.Component.OtherOption> & Partial<ComponentLifetimes> & ThisType<ComponentInstance<Data, Props, Method, Behavior, InstanceProps, IsPage>>;
type ComponentConstructor = <Data extends WechatMiniprogram.Component.DataOption, Props extends PropsOptions, Method extends WechatMiniprogram.Component.MethodOption, Behavior extends WechatMiniprogram.Component.BehaviorOption, InstanceProps extends WechatMiniprogram.IAnyObject = Record<never, never>, IsPage extends boolean = false>(options: ComponentOptions<Data, Props, Method, Behavior, InstanceProps, IsPage>) => string;
type TrivialComponentInstance = ComponentInstance<WechatMiniprogram.IAnyObject, Record<string, null>, Record<string, (...args: unknown[]) => any>, [
]>;
type TrivialComponentOptions = ComponentOptions<WechatMiniprogram.IAnyObject, Record<string, null>, Record<string, (...args: any[]) => any>, [
]>;
type RefMap = Record<string, TrivialComponentInstance>;

declare const handleProperties: (oldProps?: PropsOptions) => WechatMiniprogram.Component.PropertyOption;
/**
 * 组件注册器
 *
 * @param options 注册选项
 */
declare const $Component: ComponentConstructor;

declare const getRef: (id: number) => TrivialComponentInstance;
declare const setRef: (id: number, value: TrivialComponentInstance) => void;
declare const removeRef: (id: number) => void;

declare const go: (pageName: string) => Promise<WechatMiniprogram.NavigateToSuccessCallbackResult>;
declare const redirect: (pageName: string) => Promise<WechatMiniprogram.GeneralCallbackResult>;
declare const switchTab: (pageName: string) => Promise<WechatMiniprogram.GeneralCallbackResult>;
declare const reLaunch: (pageName: string) => Promise<WechatMiniprogram.GeneralCallbackResult>;
declare function bind(this: TrivialComponentInstance, touchEvent: WechatMiniprogram.Touch<{
    id: number;
    event: string;
    args: unknown[];
}>): void;

/** 页面跳转 API */
interface NavigatorMethods {
    /**
     * 导航到指定页面
     *
     * 本函数是 `wx.navigateTo` 的封装，`pageName` 可以带上 `queryString`
     *
     * @param pageName 页面名称或页面的路径
     *
     * 示例：
     *
     * ```js
     * this.$go('play?vid=xxx&cid=xxx');
     * ```
     */
    $go(pageName: string): Promise<WechatMiniprogram.NavigateToSuccessCallbackResult>;
    /**
     * 跳转到指定页面, **替换页面，不产生历史**
     *
     * 本函数是 `wx.redirectTo` 的封装，`pageName` 可以带上 `queryString`
     *
     * @param pageName 页面名称或页面的路径
     *
     * 示例：
     *
     * ```js
     * this.$redirect('about');
     * ```
     */
    $redirect(pageName: string): Promise<WechatMiniprogram.GeneralCallbackResult>;
    /**
     * 跳转到指定 tabBar 页面，并关闭其他所有非 tabBar 页面
     *
     * 本函数是 `wx.switchTab` 的封装，路径参数只用于触发 `onNavigate`
     *
     * @param pageName 页面名称或页面的路径
     *
     * 示例：
     *
     * ```js
     * this.$switch('main?user=mrhope');
     * ```
     */
    $switch(pageName: string): Promise<WechatMiniprogram.GeneralCallbackResult>;
    /**
     * 关闭所有页面，之后打开到应用内的某个页面
     *
     * 本函数是 `wx.reLaunch` 的封装，`pageName` 可以带上 `queryString`
     *
     * @param pageName 页面名称或页面的路径
     *
     * 示例：
     *
     * ```js
     * this.$launch('main');
     * ```
     */
    $reLaunch(pageName: string): Promise<WechatMiniprogram.GeneralCallbackResult>;
    /**
     * 返回上一页，`wx.navigateBack` 的封装
     *
     * @param delta 返回的层数，默认为 `1`
     *
     * 示例：
     *
     * ```js
     * this.$back();
     * this.$back(2);
     * ```
     */
    $back(delta?: number): Promise<WechatMiniprogram.GeneralCallbackResult>;
    /**
     * 提前预加载指定页面 (会触发对应页面的 `onPreload` 生命周期)
     *
     * @param pageName 页面名称或页面的路径，可以带上 `queryString`
     *
     * 示例：
     *
     * ```js
     * this.$preload('main?id=xxx&target=xxx');
     * this.$preload('/page/main?userName=xxx&action=xxx');
     * ```
     */
    $preload(pageName: string): void | Promise<void>;
    /**
     * 点击代理方法，绑定 `$go` 逻辑
     *
     * 在元素上声明 `data-url` 作为跳转地址，支持切面方法：
     *
     * - `data-before` 跳转前执行
     * - `data-after`  跳转后执行
     *
     * 示例：
     *
     * ```html
     * <button
     *   catch:tap="$bindGo"
     *   data-url="/pages/play"
     *   data-before="onClickBefore"
     * >click go</button>
     * ```
     */
    $bindGo(event: WechatMiniprogram.Touch): void | Promise<void>;
    /**
     * 点击代理方法，绑定 `$redirect` 逻辑
     *
     * 你需要在元素上声明 `data-url` 作为跳转地址，同时支持切面方法：
     *
     * - `data-before` 跳转前执行
     * - `data-after`  跳转后执行
     *
     * 示例：
     *
     * ```html
     * <button
     *   catch:tap="$bindRedirect"
     *   data-url="/pages/play"
     *   data-before="onClickBefore"
     * >click redirect</button>
     * ```
     */
    $bindRedirect(event: WechatMiniprogram.Touch): void | Promise<void>;
    /**
     * 点击代理方法，绑定 `$switch` 逻辑
     *
     * 你需要在元素上声明 `data-url` 作为跳转地址，同时支持切面方法：
     *
     * - `data-before` 跳转前执行
     * - `data-after`  跳转后执行
     *
     * 示例：
     *
     * ```html
     * <button
     *   catch:tap="$bindSwitch"
     *   data-url="/pages/play"
     *   data-before="onClickBefore"
     * >click switch</button>
     * ```
     */
    $bindSwitch(event: WechatMiniprogram.Touch): void | Promise<void>;
    /**
     * 点击代理方法，绑定 `$reLaunch` 逻辑。
     *
     * 你需要在元素上声明 `data-url` 作为跳转地址，同时支持切面方法：
     *
     * - `data-before` 跳转前执行
     * - `data-after`  跳转后执行
     *
     * 示例:
     *
     * ```html
     * <button
     *   catch:tap="$bindReLaunch"
     *   data-url="/pages/play"
     *   data-before="onClickBefore"
     * >click relaunch</button>
     * ```
     */
    $bindRelaunch(event: WechatMiniprogram.Touch): void | Promise<void>;
    /**
     * 点击代理方法，绑定 `$back` 逻辑
     * 你可以在元素上声明 `data-delta` 作为回退层数
     *
     * - `data-before` 跳转前执行
     * - `data-after`  跳转后执行
     *
     * 示例:
     *
     * ```html
     * <button
     *   catch:tap="$bindBack"
     *   data-delta="1"
     *   data-before="onClickBefore"
     * >click relaunch</button>
     * ```
     */
    $bindBack(): Promise<void> | void;
}

type PageQuery = Record<string, string>;
interface PageState {
    /** 是否是打开的第一个页面 */
    firstOpen: boolean;
}
interface ExtendedPageLifeCycles {
    /**
     * 在页面注册时调用
     *
     * 此时页面的 this 还不可用
     */
    onRegister(): void;
    /**
     * 在 `App.onLaunch` 触发时调用
     *
     * @param App.onLaunch 参数
     */
    onAppLaunch(options: WechatMiniprogram.App.LaunchShowOption): void | Promise<void>;
    /**
     * 小程序在切入后台后被唤醒
     *
     * @param time 休眠时间 (单位 ms)
     */
    onAwake(time: number): void | Promise<void>;
    /**
     * 页面预加载时触发
     *
     * 可在其他页面中使用 `this.$preload(pageNameWithArgs|pageUrl)` 触发特定页面的预加载周期
     *
     * @param options url 参数对象
     */
    onPreload(options: PageQuery): void | Promise<void>;
    /**
     * 页面即将被导航时触发
     *
     * 需要在调用页面中使用框架提供的跳转方式 `this.$go(pageNameWithArgs|pageUrl)`
     * 才能正确触发 `onNavigate`
     *
     * 另外需要特别注意第一次进入一个分包界面
     * 或者是通过微信小程序二维码或微信内分享直接跳转到小程序子页面时同样不会触发
     */
    onNavigate(options: PageQuery): void | Promise<void>;
}
interface ExtendedPageProperties {
    /** 当前页面名称 */
    $name: string;
    /** 一些由框架生成的页面状态 */
    $state: PageState;
    /**
     * 指定了 `ref` 的子组件实例映射
     *
     * 示例:
     *
     * ```html
     * <custom-component binding="$" ref="customComp"/>
     * ```
     *
     * ```js
     * $Page({
     *   onLoad() {
     *     this.$refs.customComp // 根据ref属性获取子组件的实例引用
     *   }
     * });
     * ```
     */
    $refs: RefMap;
}
interface ExtendedPageMethods<Data extends WechatMiniprogram.IAnyObject, Custom extends WechatMiniprogram.IAnyObject> extends InstanceEmitterMethods, NavigatorMethods {
    /**
     * 绑定组件函数
     */
    $: typeof bind;
    /**
     * 获取当前页面实例。
     */
    $currentPage(): PageInstance<Data, Custom>;
    /**
     * 获得页面路径
     *
     * @param name 页面简称
     */
    $getPath(name: string): string;
}
type PageInstance<Data extends WechatMiniprogram.IAnyObject, Custom extends WechatMiniprogram.IAnyObject> = WechatMiniprogram.OptionalInterface<WechatMiniprogram.Page.ILifetime & ExtendedPageLifeCycles> & WechatMiniprogram.Page.InstanceProperties & WechatMiniprogram.Page.InstanceMethods<Data> & ExtendedPageMethods<Data, Custom> & ExtendedPageProperties & WechatMiniprogram.Page.Data<Data> & Custom;
type PageOptions<Data extends WechatMiniprogram.IAnyObject, Custom extends WechatMiniprogram.IAnyObject> = (Custom & Partial<WechatMiniprogram.Page.Data<Data>> & Partial<WechatMiniprogram.Page.ILifetime & ExtendedPageLifeCycles> & Partial<ExtendedPageProperties> & {
    options?: WechatMiniprogram.Component.ComponentOptions;
}) & ThisType<PageInstance<Data, Custom>>;
type PageConstructor = <Data extends WechatMiniprogram.IAnyObject, Custom extends WechatMiniprogram.IAnyObject>(name: string, options: PageOptions<Data, Custom>) => void;
type TrivialPageInstance = PageInstance<WechatMiniprogram.IAnyObject, WechatMiniprogram.IAnyObject>;
type TrivialPageOptions = PageOptions<WechatMiniprogram.IAnyObject, WechatMiniprogram.IAnyObject>;

declare const $Page: PageConstructor;

type UserEmitter = EmitterInstance<WechatMiniprogram.IAnyObject>;
declare const userEmitter: UserEmitter;

interface InstanceEmitterMethods {
    /**
     * 事件名到处理函数的映射
     * @memberOf [Emitter](https://miniapp-tool.github.io/api/enhance/emitter.html) 实例
     */
    $all: UserEmitter["all"];
    /**
     * 为特定事件类型注册处理函数
     *
     * @param type 监听的事件类型，使用 `'*'` 监听所有事件
     * @param handler 待添加的响应函数
     * @memberOf [Emitter](https://miniapp-tool.github.io/api/enhance/emitter.html) 实例
     */
    $on: UserEmitter["on"];
    /**
     * 从特定事件类型移除指定监听器
     *
     * 如果省略 `handler`，给定类型的所有事件均被忽略
     *
     * @param {string|symbol} type 取消监听的事件类型，使用 `'*'` 取消监听所有事件
     * @param {Function} [handler] 待移除的响应函数
     * @memberOf [Emitter](https://miniapp-tool.github.io/api/enhance/emitter.html) 实例
     */
    $off: UserEmitter["off"];
    /**
     * 调用所有给定事件类型的响应函数
     *
     * 如果存在，`'*'` 响应函数会在符合事件类型的响应函数之后调用
     *
     * 注意，手动调用 `'*'` 事件不被支持
     *
     * @param type 待触发的事件类型
     * @param event 传递给所有响应函数的事件
     * @memberOf [Emitter](https://miniapp-tool.github.io/api/enhance/emitter.html) 实例
     */
    $emit: UserEmitter["emit"];
    /**
     * 异步调用所有给定事件类型的响应函数
     *
     * 所有响应函数将被并行调用。
     *
     * 如果存在，`'*'` 响应函数会在符合事件类型的响应函数之后并行调用
     *
     * 注意，手动调用 `'*'` 事件不被支持
     *
     * @param type 待触发的事件类型
     * @param event 传递给所有响应函数的事件
     * @memberOf [Emitter](https://miniapp-tool.github.io/api/enhance/emitter.html) 实例
     */
    $emitAsync: UserEmitter["emitAsync"];
}

interface ExtendsAppOptions {
    /**
     * 小程序在切入后台后被唤醒
     *
     * @param time 休眠时间 (单位ms)
     */
    onAwake?(time: number): void;
}
type ExtendedAppMethods = InstanceEmitterMethods;
type AppOptions<Custom> = ExtendsAppOptions & Partial<WechatMiniprogram.App.Option> & Custom & Partial<ExtendedAppMethods> & ThisType<AppInstance<Custom>>;
type AppInstance<Custom> = AppOptions<Custom> & Custom & ExtendedAppMethods;
type AppConstructor = <Custom extends WechatMiniprogram.IAnyObject>(appOptions: AppOptions<Custom>) => void;

declare const appState: {
    /** 是否已启动 */
    launch: boolean;
    /** 启动参数 */
    lOpt: {};
    /** 切入后台时的时间戳 */
    hide: number;
};
/**
 * Application wrapper
 *
 * @param appOptions App Option
 */
declare const $App: AppConstructor;

interface AppConfigCommonOptions {
    /**
     * 主页页面名称或路径
     */
    home?: string;
    /**
     * 跳转延迟执行的最长时间，单位 ms
     *
     * @description 异步 onNavigate 方法用时过久会直接调转
     *
     * @default 200
     */
    maxDelay?: number;
    /**
     * 允许进行跳转据页面首屏渲染后的最小间隔时间，单位 ms
     *
     * @default 100
     */
    minInterval?: number;
    /**
     * 自定义扩展组件
     *
     * 时机在框架执行扩展之前，可为每个组件挂载实例方法
     *
     * @param options 组件选项
     */
    extendComponent?(options: TrivialComponentOptions): void;
    /**
     * 自定义注入组件
     *
     * 时机在框架执行扩展之后，这意味着你可以覆盖框架的方法
     *
     * @param options 组件选项
     */
    injectComponent?(options: TrivialComponentOptions): void;
    /**
     * 自定义扩展页面，在框架执行扩展之前
     *
     * @param name 页面名称
     * @param options 页面选项
     */
    extendPage?(name: string, options: TrivialPageOptions): void;
    /**
     * 自定义注入页面
     *
     * 在框架执行扩展之后，这意味着你可以覆盖框架的方法
     *
     * @param name 页面名称
     * @param options 页面选项
     */
    injectPage?(name: string, options: TrivialPageOptions): void;
}
interface RoutePathConfig {
    /**
     * 当你给出的页面路径或简称无法通过 routeMap 解析时，会回退到此路径
     *
     * 填入小程序路径模式，小程序路径模式是一个路径字符串，用 `$name` 表示小程序简称的位置
     *
     * 例子: 你可以填入 `/pages/$name/$name` 来表达:
     *
     * - `main': '/pages/main/main`
     * - `user': '/pages/user/user`
     */
    defaultPage: string;
    /**
     * 你可以直接以对象形式表示简称到路径的映射。如:
     *
     * ```js
     * {
     *   main: '/pages/main/main',
     *   cart: '/pages/cart/cart',
     *   user: '/pages/user/user',
     * }
     * ```
     *
     * 也支持以在页面复杂的情况下数组格式表示小程序路径映射，数组的元素有两种填写方式:
     *
     * - `[页面简称, 小程序路经]`
     *
     * - `[页面简称数组, 小程序路经模式]`
     *
     *   小程序路径模式是一个路径字符串，用 `$name` 表示小程序简称的位置
     *
     * 如:
     *
     * ```js
     * [
     *   [['main', 'cart', 'user'], '/pages/$name/$name'],
     *   [['search', 'details', 'order'], '/shop/$name/$name'],
     *   ['about', '/others/about/about'],
     * ]
     * ```
     *
     * 等效于:
     *
     * ```js
     * {
     *   'main': '/pages/main/main',
     *   'cart': '/pages/cart/cart',
     *   'user': '/pages/user/user',
     *   'search': '/shop/search/search',
     *   'details': '/shop/details/details',
     *   'order': '/shop/order/order',
     *   'about': '/others/about/about',
     * }
     * ```
     *
     * @description 无法解析的路径会回退到 `defaultPage`
     */
    pages?: Record<string, string> | [string | string[], string][];
}
interface RouteCustomConfig {
    /**
     * 获得页面路径
     *
     * @param pageName 页面简称
     * @returns 页面路径
     */
    getPath: (pageName: string) => string;
}
type AppConfigOptions = AppConfigCommonOptions & (RoutePathConfig | RouteCustomConfig);

interface Config extends Omit<AppConfigOptions, "defaultPage" | "pages"> {
    /**
     * 获得页面路径
     *
     * @param pageName 页面简称
     * @returns 页面路径
     */
    getPath: (pageName: string) => string;
}
declare const $Config: (config: AppConfigOptions) => void;
declare const getConfig: () => Config;

export { $App, $Component, $Config, $Page, Emitter, MpError, Queue, appState, decode as decodeBase64, userEmitter as emitter, encode as encodeBase64, env, funcQueue, getConfig, getRef, go, handleProperties, isFunction, lock, logger, once, query, reLaunch, redirect, removeRef, setRef, switchTab, type, wrapFunction };
export type { AppConfigCommonOptions, AppConfigOptions, AppConstructor, AppInstance, AppOptions, ComponentConstructor, ComponentInstance, ComponentLifetimes, ComponentOptions, Config, EmitterInstance, Env, EventHandlerList, EventHandlerMap, EventType, ExtendedAppMethods, ExtendedComponentMethods, ExtendedComponentProperty, ExtendedPageLifeCycles, ExtendedPageMethods, ExtendedPageProperties, ExtendsAppOptions, Handler, InferFromType, InferPropType, InferPropTypes, MpErrorOptions, PageConstructor, PageInstance, PageOptions, PageQuery, PageState, PropItem, PropOption, PropType, Props, PropsOptions, RefMap, RouteCustomConfig, RoutePathConfig, Task, TrivialComponentInstance, TrivialComponentOptions, TrivialPageInstance, TrivialPageOptions, WildCardEventHandlerList, WildcardHandler };