@kitbag/router 0.0.1 → 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/README.md +18 -2
  2. package/dist/kitbag-router.d.ts +560 -3703
  3. package/dist/kitbag-router.js +1216 -4728
  4. package/dist/kitbag-router.umd.cjs +1 -4951
  5. package/package.json +1 -1
package/dist/kitbag-router.d.ts CHANGED
@@ -1,32 +1,14 @@
1
1
  import { AsyncComponentLoader } from 'vue';
2
2
  import { Component } from 'vue';
3
- import { ComponentOptionsBase } from 'vue';
4
3
  import { ComponentOptionsMixin } from 'vue';
5
- import { ComponentPublicInstance } from 'vue';
6
- import { ComputedGetter } from 'vue';
7
- import { ComputedOptions } from 'vue';
8
- import { ComputedSetter } from 'vue';
9
- import { DebuggerEvent } from 'vue';
10
4
  import { DeepReadonly } from 'vue';
11
5
  import { DefineComponent } from 'vue';
12
- import { DefineSetupFnComponent } from 'vue';
13
- import { DirectiveBinding } from 'vue';
14
- import { DirectiveHook } from 'vue';
15
6
  import { ExtractPropTypes } from 'vue';
16
- import { FunctionalComponent } from 'vue';
17
- import { FunctionDirective } from 'vue';
18
7
  import { InjectionKey } from 'vue';
19
- import { LooseRequired } from '@vue/shared';
20
- import { MethodOptions } from 'vue';
21
8
  import { Plugin as Plugin_2 } from 'vue';
22
9
  import { PropType } from 'vue';
23
10
  import { PublicProps } from 'vue';
24
11
  import { Ref } from 'vue';
25
- import { RendererElement } from 'vue';
26
- import { RendererNode } from 'vue';
27
- import { Slot } from 'vue';
28
- import { VNode } from 'vue';
29
- import { WatchCallback } from 'vue';
30
12
 
31
13
  declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
32
14
 
@@ -51,81 +33,101 @@ declare type __VLS_WithTemplateSlots_2<T, S> = T & {
51
33
  };
52
34
  };
53
35
 
36
+ /**
37
+ * Adds a hook that is called after a route change. Returns a function to remove the hook.
38
+ * @param hook - {@link AfterRouteHook} The hook function to add.
39
+ * @returns {RouteHookRemove} A function that removes the added hook.
40
+ */
54
41
  export declare type AddAfterRouteHook = (hook: AfterRouteHook) => RouteHookRemove;
55
42
 
43
+ /**
44
+ * Adds a hook that is called before a route change. Returns a function to remove the hook.
45
+ * @param hook - {@link BeforeRouteHook} The hook function to add.
46
+ * @returns {RouteHookRemove} A function that removes the added hook.
47
+ */
56
48
  export declare type AddBeforeRouteHook = (hook: BeforeRouteHook) => RouteHookRemove;
57
49
 
58
- declare type AfterContext = {
59
- to: ResolvedRoute;
60
- from: ResolvedRoute;
61
- hooks: RouteHookStore;
62
- };
63
-
50
+ /**
51
+ * Represents a function called after a route change has occurred.
52
+ * @param to - {@link ResolvedRoute} The resolved route the router has navigated to.
53
+ * @param context - {@link AfterRouteHookContext} The context providing functions and state for the routing operation.
54
+ * @returns Possibly a promise that resolves when the hook's logic has completed.
55
+ */
64
56
  export declare type AfterRouteHook = (to: ResolvedRoute, context: AfterRouteHookContext) => MaybePromise<void>;
65
57
 
58
+ /**
59
+ * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
60
+ */
66
61
  declare type AfterRouteHookContext = RouteHookContext;
67
62
 
63
+ /**
64
+ * Enumerates the lifecycle events for after route hooks.
65
+ */
68
66
  export declare type AfterRouteHookLifecycle = 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
69
67
 
70
- declare type AfterRouteHookRegistration = {
71
- timing: RouteHookTiming;
72
- lifecycle: 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
73
- hook: AfterRouteHook;
74
- depth: number;
75
- };
76
-
77
- export declare type AfterRouteHookResponse<T extends Routes> = RouteHookSuccessResponse | RouteHookPushResponse<T> | RouteHookRejectResponse;
68
+ /**
69
+ * Type for responses from an after route hook, which may indicate different outcomes such as success, push, or reject.
70
+ * @template TRoutes - The type of the routes configuration.
71
+ */
72
+ export declare type AfterRouteHookResponse<TRoutes extends Routes> = RouteHookSuccessResponse | RouteHookPushResponse<TRoutes> | RouteHookRejectResponse;
78
73
 
79
- export declare type AllPropertiesAreOptional<T> = IsEmptyObject<OnlyRequiredProperties<T>>;
74
+ declare type AllPropertiesAreOptional<T> = Record<string, unknown> extends T ? true : IsEmptyObject<OnlyRequiredProperties<T>>;
80
75
 
81
- export declare function asArray<T>(value: T | T[]): T[];
82
-
83
- export declare function assembleUrl(route: Route, options?: AssembleUrlOptions): string;
84
-
85
- declare type AssembleUrlOptions = {
86
- params?: Record<string, unknown>;
87
- query?: Record<string, string>;
76
+ declare type BaseResolvedRoute = Route & {
77
+ path: {
78
+ params: Record<string, unknown>;
79
+ };
80
+ query: {
81
+ params: Record<string, unknown>;
82
+ };
88
83
  };
89
84
 
90
85
  declare type BaseRoute = {
91
86
  key: string;
92
87
  disabled: false;
93
- pathParams: Record<string, unknown>;
94
- queryParams: Record<string, unknown>;
95
- };
96
-
97
- declare type BeforeContext = {
98
- to: ResolvedRoute;
99
- from: ResolvedRoute;
100
- hooks: RouteHookStore;
88
+ path: {
89
+ params: Record<string, unknown>;
90
+ };
91
+ query: {
92
+ params: Record<string, unknown>;
93
+ };
101
94
  };
102
95
 
96
+ /**
97
+ * Represents a function called before a route change, potentially altering the routing operation.
98
+ * @param to - {@link ResolvedRoute} The resolved route the router is navigating to.
99
+ * @param context - {@link BeforeRouteHookContext} The context providing functions and state for the routing operation.
100
+ * @returns Possibly a promise that resolves when the hook's logic has completed.
101
+ */
103
102
  export declare type BeforeRouteHook = (to: ResolvedRoute, context: BeforeRouteHookContext) => MaybePromise<void>;
104
103
 
104
+ /**
105
+ * Context provided to route hooks, containing context of previous route and functions for triggering rejections, push/replace to another route,
106
+ * as well as aborting current route change.
107
+ */
105
108
  declare type BeforeRouteHookContext = RouteHookContext & {
106
109
  abort: RouteHookAbort;
107
110
  };
108
111
 
112
+ /**
113
+ * Enumerates the lifecycle events for before route hooks.
114
+ */
109
115
  export declare type BeforeRouteHookLifecycle = 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
110
116
 
111
- declare type BeforeRouteHookRegistration = {
112
- timing: RouteHookTiming;
113
- lifecycle: 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
114
- hook: BeforeRouteHook;
115
- depth: number;
116
- };
117
-
118
- export declare type BeforeRouteHookResponse<T extends Routes> = RouteHookSuccessResponse | RouteHookPushResponse<T> | RouteHookRejectResponse | RouteHookAbortResponse;
119
-
120
- declare type BuiltInRejectionComponents = Partial<Record<BuiltInRejectionType, RouteComponent>>;
121
-
122
- export declare const builtInRejectionComponents: Record<BuiltInRejectionType, RouteComponent>;
117
+ /**
118
+ * Type for responses from a before route hook, which may indicate different outcomes such as success, push, reject, or abort.
119
+ * @template TRoutes - The type of the routes configuration.
120
+ */
121
+ export declare type BeforeRouteHookResponse<TRoutes extends Routes> = RouteHookSuccessResponse | RouteHookPushResponse<TRoutes> | RouteHookRejectResponse | RouteHookAbortResponse;
123
122
 
124
- export declare const builtInRejections: readonly ["NotFound"];
123
+ declare const builtInRejections: readonly ["NotFound"];
125
124
 
126
- export declare type BuiltInRejectionType = typeof builtInRejections[number];
125
+ declare type BuiltInRejectionType = typeof builtInRejections[number];
127
126
 
128
- export declare type ChildRouteProps = WithHooks & {
127
+ /**
128
+ * Represents properties for child routes, including required component, name, and path.
129
+ */
130
+ declare type ChildRouteProps = WithHooks & {
129
131
  name: string;
130
132
  disabled?: boolean;
131
133
  path: string | Path;
@@ -150,54 +152,62 @@ declare type CombineQuery<TParent extends Query | undefined, TChild extends Quer
150
152
  } ? ToQuery<TChild> extends {
151
153
  query: infer TChildQuery extends string;
152
154
  params: infer TChildParams extends Record<string, unknown>;
153
- } ? MergeParams<TParentParams, TChildParams> extends QueryParams<`${TParentQuery}${TChildQuery}`> ? Query<`${TParentQuery}${TChildQuery}`, MergeParams<TParentParams, TChildParams>> : Query<'', {}> : Query<'', {}> : Query<'', {}>;
154
-
155
- export declare const component: {
156
- template: string;
157
- };
158
-
159
- export declare function countExpectedQueryKeys(route: Route, actualQuery: URLSearchParams): number;
160
-
161
- export declare function createCurrentRoute(fallbackRoute: ResolvedRoute): CurrentRoute;
162
-
163
- export declare function createMaybeRelativeUrl(value: string): MaybeRelativeUrl;
164
-
165
- export declare function createResolvedRouteQuery(query?: string): ResolvedRouteQuery;
166
-
167
- export declare function createRouteHookRunners<const T extends Routes>(): RouteHookRunners<T>;
168
-
155
+ } ? MergeParams<TParentParams, TChildParams> extends QueryParams<CombineQueryString<TParentQuery, TChildQuery>> ? Query<CombineQueryString<TParentQuery, TChildQuery>, MergeParams<TParentParams, TChildParams>> : Query<'', {}> : Query<'', {}> : Query<'', {}>;
156
+
157
+ declare type CombineQueryString<TParent extends string | undefined, TChild extends string | undefined> = StringHasValue<TParent> extends true ? StringHasValue<TChild> extends true ? `${TParent}&${TChild}` : TParent : TChild;
158
+
159
+ /**
160
+ * Creates a router instance for a Vue application, equipped with methods for route handling, lifecycle hooks, and state management.
161
+ *
162
+ * @param routes - {@link Routes} An array of route definitions specifying the configuration of routes in the application.
163
+ * Use createRoutes method to create the route definitions.
164
+ * @param options - {@link RouterOptions} for the router, including history mode and initial URL settings.
165
+ * @returns Router instance
166
+ *
167
+ * @example
168
+ * ```ts
169
+ * import { createRoutes, createRouter } from '@kitbag/router'
170
+ *
171
+ * const Home = { template: '<div>Home</div>' }
172
+ * const About = { template: '<div>About</div>' }
173
+ *
174
+ * export const routes = createRoutes([
175
+ * { name: 'home', path: '/', component: Home },
176
+ * { name: 'path', path: '/about', component: About },
177
+ * ])
178
+ *
179
+ * const router = createRouter(routes)
180
+ * ```
181
+ */
169
182
  export declare function createRouter<const T extends Routes>(routes: T, options?: RouterOptions): Router<T>;
170
183
 
171
- export declare function createRouterFind<const TRoutes extends Routes>(routes: TRoutes): RouterFind<TRoutes>;
172
-
173
- export declare function createRouterHistory({ mode }?: RouterHistoryOptions): RouterHistory;
174
-
175
- export declare function createRouterHooks(): RouterHooks;
176
-
177
- export declare type CreateRouterReject = {
178
- setRejection: RouterSetReject;
179
- rejection: RouterRejection;
180
- getRejectionRoute: GetRejectionRoute;
181
- isRejectionRoute: IsRejectionRoute;
182
- };
183
-
184
- export declare function createRouterReject({ rejections: customRejectionComponents, }: CreateRouterRejectContext): CreateRouterReject;
185
-
186
- declare type CreateRouterRejectContext = {
187
- rejections?: RouterRejectionComponents['rejections'];
188
- };
189
-
190
- export declare function createRouterResolve<const TRoutes extends Routes>(routes: TRoutes): RouterResolve<TRoutes>;
191
-
184
+ /**
185
+ * Creates an array of routes from a defined set of route properties, handling hierarchical route combinations.
186
+ * This function also validates for duplicate parameter keys across the combined routes.
187
+ *
188
+ * @param routesProps - An array of route properties used to configure and create routes.
189
+ * @returns An array of fully configured Route instances.
190
+ */
192
191
  export declare function createRoutes<const TRoutes extends Readonly<RouteProps[]>>(routes: TRoutes): FlattenRoutes<TRoutes>;
193
192
 
194
- declare type CurrentRoute = {
195
- route: ResolvedRoute;
196
- updateRoute: ResolvedRouteUpdate;
197
- };
198
-
199
- export declare const depthInjectionKey: InjectionKey<number>;
193
+ /**
194
+ * An error thrown when duplicate parameters are detected in a route when creating a router.
195
+ * When defining routes, param names must be unique. This includes params defined in a path
196
+ * parent and params defined in the query.
197
+ */
198
+ export declare class DuplicateParamsError extends Error {
199
+ /**
200
+ * Constructs a new DuplicateParamsError instance with a message indicating the problematic parameter.
201
+ * @param paramName - The name of the parameter that was duplicated.
202
+ */
203
+ constructor(paramName: string);
204
+ }
200
205
 
206
+ /**
207
+ * Extracts the parameter name from a string, handling optional parameters denoted by a leading '?'.
208
+ * @template TParam - The string from which to extract the parameter name.
209
+ * @returns The extracted parameter name, or never if the parameter string is empty.
210
+ */
201
211
  export declare type ExtractParamName<TParam extends string> = TParam extends `?${infer Param}` ? Param extends '' ? never : Param : TParam extends '' ? never : TParam;
202
212
 
203
213
  declare type ExtractParamsFromPathString<TPath extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TPath extends `${infer Path}${ParamEnd}` ? ExtractParamsFromPathString<Path, TParams> : TPath extends `${string}:${infer Param}${ParamEnd}${infer Rest}` ? MergeParams<{
@@ -206,12 +216,28 @@ declare type ExtractParamsFromPathString<TPath extends string, TParams extends R
206
216
  [P in ExtractParamName<Param>]: ExtractPathParamType<Param, TParams>;
207
217
  } : Record<never, never>;
208
218
 
219
+ /**
220
+ * Extracts the actual type from a parameter type, handling getters, setters, and potential undefined values.
221
+ * @template TParam - The parameter type.
222
+ * @returns The extracted type, or 'string' as a fallback.
223
+ */
209
224
  export declare type ExtractParamType<TParam extends Param | undefined> = TParam extends ParamGetSet<infer Type> ? undefined extends TParam ? Type | undefined : Type : TParam extends ParamGetter ? undefined extends TParam ? ReturnType<TParam> | undefined : ReturnType<TParam> : undefined extends TParam ? undefined : string;
210
225
 
226
+ /**
227
+ * Transforms a record of parameter types into a type with optional properties where the original type allows undefined.
228
+ * @template TParams - The record of parameter types, possibly including undefined.
229
+ * @returns A new type with the appropriate properties marked as optional.
230
+ */
211
231
  export declare type ExtractParamTypes<TParams extends Record<string, Param | undefined>> = Identity<MakeOptional<{
212
232
  [K in keyof TParams]: ExtractParamType<TParams[K]>;
213
233
  }>>;
214
234
 
235
+ /**
236
+ * Determines the type of a path parameter from a record of parameter types, considering optional parameters.
237
+ * @template TParam - The parameter name string.
238
+ * @template TParams - The record object mapping parameter names to their types.
239
+ * @returns The type associated with the parameter, or StringConstructor if unspecified; may be undefined for optional parameters.
240
+ */
215
241
  export declare type ExtractPathParamType<TParam extends string, TParams extends Record<string, Param | undefined>> = TParam extends `?${infer OptionalParam}` ? OptionalParam extends keyof TParams ? TParams[OptionalParam] | undefined : StringConstructor | undefined : TParam extends keyof TParams ? TParams[TParam] : StringConstructor;
216
242
 
217
243
  declare type ExtractQueryParamsFromQueryString<TQuery extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TQuery extends `${string}=:${infer Param}&${infer Rest}` ? MergeParams<{
@@ -222,13 +248,26 @@ declare type ExtractQueryParamsFromQueryString<TQuery extends string, TParams ex
222
248
 
223
249
  declare type ExtractRouteChildren<TRoute extends RouteProps> = TRoute extends ParentRouteProps ? TRoute['children'] extends Route[] ? TRoute['children'] : [] : [];
224
250
 
251
+ /**
252
+ * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
253
+ * @template TRoute - The route type from which to extract and merge parameter types.
254
+ * @returns A record of parameter names to their respective types, extracted and merged from both path and query parameters.
255
+ */
225
256
  export declare type ExtractRouteParamTypes<TRoute extends {
226
- pathParams: Record<string, unknown>;
227
- queryParams: Record<string, unknown>;
257
+ path: {
258
+ params: Record<string, unknown>;
259
+ };
260
+ query: {
261
+ params: Record<string, unknown>;
262
+ };
228
263
  }> = TRoute extends {
229
- pathParams: infer PathParams extends Record<string, Param | undefined>;
230
- queryParams: infer QueryParams extends Record<string, Param | undefined>;
231
- } ? ExtractParamTypes<MergeParams<PathParams, QueryParams>> : never;
264
+ path: {
265
+ params: infer PathParams extends Record<string, Param | undefined>;
266
+ };
267
+ query: {
268
+ params: infer QueryParams extends Record<string, Param | undefined>;
269
+ };
270
+ } ? ExtractParamTypes<MergeParams<PathParams, QueryParams>> : Record<string, unknown>;
232
271
 
233
272
  declare type Flatten<T extends any[]> = T extends [infer First, ...infer Rest] ? First extends unknown[] ? Flatten<[...First, ...Flatten<Rest>]> : [First, ...Flatten<Rest>] : [];
234
273
 
@@ -245,125 +284,97 @@ declare type FlattenRoutes<TRoutes extends Readonly<RouteProps[]>> = Flatten<[
245
284
  }
246
285
  ]>;
247
286
 
248
- export declare function generateRoutePathRegexPattern(route: Route): RegExp;
249
-
250
- export declare function generateRouteQueryRegexPatterns(route: Route): RegExp[];
251
-
252
- export declare function getAfterRouteHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute): RouteHooks;
253
-
254
- export declare function getBeforeRouteHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute): RouteHooks;
255
-
256
- export declare function getInitialUrl(initialUrl?: string): string;
257
-
258
- export declare function getParam<P extends Record<string, Param | undefined>>(params: P, param: string): Param;
259
-
260
- export declare function getParamsForString<TInput extends string, TParams extends Record<string, Param | undefined>>(string: TInput, params: TParams): Record<string, Param>;
261
-
262
- export declare function getParamValue<T extends Param>(value: string | undefined, param: T): ExtractParamType<T>;
263
-
264
- export declare function getParamValueFromUrl(url: string, path: string, paramName: string): string | undefined;
265
-
266
- declare type GetRejectionRoute = (type: RouterRejectionType) => ResolvedRoute;
267
-
268
- export declare function getResolvedRouteForUrl(routes: Routes, url: string): ResolvedRoute | undefined;
269
-
270
- export declare function getRouteHookCondition(lifecycle: RouteHookLifecycle): RouteHookCondition;
271
-
272
- export declare const getRouteParamValues: (route: Route, url: string) => Record<string, unknown>;
273
-
274
- export declare function getRouteScoreSortMethod(url: string): RouteSortMethod;
275
-
276
- export declare function hasProperty<TSource extends Record<PropertyKey, unknown>, TProperty extends PropertyKey, TType extends () => unknown>(value: TSource, key: TProperty, type?: TType): value is TSource & Record<TProperty, ReturnType<TType>>;
277
-
278
- export declare type Identity<T> = T extends object ? {} & {
287
+ declare type Identity<T> = T extends object ? {} & {
279
288
  [P in keyof T as T[P] extends never ? never : P]: T[P];
280
289
  } : T;
281
290
 
282
- export declare class InvalidRouteParamValueError extends Error {
283
- }
284
-
285
- export declare type IsAny<T> = 0 extends (1 & T) ? true : false;
286
-
287
- export declare function isBrowser(): boolean;
288
-
289
- export declare type IsEmptyObject<T> = T extends Record<string, never> ? (keyof T extends never ? true : false) : false;
291
+ declare type IsEmptyObject<T> = T extends Record<string, never> ? (keyof T extends never ? true : false) : false;
290
292
 
293
+ /**
294
+ * Type guard to check if a value conforms to the ParamGetSet type.
295
+ * @param value - The value to check.
296
+ * @returns True if the value is an object with both 'get' and 'set' functions defined.
297
+ */
291
298
  export declare function isParamGetSet(value: Param): value is ParamGetSet;
292
299
 
300
+ /**
301
+ * Type guard to check if a value conforms to the ParamGetter type.
302
+ * @param value - The value to check.
303
+ * @returns True if the value is a function that is not a constructor.
304
+ */
293
305
  export declare function isParamGetter(value: Param): value is ParamGetter;
294
306
 
295
- export declare function isParentRoute(value: RouteProps): value is ParentRouteProps;
296
-
297
- export declare function isRecord(value: unknown): value is Record<PropertyKey, unknown>;
298
-
299
- declare type IsRejectionRoute = (route: ResolvedRoute) => boolean;
300
-
301
- export declare const isRouteEnter: RouteHookCondition;
302
-
303
- export declare const isRouteLeave: RouteHookCondition;
304
-
305
- export declare const isRouteUpdate: RouteHookCondition;
306
-
307
- export declare function isUrl(value: unknown): value is Url;
308
-
309
307
  declare type MakeOptional<T> = {
310
308
  [P in WithOptionalProperties<T>]?: T[P];
311
309
  } & {
312
310
  [P in Exclude<keyof T, WithOptionalProperties<T>>]: T[P];
313
311
  };
314
312
 
315
- export declare function markRouteRaw(route: RouteProps): RouteProps;
313
+ declare type MaybeArray<T> = T | T[];
316
314
 
317
- export declare type MaybeArray<T> = T | T[];
318
-
319
- export declare type MaybeDeepReadonly<T> = T | DeepReadonly<T>;
320
-
321
- export declare type MaybePromise<T> = T | Promise<T>;
322
-
323
- export declare type MaybeRelativeUrl = {
324
- protocol?: string;
325
- host?: string;
326
- pathname: string;
327
- searchParams: URLSearchParams;
328
- search: string;
329
- hash: string;
330
- };
315
+ declare type MaybePromise<T> = T | Promise<T>;
331
316
 
317
+ /**
318
+ * Merges two parameter type records, ensuring no overlap in properties.
319
+ * @template TAlpha - The first record type.
320
+ * @template TBeta - The second record type.
321
+ * @returns A new record type combining properties from both inputs without overlaps.
322
+ */
332
323
  export declare type MergeParams<TAlpha extends Record<string, unknown>, TBeta extends Record<string, unknown>> = {
333
324
  [K in keyof TAlpha | keyof TBeta]: K extends keyof TAlpha & keyof TBeta ? never : K extends keyof TAlpha ? TAlpha[K] : K extends keyof TBeta ? TBeta[K] : never;
334
325
  };
335
326
 
336
327
  declare type NamedNotDisabled<T> = T extends BaseRoute ? T : never;
337
328
 
338
- declare type NavigationBack = () => void;
339
-
340
- declare type NavigationForward = () => void;
341
-
342
- declare type NavigationGo = (delta: number) => void;
343
-
344
- declare type NavigationPushOptions = {
345
- replace?: boolean;
346
- };
347
-
348
- declare type NavigationRefresh = () => void;
349
-
350
- declare type NavigationUpdate = (url: string, options?: NavigationPushOptions) => void;
351
-
352
- export declare const NotFound: DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, PublicProps>;
353
-
354
- export declare type OnlyRequiredProperties<T> = {
329
+ /**
330
+ * Registers a hook that is called after a route has been entered. Must be called during setup.
331
+ * This allows performing actions right after the component becomes active, such as fetching data or setting up event listeners.
332
+ *
333
+ * @param AfterRouteHook - The hook callback function
334
+ * @returns {RouteHookRemove} A function that removes the added hook.
335
+ */
336
+ export declare const onAfterRouteEnter: AddAfterRouteHook;
337
+
338
+ /**
339
+ * Registers a hook that is called after a route has been left. Must be called during setup.
340
+ * This can be used for cleanup actions after the component is no longer active, ensuring proper resource management.
341
+ *
342
+ * @param AfterRouteHook - The hook callback function
343
+ * @returns {RouteHookRemove} A function that removes the added hook.
344
+ */
345
+ export declare const onAfterRouteLeave: AddAfterRouteHook;
346
+
347
+ /**
348
+ * Registers a hook that is called after a route has been updated. Must be called during setup.
349
+ * This is ideal for responding to updates within the same route, such as parameter changes, without full component reloads.
350
+ *
351
+ * @param AfterRouteHook - The hook callback function
352
+ * @returns {RouteHookRemove} A function that removes the added hook.
353
+ */
354
+ export declare const onAfterRouteUpdate: AddAfterRouteHook;
355
+
356
+ /**
357
+ * Registers a hook that is called before a route is left. Must be called from setup.
358
+ * This is useful for performing actions or cleanups before navigating away from a route component.
359
+ *
360
+ * @param BeforeRouteHook - The hook callback function
361
+ * @returns {RouteHookRemove} A function that removes the added hook.
362
+ */
363
+ export declare const onBeforeRouteLeave: AddBeforeRouteHook;
364
+
365
+ /**
366
+ * Registers a hook that is called before a route is updated. Must be called from setup.
367
+ * This is particularly useful for handling changes in route parameters or query while staying within the same component.
368
+ *
369
+ * @param BeforeRouteHook - The hook callback function
370
+ * @returns {RouteHookRemove} A function that removes the added hook.
371
+ */
372
+ export declare const onBeforeRouteUpdate: AddBeforeRouteHook;
373
+
374
+ declare type OnlyRequiredProperties<T> = {
355
375
  [K in keyof T as Extract<T[K], undefined> extends never ? K : never]: T[K];
356
376
  };
357
377
 
358
- export declare function optional<TParam extends Param>(param: TParam): OptionalParamGetSet<TParam>;
359
-
360
- declare const optionalKey: unique symbol;
361
-
362
- declare type OptionalParamGetSet<TParam extends Param, TValue = ExtractParamType<TParam> | undefined> = ParamGetSet<TValue> & {
363
- [optionalKey]: true;
364
- get: (value: string | undefined, extras: ParamExtras) => TValue;
365
- };
366
-
367
378
  export declare type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor;
368
379
 
369
380
  declare type ParamEnd = '/';
@@ -379,133 +390,231 @@ export declare type ParamGetSet<T = any> = {
379
390
 
380
391
  export declare type ParamGetter<T = any> = (value: string, extras: ParamExtras) => T;
381
392
 
382
- declare type ParamRawValue<T> = Extract<T, undefined> extends never ? string : string | undefined;
383
-
384
- export declare type ParamReplace = {
385
- name: string;
386
- param: Param;
387
- value?: unknown;
388
- };
389
-
390
393
  export declare type ParamSetter<T = any> = (value: T, extras: ParamExtras) => string;
391
394
 
392
- export declare type ParentRouteProps = WithHooks & {
395
+ /**
396
+ * Represents properties common to parent routes in a route configuration, including hooks, path, and optional query parameters.
397
+ */
398
+ declare type ParentRouteProps = WithHooks & {
393
399
  name?: string;
394
400
  path: string | Path;
395
401
  query?: string | Query;
396
402
  disabled?: boolean;
397
- children?: Routes;
403
+ children: Routes;
398
404
  component?: RouteComponent;
399
405
  meta?: RouteMeta;
400
406
  };
401
407
 
402
- export declare type Path<T extends string = any, P extends PathParams<T> = any> = {
408
+ declare type Path<T extends string = any, P extends PathParams<T> = any> = {
403
409
  path: T;
404
410
  params: Identity<ExtractParamsFromPathString<T, P>>;
405
411
  toString: () => string;
406
412
  };
407
413
 
408
- export declare function path<T extends string, P extends PathParams<T>>(path: T, params: Identity<P>): Path<T, P>;
409
-
410
- export declare type PathParams<T extends string> = {
414
+ /**
415
+ * Constructs a Path object, which enables assigning types for params.
416
+ *
417
+ * @template TPath - The string literal type that represents the path.
418
+ * @template TParams - The type of the path parameters associated with the path.
419
+ * @param path - The path string.
420
+ * @param params - The parameters associated with the path, typically as key-value pairs.
421
+ * @returns An object representing the path which includes the path string, its parameters,
422
+ * and a toString method for getting the path as a string.
423
+ *
424
+ * @example
425
+ * ```ts
426
+ * import { createRoutes, path } from '@kitbag/router'
427
+ *
428
+ * export const routes = createRoutes([
429
+ * {
430
+ * name: 'home',
431
+ * path: path('/:foo', { foo: Number }),
432
+ * component: Home
433
+ * },
434
+ * ])
435
+ * ```
436
+ */
437
+ export declare function path<TPath extends string, TParams extends PathParams<TPath>>(path: TPath, params: Identity<TParams>): Path<TPath, TParams>;
438
+
439
+ declare type PathParams<T extends string> = {
411
440
  [K in keyof ExtractParamsFromPathString<T>]?: Param;
412
441
  };
413
442
 
414
- export declare type Query<T extends string = any, P extends QueryParams<T> = any> = {
443
+ declare type Query<T extends string = any, P extends QueryParams<T> = any> = {
415
444
  query: T;
416
445
  params: Identity<ExtractQueryParamsFromQueryString<T, P>>;
417
446
  toString: () => string;
418
447
  };
419
448
 
420
- export declare function query<T extends string, P extends QueryParams<T>>(query: T, params: Identity<P>): Query<T, P>;
421
-
422
- export declare type QueryParams<T extends string> = {
449
+ /**
450
+ * Constructs a Query object, which enables assigning types for params.
451
+ *
452
+ * @template TQuery - The string literal type that represents the query.
453
+ * @template TParams - The type of the query parameters associated with the query.
454
+ * @param query - The query string.
455
+ * @param params - The parameters associated with the query, typically as key-value pairs.
456
+ * @returns An object representing the query which includes the query string, its parameters,
457
+ * and a toString method for getting the query as a string.
458
+ *
459
+ * @example
460
+ * ```ts
461
+ * import { createRoutes, query } from '@kitbag/router'
462
+ *
463
+ * export const routes = createRoutes([
464
+ * {
465
+ * name: 'home',
466
+ * query: query('?bar=:bar', { bar: Boolean }),
467
+ * component: Home
468
+ * },
469
+ * ])
470
+ * ```
471
+ */
472
+ export declare function query<TQuery extends string, TParams extends QueryParams<TQuery>>(query: TQuery, params: Identity<TParams>): Query<TQuery, TParams>;
473
+
474
+ declare type QueryParams<T extends string> = {
423
475
  [K in keyof ExtractQueryParamsFromQueryString<T>]?: Param;
424
476
  };
425
477
 
426
- export declare const random: {
427
- number(options?: {
428
- min?: number;
429
- max?: number;
430
- }): number;
431
- };
432
-
478
+ /**
479
+ * Represents the state of currently registered router, and rejections. Used to provide correct type context for
480
+ * components like `RouterLink`, as well as for composables like `useRouter`, `useRoute`, and hooks.
481
+ *
482
+ * @example
483
+ * ```ts
484
+ * declare module '@kitbag/router' {
485
+ * interface Register {
486
+ * router: typeof router
487
+ * }
488
+ * }
489
+ * ```
490
+ */
433
491
  export declare interface Register {
434
492
  }
435
493
 
494
+ /**
495
+ * Represents the possible Rejections registered within {@link Register}
496
+ */
436
497
  export declare type RegisteredRejectionType = Register extends {
437
498
  rejections: infer TRejections extends string[];
438
499
  } ? TRejections[number] : never;
439
500
 
501
+ /**
502
+ * Represents the a map of all possible RouteKeys with corresponding Route registered within {@link Register}
503
+ */
440
504
  export declare type RegisteredRouteMap = RoutesMap<RegisteredRoutes>;
441
505
 
506
+ /**
507
+ * Represents the Router property within {@link Register}
508
+ */
442
509
  export declare type RegisteredRouter = Register extends {
443
510
  router: infer TRouter;
444
- } ? TRouter : Router<any>;
511
+ } ? TRouter : Router;
445
512
 
513
+ /**
514
+ * Represents the type for router `push`, with types for routes registered within {@link Register}
515
+ */
446
516
  export declare type RegisteredRouterPush = RouterPush<RegisteredRoutes>;
447
517
 
518
+ /**
519
+ * Represents the type for router `replace`, with types for routes registered within {@link Register}
520
+ */
448
521
  export declare type RegisteredRouterReplace = RouterReplace<RegisteredRoutes>;
449
522
 
523
+ /**
524
+ * Represents the State property registered within {@link Register}
525
+ */
450
526
  export declare type RegisteredRouterState = Register extends {
451
527
  state: infer TState;
452
528
  } ? TState : {};
453
529
 
530
+ /**
531
+ * Represents the Router routes property within {@link Register}
532
+ */
454
533
  export declare type RegisteredRoutes = Register extends {
455
534
  router: Router<infer TRoutes extends Routes>;
456
535
  } ? TRoutes : Route<string, Path<'', {}>, Query<'', {}>, false>[];
457
536
 
537
+ /**
538
+ * Represents the union of all possible RouteKeys registered within {@link Register}
539
+ */
458
540
  export declare type RegisteredRoutesKey = RoutesKey<RegisteredRoutes>;
459
541
 
460
- export declare type ReplaceAll<Input extends string, Search extends string, Replacement extends string> = Input extends `${infer Head}${Search}${infer Tail}` ? `${Head}${Replacement}${ReplaceAll<Tail, Search, Replacement>}` : Input;
461
-
462
- export declare function replaceParamSyntaxWithCatchAlls(value: string): string;
463
-
464
- export declare type ResolvedRoute<TRoute extends Route = Route> = {
542
+ declare type ResolvedRoute<TRoute extends Route = BaseResolvedRoute> = DeepReadonly<{
465
543
  matched: TRoute['matched'];
466
544
  matches: RouteProps[];
467
545
  key: TRoute['key'];
468
546
  query: ResolvedRouteQuery;
469
547
  params: ExtractRouteParamTypes<TRoute>;
470
- };
548
+ }>;
471
549
 
472
- export declare type ResolvedRouteQuery = {
550
+ declare type ResolvedRouteQuery = {
473
551
  get: (key: string) => string | null;
474
552
  getAll: (key: string) => string[];
475
553
  };
476
554
 
477
- declare type ResolvedRouteUpdate = (route: ResolvedRoute) => void;
478
-
555
+ /**
556
+ * Represents the structure of a route within the application.
557
+ * @template TKey - Represents the unique key identifying the route, typically a string.
558
+ * @template TPath - The type or structure of the route's path.
559
+ * @template TQuery - The type or structure of the query parameters associated with the route.
560
+ * @template TDisabled - Indicates whether the route is disabled, which could affect routing logic.
561
+ */
479
562
  export declare type Route<TKey extends string | undefined = any, TPath extends string | Path = Path, TQuery extends string | Query | undefined = Query, TDisabled extends boolean | undefined = boolean> = {
480
- matched: RouteProps;
481
- matches: RouteProps[];
563
+ /**
564
+ * The specific route properties that were matched in the current route.
565
+ */
566
+ matched: RoutePropsWithMeta;
567
+ /**
568
+ * The specific route properties that were matched in the current route, including any ancestors.
569
+ * Order of routes will be from greatest ancestor to narrowest matched.
570
+ */
571
+ matches: RoutePropsWithMeta[];
572
+ /**
573
+ * Unique identifier for the route, generated by joining route `name` by period. Key is used for routing and for matching.
574
+ */
482
575
  key: TKey;
576
+ /**
577
+ * Represents the structured path of the route, including path params.
578
+ */
483
579
  path: ToPath<TPath>;
580
+ /**
581
+ * Represents the structured query of the route, including query params.
582
+ */
484
583
  query: ToQuery<TQuery>;
485
- pathParams: ToPath<TPath>['params'];
486
- queryParams: ToQuery<TQuery>['params'];
487
584
  depth: number;
585
+ /**
586
+ * Indicates if the route is disabled.
587
+ */
488
588
  disabled: TDisabled extends boolean ? TDisabled : false;
489
589
  };
490
590
 
491
- export declare type RouteComponent = Component | DefineComponent | AsyncComponentLoader;
591
+ /**
592
+ * Type alias for Vue components, which can be either synchronous or asynchronous components.
593
+ */
594
+ declare type RouteComponent = Component | DefineComponent | AsyncComponentLoader;
492
595
 
493
- export declare type RouteGetByKey<TRoutes extends Routes, TKey extends RoutesKey<TRoutes>> = RoutesMap<TRoutes>[TKey];
596
+ declare type RouteGetByKey<TRoutes extends Routes, TKey extends RoutesKey<TRoutes>> = RoutesMap<TRoutes>[TKey];
494
597
 
598
+ /**
599
+ * Generic type representing a route hook, which can be either before or after a route change.
600
+ */
495
601
  export declare type RouteHook = BeforeRouteHook | AfterRouteHook;
496
602
 
603
+ /**
604
+ * A function that can be called to abort a routing operation.
605
+ */
497
606
  export declare type RouteHookAbort = () => void;
498
607
 
608
+ /**
609
+ * Defines the structure of an aborted route hook response.
610
+ */
499
611
  declare type RouteHookAbortResponse = {
500
612
  status: 'ABORT';
501
613
  };
502
614
 
503
- declare type RouteHookAfterRunner<T extends Routes> = (context: AfterContext) => Promise<AfterRouteHookResponse<T>>;
504
-
505
- declare type RouteHookBeforeRunner<T extends Routes> = (context: BeforeContext) => Promise<BeforeRouteHookResponse<T>>;
506
-
507
- export declare type RouteHookCondition = (to: ResolvedRoute, from: ResolvedRoute | null, depth: number) => boolean;
508
-
615
+ /**
616
+ * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
617
+ */
509
618
  declare type RouteHookContext = {
510
619
  from: ResolvedRoute | null;
511
620
  reject: RouterReject;
@@ -513,116 +622,153 @@ declare type RouteHookContext = {
513
622
  replace: RegisteredRouterReplace;
514
623
  };
515
624
 
625
+ /**
626
+ * Union type for all route hook lifecycle events.
627
+ */
516
628
  export declare type RouteHookLifecycle = BeforeRouteHookLifecycle | AfterRouteHookLifecycle;
517
629
 
630
+ /**
631
+ * Defines the structure of a route hook response that results in a push to a new route.
632
+ * @template T - The type of the routes configuration.
633
+ */
518
634
  declare type RouteHookPushResponse<T extends Routes> = {
519
635
  status: 'PUSH';
520
636
  to: Parameters<RouterPush<T>>;
521
637
  };
522
638
 
639
+ /**
640
+ * Defines the structure of a route hook response that results in the rejection of a route transition.
641
+ */
523
642
  declare type RouteHookRejectResponse = {
524
643
  status: 'REJECT';
525
644
  type: RouterRejectionType;
526
645
  };
527
646
 
647
+ /**
648
+ * A function to remove a previously registered route hook.
649
+ */
528
650
  export declare type RouteHookRemove = () => void;
529
651
 
530
- export declare type RouteHookResponse<T extends Routes> = BeforeRouteHookResponse<T> | AfterRouteHookResponse<T>;
531
-
532
- declare type RouteHookRunners<T extends Routes> = {
533
- runBeforeRouteHooks: RouteHookBeforeRunner<T>;
534
- runAfterRouteHooks: RouteHookAfterRunner<T>;
535
- };
536
-
537
- declare class RouteHooks {
538
- onBeforeRouteEnter: Set<BeforeRouteHook>;
539
- onBeforeRouteUpdate: Set<BeforeRouteHook>;
540
- onBeforeRouteLeave: Set<BeforeRouteHook>;
541
- onAfterRouteEnter: Set<AfterRouteHook>;
542
- onAfterRouteUpdate: Set<AfterRouteHook>;
543
- onAfterRouteLeave: Set<AfterRouteHook>;
544
- }
545
-
546
- declare class RouteHookStore {
547
- global: RouteHooks;
548
- component: RouteHooks;
549
- addBeforeRouteHook({ lifecycle, timing, depth, hook }: BeforeRouteHookRegistration): RouteHookRemove;
550
- addAfterRouteHook({ lifecycle, timing, depth, hook }: AfterRouteHookRegistration): RouteHookRemove;
551
- }
552
-
553
- export declare const routeHookStoreKey: InjectionKey<RouteHookStore>;
652
+ /**
653
+ * Union type for all possible route hook responses, covering both before and after scenarios.
654
+ * @template TRoutes - The type of the routes configuration.
655
+ */
656
+ export declare type RouteHookResponse<TRoutes extends Routes> = BeforeRouteHookResponse<TRoutes> | AfterRouteHookResponse<TRoutes>;
554
657
 
658
+ /**
659
+ * Defines the structure of a successful route hook response.
660
+ */
555
661
  declare type RouteHookSuccessResponse = {
556
662
  status: 'SUCCESS';
557
663
  };
558
664
 
559
- declare type RouteHookTiming = 'global' | 'component';
560
-
561
- export declare type RouteMatchRule = (route: Route, url: string) => boolean;
562
-
563
- export declare interface RouteMeta {
665
+ /**
666
+ * Represents additional metadata associated with a route, customizable via extensions.
667
+ * @example
668
+ * ```ts
669
+ * declare module '@kitbag/router' {
670
+ * interface RouteMeta {
671
+ * pageTitle?: string
672
+ * }
673
+ * }
674
+ * ```
675
+ */
676
+ declare interface RouteMeta extends Record<string, unknown> {
564
677
  }
565
678
 
566
- export declare const routeParamsAreValid: RouteMatchRule;
567
-
568
- export declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = ExtractRouteParamTypes<RouteGetByKey<TRoutes, TKey>>;
679
+ declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = ExtractRouteParamTypes<RouteGetByKey<TRoutes, TKey>>;
569
680
 
570
- export declare const routePathMatches: RouteMatchRule;
681
+ /**
682
+ * Unifies the properties of both parent and child routes, ensuring type safety and consistency across route configurations.
683
+ */
684
+ declare type RouteProps = Readonly<ParentRouteProps | ChildRouteProps>;
571
685
 
572
- export declare type RouteProps = Readonly<ParentRouteProps | ChildRouteProps>;
573
-
574
- export declare const routeQueryMatches: RouteMatchRule;
686
+ /**
687
+ * The Route properties originally provided to `createRoutes`. The only change is normalizing meta to always default to an empty object.
688
+ */
689
+ declare type RoutePropsWithMeta = RouteProps & {
690
+ meta: RouteMeta;
691
+ };
575
692
 
576
- export declare type Router<TRoutes extends Routes = []> = {
577
- route: DeepReadonly<ResolvedRoute>;
693
+ export declare type Router<TRoutes extends Routes = any> = Plugin_2 & {
694
+ /**
695
+ * Manages the current route state.
696
+ */
697
+ route: RouterRoute;
698
+ /**
699
+ * Resolves a URL to a route object.
700
+ */
578
701
  resolve: RouterResolve<TRoutes>;
702
+ /**
703
+ * Navigates to a specified path or route object in the history stack, adding a new entry.
704
+ */
579
705
  push: RouterPush<TRoutes>;
706
+ /**
707
+ * Replaces the current entry in the history stack with a new one.
708
+ */
580
709
  replace: RouterReplace<TRoutes>;
710
+ /**
711
+ * Finds a route object based on the provided lookup parameters.
712
+ */
581
713
  find: RouterFind<TRoutes>;
714
+ /**
715
+ * Handles route rejection based on a specified rejection type.
716
+ */
582
717
  reject: RouterReject;
718
+ /**
719
+ * Forces the router to re-evaluate the current route.
720
+ */
583
721
  refresh: () => void;
722
+ /**
723
+ * Navigates to the previous entry in the browser's history stack.
724
+ */
584
725
  back: () => void;
726
+ /**
727
+ * Navigates to the next entry in the browser's history stack.
728
+ */
585
729
  forward: () => void;
730
+ /**
731
+ * Moves the current history entry to a specific point in the history stack.
732
+ */
586
733
  go: (delta: number) => void;
734
+ /**
735
+ * Registers a hook to be called before a route is entered.
736
+ */
587
737
  onBeforeRouteEnter: AddBeforeRouteHook;
738
+ /**
739
+ * Registers a hook to be called before a route is left.
740
+ */
588
741
  onBeforeRouteLeave: AddBeforeRouteHook;
742
+ /**
743
+ * Registers a hook to be called before a route is updated.
744
+ */
589
745
  onBeforeRouteUpdate: AddBeforeRouteHook;
746
+ /**
747
+ * Registers a hook to be called after a route is entered.
748
+ */
590
749
  onAfterRouteEnter: AddAfterRouteHook;
750
+ /**
751
+ * Registers a hook to be called after a route is left.
752
+ */
591
753
  onAfterRouteLeave: AddAfterRouteHook;
754
+ /**
755
+ * Registers a hook to be called after a route is updated.
756
+ */
592
757
  onAfterRouteUpdate: AddAfterRouteHook;
758
+ /**
759
+ * A promise that resolves when the router is fully initialized.
760
+ */
593
761
  initialized: Promise<void>;
594
- } & Plugin_2;
762
+ };
595
763
 
596
- export declare type RouterFind<TRoutes extends Routes> = {
764
+ declare type RouterFind<TRoutes extends Routes> = {
597
765
  <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterFindArgs<TRoutes, TSource>): ResolvedRoute | undefined;
598
766
  (source: Url): ResolvedRoute | undefined;
599
767
  };
600
768
 
601
769
  declare type RouterFindArgs<TRoutes extends Routes, TSource extends string & keyof RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams] : [params: TParams];
602
770
 
603
- export declare type RouterHistory = {
604
- forward: NavigationForward;
605
- back: NavigationBack;
606
- go: NavigationGo;
607
- update: NavigationUpdate;
608
- refresh: NavigationRefresh;
609
- };
610
-
611
- export declare type RouterHistoryMode = 'auto' | 'browser' | 'memory' | 'hash';
612
-
613
- declare type RouterHistoryOptions = {
614
- mode?: RouterHistoryMode;
615
- };
616
-
617
- export declare type RouterHooks = {
618
- onBeforeRouteEnter: AddBeforeRouteHook;
619
- onBeforeRouteUpdate: AddBeforeRouteHook;
620
- onBeforeRouteLeave: AddBeforeRouteHook;
621
- onAfterRouteEnter: AddAfterRouteHook;
622
- onAfterRouteUpdate: AddAfterRouteHook;
623
- onAfterRouteLeave: AddAfterRouteHook;
624
- hooks: RouteHookStore;
625
- };
771
+ declare type RouterHistoryMode = 'auto' | 'browser' | 'memory' | 'hash';
626
772
 
627
773
  export declare const routerInjectionKey: InjectionKey<RegisteredRouter>;
628
774
 
@@ -646,3465 +792,174 @@ to: Url | ToCallback;
646
792
  }) => unknown) | undefined;
647
793
  }>;
648
794
 
795
+ /**
796
+ * An error thrown when an attempt is made to use routing functionality before the router has been installed.
797
+ */
798
+ export declare class RouterNotInstalledError extends Error {
799
+ constructor();
800
+ }
801
+
802
+ /**
803
+ * Options to initialize a {@link Router} instance.
804
+ */
649
805
  export declare type RouterOptions = {
806
+ /**
807
+ * Initial URL for the router to use. Required if using Node environment.
808
+ *
809
+ * @default window.location.toString()
810
+ */
650
811
  initialUrl?: string;
812
+ /**
813
+ * Specifies the history mode for the router, such as 'hash', 'history', or 'abstract'.
814
+ */
651
815
  historyMode?: RouterHistoryMode;
652
816
  } & RouterRejectionComponents;
653
817
 
654
- export declare type RouterPush<TRoutes extends Routes> = {
818
+ declare type RouterPush<TRoutes extends Routes = any> = {
655
819
  <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterPushArgs<TRoutes, TSource>): Promise<void>;
656
820
  (source: Url, options?: RouterPushOptions): Promise<void>;
657
821
  };
658
822
 
659
823
  declare type RouterPushArgs<TRoutes extends Routes, TSource extends string & keyof RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterPushOptions] : [params: TParams, options?: RouterPushOptions];
660
824
 
661
- export declare type RouterPushOptions = {
825
+ declare type RouterPushOptions = {
662
826
  query?: Record<string, string>;
663
827
  replace?: boolean;
664
828
  };
665
829
 
666
830
  export declare type RouterReject = (type: RouterRejectionType) => void;
667
831
 
668
- export declare type RouterRejection = Ref<null | {
832
+ declare type RouterRejection = Ref<null | {
669
833
  type: RouterRejectionType;
670
834
  component: RouteComponent;
671
835
  }>;
672
836
 
673
- export declare type RouterRejectionComponents = RegisteredRejectionType extends never ? {
674
- rejections?: BuiltInRejectionComponents;
675
- } : {
676
- rejections: BuiltInRejectionComponents & Record<RegisteredRejectionType, RouteComponent>;
837
+ declare type RouterRejectionComponents = {
838
+ rejections?: Partial<Record<RouterRejectionType, RouteComponent>>;
677
839
  };
678
840
 
679
841
  export declare const routerRejectionKey: InjectionKey<RouterRejection>;
680
842
 
681
- export declare type RouterRejectionType = BuiltInRejectionType | RegisteredRejectionType;
843
+ declare type RouterRejectionType = BuiltInRejectionType | RegisteredRejectionType;
682
844
 
683
- export declare type RouterReplace<TRoutes extends Routes> = {
845
+ declare type RouterReplace<TRoutes extends Routes> = {
684
846
  <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterReplaceArgs<TRoutes, TSource>): Promise<void>;
685
847
  (source: Url, options?: RouterReplaceOptions): Promise<void>;
686
848
  };
687
849
 
688
850
  declare type RouterReplaceArgs<TRoutes extends Routes, TSource extends string & keyof RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterReplaceOptions] : [params: TParams, options?: RouterReplaceOptions];
689
851
 
690
- export declare type RouterReplaceOptions = Omit<RouterPushOptions, 'replace'>;
852
+ declare type RouterReplaceOptions = Omit<RouterPushOptions, 'replace'>;
691
853
 
692
- export declare type RouterResolve<TRoutes extends Routes> = {
854
+ declare type RouterResolve<TRoutes extends Routes> = {
693
855
  <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterResolveArgs<TRoutes, TSource>): string;
694
856
  (source: Url, options?: RouterResolveOptions): string;
695
857
  };
696
858
 
697
859
  declare type RouterResolveArgs<TRoutes extends Routes, TSource extends string & keyof RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterResolveOptions] : [params: TParams, options?: RouterResolveOptions];
698
860
 
699
- export declare type RouterResolveOptions = {
861
+ declare type RouterResolveOptions = {
700
862
  query?: Record<string, string>;
701
863
  };
702
864
 
703
- export declare type RouterSetReject = (type: RouterRejectionType | null) => void;
865
+ declare type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = Omit<ResolvedRoute, 'params'> & Readonly<{
866
+ params: Writable<TRoute['params']>;
867
+ update: RouteUpdate<TRoute>;
868
+ }>;
704
869
 
705
870
  export declare const RouterView: __VLS_WithTemplateSlots<DefineComponent< {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes< {}>>, {}, {}>, Readonly<{
706
871
  default?: ((props: {
707
- route: {
708
- readonly matched: {
709
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
710
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
711
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
712
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
713
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
714
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
715
- readonly name?: string | undefined;
716
- readonly path: string | {
717
- readonly path: any;
718
- readonly params: {} | {
719
- readonly [x: string]: any;
720
- } | {
721
- readonly [x: string]: any;
722
- };
723
- readonly toString: () => string;
724
- };
725
- readonly query?: string | {
726
- readonly query: any;
727
- readonly params: {} | {
728
- readonly [x: string]: any;
729
- } | {
730
- readonly [x: string]: any;
731
- };
732
- readonly toString: () => string;
733
- } | undefined;
734
- readonly disabled?: boolean | undefined;
735
- readonly children?: readonly {
736
- readonly matched: any | {
737
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
738
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
739
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
740
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
741
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
742
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
743
- readonly name: string;
744
- readonly disabled?: boolean | undefined;
745
- readonly path: string | {
746
- readonly path: any;
747
- readonly params: {} | {
748
- readonly [x: string]: any;
749
- } | {
750
- readonly [x: string]: any;
751
- };
752
- readonly toString: () => string;
753
- };
754
- readonly query?: string | {
755
- readonly query: any;
756
- readonly params: {} | {
757
- readonly [x: string]: any;
758
- } | {
759
- readonly [x: string]: any;
760
- };
761
- readonly toString: () => string;
762
- } | undefined;
763
- readonly component: FunctionalComponent<any, {}, any, {}> | {
764
- new (...args: any[]): any;
765
- __isFragment?: undefined;
766
- __isTeleport?: undefined;
767
- __isSuspense?: undefined;
768
- } | DefineComponent | AsyncComponentLoader | {
769
- readonly [x: string]: any;
770
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
771
- attrs: {
772
- [x: string]: unknown;
773
- };
774
- slots: Readonly<{
775
- [name: string]: Slot<any> | undefined;
776
- }>;
777
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
778
- expose: (exposed?: Record<string, any> | undefined) => void;
779
- }) => any) | undefined;
780
- readonly name?: string | undefined;
781
- readonly template?: string | object | undefined;
782
- readonly render?: Function | undefined;
783
- readonly components?: {
784
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
785
- new (...args: any[]): any;
786
- __isFragment?: undefined;
787
- __isTeleport?: undefined;
788
- __isSuspense?: undefined;
789
- } | any;
790
- } | undefined;
791
- readonly directives?: {
792
- readonly [x: string]: FunctionDirective<any, any> | {
793
- readonly created?: DirectiveHook<any, null, any> | undefined;
794
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
795
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
796
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
797
- [key: string]: any;
798
- }>, any> | undefined;
799
- readonly updated?: DirectiveHook<any, VNode<any, any, {
800
- [key: string]: any;
801
- }>, any> | undefined;
802
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
803
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
804
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
805
- [key: string]: any;
806
- }>) => {
807
- [x: string]: unknown;
808
- } | undefined) | undefined;
809
- readonly deep?: boolean | undefined;
810
- };
811
- } | undefined;
812
- readonly inheritAttrs?: boolean | undefined;
813
- readonly emits?: any;
814
- readonly slots?: {} | undefined;
815
- readonly expose?: readonly string[] | undefined;
816
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
817
- readonly compilerOptions?: {
818
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
819
- readonly whitespace?: "preserve" | "condense" | undefined;
820
- readonly comments?: boolean | undefined;
821
- readonly delimiters?: readonly [string, string] | undefined;
822
- } | undefined;
823
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
824
- readonly __isFragment?: undefined;
825
- readonly __isTeleport?: undefined;
826
- readonly __isSuspense?: undefined;
827
- readonly __defaults?: any;
828
- readonly compatConfig?: {
829
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
830
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
831
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
832
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
833
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
834
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
835
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
836
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
837
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
838
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
839
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
840
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
841
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
842
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
843
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
844
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
845
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
846
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
847
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
848
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
849
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
850
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
851
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
852
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
853
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
854
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
855
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
856
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
857
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
858
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
859
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
860
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
861
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
862
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
863
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
864
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
865
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
866
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
867
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
868
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
869
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
870
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
871
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
872
- } | undefined;
873
- readonly data?: ((this: any, vm: any) => any) | undefined;
874
- readonly computed?: {
875
- readonly [x: string]: ComputedGetter<any> | {
876
- readonly get: ComputedGetter<any>;
877
- readonly set: ComputedSetter<any>;
878
- };
879
- } | undefined;
880
- readonly methods?: {
881
- readonly [x: string]: Function;
882
- } | undefined;
883
- readonly watch?: {
884
- readonly [x: string]: string | WatchCallback<any, any> | {
885
- readonly handler: string | WatchCallback<any, any>;
886
- readonly immediate?: boolean | undefined;
887
- readonly deep?: boolean | undefined;
888
- readonly once?: boolean | undefined;
889
- readonly flush?: "pre" | "post" | "sync" | undefined;
890
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
891
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
892
- } | readonly (string | WatchCallback<any, any> | {
893
- readonly handler: string | WatchCallback<any, any>;
894
- readonly immediate?: boolean | undefined;
895
- readonly deep?: boolean | undefined;
896
- readonly once?: boolean | undefined;
897
- readonly flush?: "pre" | "post" | "sync" | undefined;
898
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
899
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
900
- })[];
901
- } | undefined;
902
- readonly provide?: Function | {
903
- readonly [x: string]: Readonly<unknown>;
904
- readonly [x: symbol]: Readonly<unknown>;
905
- } | undefined;
906
- readonly inject?: readonly string[] | {} | undefined;
907
- readonly filters?: {
908
- readonly [x: string]: Function;
909
- } | undefined;
910
- readonly mixins?: readonly any[] | undefined;
911
- readonly extends?: any;
912
- readonly beforeCreate?: (() => void) | undefined;
913
- readonly created?: (() => void) | undefined;
914
- readonly beforeMount?: (() => void) | undefined;
915
- readonly mounted?: (() => void) | undefined;
916
- readonly beforeUpdate?: (() => void) | undefined;
917
- readonly updated?: (() => void) | undefined;
918
- readonly activated?: (() => void) | undefined;
919
- readonly deactivated?: (() => void) | undefined;
920
- readonly beforeDestroy?: (() => void) | undefined;
921
- readonly beforeUnmount?: (() => void) | undefined;
922
- readonly destroyed?: (() => void) | undefined;
923
- readonly unmounted?: (() => void) | undefined;
924
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
925
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
926
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
927
- readonly delimiters?: readonly [string, string] | undefined;
928
- readonly __differentiator?: string | number | symbol | undefined;
929
- readonly __isBuiltIn?: boolean | undefined;
930
- readonly __file?: string | undefined;
931
- readonly __name?: string | undefined;
932
- };
933
- readonly meta?: {} | undefined;
934
- };
935
- readonly matches: readonly (any | {
936
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
937
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
938
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
939
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
940
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
941
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
942
- readonly name: string;
943
- readonly disabled?: boolean | undefined;
944
- readonly path: string | {
945
- readonly path: any;
946
- readonly params: {} | {
947
- readonly [x: string]: any;
948
- } | {
949
- readonly [x: string]: any;
950
- };
951
- readonly toString: () => string;
952
- };
953
- readonly query?: string | {
954
- readonly query: any;
955
- readonly params: {} | {
956
- readonly [x: string]: any;
957
- } | {
958
- readonly [x: string]: any;
959
- };
960
- readonly toString: () => string;
961
- } | undefined;
962
- readonly component: FunctionalComponent<any, {}, any, {}> | {
963
- new (...args: any[]): any;
964
- __isFragment?: undefined;
965
- __isTeleport?: undefined;
966
- __isSuspense?: undefined;
967
- } | DefineComponent | AsyncComponentLoader | {
968
- readonly [x: string]: any;
969
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
970
- attrs: {
971
- [x: string]: unknown;
972
- };
973
- slots: Readonly<{
974
- [name: string]: Slot<any> | undefined;
975
- }>;
976
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
977
- expose: (exposed?: Record<string, any> | undefined) => void;
978
- }) => any) | undefined;
979
- readonly name?: string | undefined;
980
- readonly template?: string | object | undefined;
981
- readonly render?: Function | undefined;
982
- readonly components?: {
983
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
984
- new (...args: any[]): any;
985
- __isFragment?: undefined;
986
- __isTeleport?: undefined;
987
- __isSuspense?: undefined;
988
- } | any;
989
- } | undefined;
990
- readonly directives?: {
991
- readonly [x: string]: FunctionDirective<any, any> | {
992
- readonly created?: DirectiveHook<any, null, any> | undefined;
993
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
994
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
995
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
996
- [key: string]: any;
997
- }>, any> | undefined;
998
- readonly updated?: DirectiveHook<any, VNode<any, any, {
999
- [key: string]: any;
1000
- }>, any> | undefined;
1001
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
1002
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
1003
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
1004
- [key: string]: any;
1005
- }>) => {
1006
- [x: string]: unknown;
1007
- } | undefined) | undefined;
1008
- readonly deep?: boolean | undefined;
1009
- };
1010
- } | undefined;
1011
- readonly inheritAttrs?: boolean | undefined;
1012
- readonly emits?: any;
1013
- readonly slots?: {} | undefined;
1014
- readonly expose?: readonly string[] | undefined;
1015
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
1016
- readonly compilerOptions?: {
1017
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
1018
- readonly whitespace?: "preserve" | "condense" | undefined;
1019
- readonly comments?: boolean | undefined;
1020
- readonly delimiters?: readonly [string, string] | undefined;
1021
- } | undefined;
1022
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
1023
- readonly __isFragment?: undefined;
1024
- readonly __isTeleport?: undefined;
1025
- readonly __isSuspense?: undefined;
1026
- readonly __defaults?: any;
1027
- readonly compatConfig?: {
1028
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
1029
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
1030
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
1031
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
1032
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
1033
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
1034
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
1035
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
1036
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
1037
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
1038
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
1039
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
1040
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
1041
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
1042
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
1043
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
1044
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
1045
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
1046
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
1047
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
1048
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
1049
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
1050
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
1051
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
1052
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
1053
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
1054
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
1055
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
1056
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
1057
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
1058
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
1059
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
1060
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
1061
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
1062
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
1063
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
1064
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
1065
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
1066
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
1067
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
1068
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
1069
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
1070
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
1071
- } | undefined;
1072
- readonly data?: ((this: any, vm: any) => any) | undefined;
1073
- readonly computed?: {
1074
- readonly [x: string]: ComputedGetter<any> | {
1075
- readonly get: ComputedGetter<any>;
1076
- readonly set: ComputedSetter<any>;
1077
- };
1078
- } | undefined;
1079
- readonly methods?: {
1080
- readonly [x: string]: Function;
1081
- } | undefined;
1082
- readonly watch?: {
1083
- readonly [x: string]: string | WatchCallback<any, any> | {
1084
- readonly handler: string | WatchCallback<any, any>;
1085
- readonly immediate?: boolean | undefined;
1086
- readonly deep?: boolean | undefined;
1087
- readonly once?: boolean | undefined;
1088
- readonly flush?: "pre" | "post" | "sync" | undefined;
1089
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
1090
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
1091
- } | readonly (string | WatchCallback<any, any> | {
1092
- readonly handler: string | WatchCallback<any, any>;
1093
- readonly immediate?: boolean | undefined;
1094
- readonly deep?: boolean | undefined;
1095
- readonly once?: boolean | undefined;
1096
- readonly flush?: "pre" | "post" | "sync" | undefined;
1097
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
1098
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
1099
- })[];
1100
- } | undefined;
1101
- readonly provide?: Function | {
1102
- readonly [x: string]: Readonly<unknown>;
1103
- readonly [x: symbol]: Readonly<unknown>;
1104
- } | undefined;
1105
- readonly inject?: readonly string[] | {} | undefined;
1106
- readonly filters?: {
1107
- readonly [x: string]: Function;
1108
- } | undefined;
1109
- readonly mixins?: readonly any[] | undefined;
1110
- readonly extends?: any;
1111
- readonly beforeCreate?: (() => void) | undefined;
1112
- readonly created?: (() => void) | undefined;
1113
- readonly beforeMount?: (() => void) | undefined;
1114
- readonly mounted?: (() => void) | undefined;
1115
- readonly beforeUpdate?: (() => void) | undefined;
1116
- readonly updated?: (() => void) | undefined;
1117
- readonly activated?: (() => void) | undefined;
1118
- readonly deactivated?: (() => void) | undefined;
1119
- readonly beforeDestroy?: (() => void) | undefined;
1120
- readonly beforeUnmount?: (() => void) | undefined;
1121
- readonly destroyed?: (() => void) | undefined;
1122
- readonly unmounted?: (() => void) | undefined;
1123
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
1124
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
1125
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
1126
- readonly delimiters?: readonly [string, string] | undefined;
1127
- readonly __differentiator?: string | number | symbol | undefined;
1128
- readonly __isBuiltIn?: boolean | undefined;
1129
- readonly __file?: string | undefined;
1130
- readonly __name?: string | undefined;
1131
- };
1132
- readonly meta?: {} | undefined;
1133
- })[];
1134
- readonly key: any;
1135
- readonly path: {
1136
- readonly path: any;
1137
- readonly params: {} | {
1138
- readonly [x: string]: any;
1139
- } | {
1140
- readonly [x: string]: any;
1141
- };
1142
- readonly toString: () => string;
1143
- };
1144
- readonly query: {
1145
- readonly query: any;
1146
- readonly params: {} | {
1147
- readonly [x: string]: any;
1148
- } | {
1149
- readonly [x: string]: any;
1150
- };
1151
- readonly toString: () => string;
1152
- };
1153
- readonly pathParams: {} | {
1154
- readonly [x: string]: any;
1155
- } | {
1156
- readonly [x: string]: any;
1157
- };
1158
- readonly queryParams: {} | {
1159
- readonly [x: string]: any;
1160
- } | {
1161
- readonly [x: string]: any;
1162
- };
1163
- readonly depth: number;
1164
- readonly disabled: boolean;
1165
- }[] | undefined;
1166
- readonly component?: FunctionalComponent<any, {}, any, {}> | {
1167
- new (...args: any[]): any;
1168
- __isFragment?: undefined;
1169
- __isTeleport?: undefined;
1170
- __isSuspense?: undefined;
1171
- } | DefineComponent | AsyncComponentLoader | {
1172
- readonly [x: string]: any;
1173
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
1174
- attrs: {
1175
- [x: string]: unknown;
1176
- };
1177
- slots: Readonly<{
1178
- [name: string]: Slot<any> | undefined;
1179
- }>;
1180
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
1181
- expose: (exposed?: Record<string, any> | undefined) => void;
1182
- }) => any) | undefined;
1183
- readonly name?: string | undefined;
1184
- readonly template?: string | object | undefined;
1185
- readonly render?: Function | undefined;
1186
- readonly components?: {
1187
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
1188
- new (...args: any[]): any;
1189
- __isFragment?: undefined;
1190
- __isTeleport?: undefined;
1191
- __isSuspense?: undefined;
1192
- } | any;
1193
- } | undefined;
1194
- readonly directives?: {
1195
- readonly [x: string]: FunctionDirective<any, any> | {
1196
- readonly created?: DirectiveHook<any, null, any> | undefined;
1197
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
1198
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
1199
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
1200
- [key: string]: any;
1201
- }>, any> | undefined;
1202
- readonly updated?: DirectiveHook<any, VNode<any, any, {
1203
- [key: string]: any;
1204
- }>, any> | undefined;
1205
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
1206
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
1207
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
1208
- [key: string]: any;
1209
- }>) => {
1210
- [x: string]: unknown;
1211
- } | undefined) | undefined;
1212
- readonly deep?: boolean | undefined;
1213
- };
1214
- } | undefined;
1215
- readonly inheritAttrs?: boolean | undefined;
1216
- readonly emits?: any;
1217
- readonly slots?: {} | undefined;
1218
- readonly expose?: readonly string[] | undefined;
1219
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
1220
- readonly compilerOptions?: {
1221
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
1222
- readonly whitespace?: "preserve" | "condense" | undefined;
1223
- readonly comments?: boolean | undefined;
1224
- readonly delimiters?: readonly [string, string] | undefined;
1225
- } | undefined;
1226
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
1227
- readonly __isFragment?: undefined;
1228
- readonly __isTeleport?: undefined;
1229
- readonly __isSuspense?: undefined;
1230
- readonly __defaults?: any;
1231
- readonly compatConfig?: {
1232
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
1233
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
1234
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
1235
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
1236
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
1237
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
1238
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
1239
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
1240
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
1241
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
1242
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
1243
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
1244
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
1245
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
1246
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
1247
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
1248
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
1249
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
1250
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
1251
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
1252
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
1253
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
1254
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
1255
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
1256
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
1257
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
1258
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
1259
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
1260
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
1261
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
1262
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
1263
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
1264
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
1265
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
1266
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
1267
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
1268
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
1269
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
1270
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
1271
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
1272
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
1273
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
1274
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
1275
- } | undefined;
1276
- readonly data?: ((this: any, vm: any) => any) | undefined;
1277
- readonly computed?: {
1278
- readonly [x: string]: ComputedGetter<any> | {
1279
- readonly get: ComputedGetter<any>;
1280
- readonly set: ComputedSetter<any>;
1281
- };
1282
- } | undefined;
1283
- readonly methods?: {
1284
- readonly [x: string]: Function;
1285
- } | undefined;
1286
- readonly watch?: {
1287
- readonly [x: string]: string | WatchCallback<any, any> | {
1288
- readonly handler: string | WatchCallback<any, any>;
1289
- readonly immediate?: boolean | undefined;
1290
- readonly deep?: boolean | undefined;
1291
- readonly once?: boolean | undefined;
1292
- readonly flush?: "pre" | "post" | "sync" | undefined;
1293
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
1294
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
1295
- } | readonly (string | WatchCallback<any, any> | {
1296
- readonly handler: string | WatchCallback<any, any>;
1297
- readonly immediate?: boolean | undefined;
1298
- readonly deep?: boolean | undefined;
1299
- readonly once?: boolean | undefined;
1300
- readonly flush?: "pre" | "post" | "sync" | undefined;
1301
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
1302
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
1303
- })[];
1304
- } | undefined;
1305
- readonly provide?: Function | {
1306
- readonly [x: string]: Readonly<unknown>;
1307
- readonly [x: symbol]: Readonly<unknown>;
1308
- } | undefined;
1309
- readonly inject?: readonly string[] | {} | undefined;
1310
- readonly filters?: {
1311
- readonly [x: string]: Function;
1312
- } | undefined;
1313
- readonly mixins?: readonly any[] | undefined;
1314
- readonly extends?: any;
1315
- readonly beforeCreate?: (() => void) | undefined;
1316
- readonly created?: (() => void) | undefined;
1317
- readonly beforeMount?: (() => void) | undefined;
1318
- readonly mounted?: (() => void) | undefined;
1319
- readonly beforeUpdate?: (() => void) | undefined;
1320
- readonly updated?: (() => void) | undefined;
1321
- readonly activated?: (() => void) | undefined;
1322
- readonly deactivated?: (() => void) | undefined;
1323
- readonly beforeDestroy?: (() => void) | undefined;
1324
- readonly beforeUnmount?: (() => void) | undefined;
1325
- readonly destroyed?: (() => void) | undefined;
1326
- readonly unmounted?: (() => void) | undefined;
1327
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
1328
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
1329
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
1330
- readonly delimiters?: readonly [string, string] | undefined;
1331
- readonly __differentiator?: string | number | symbol | undefined;
1332
- readonly __isBuiltIn?: boolean | undefined;
1333
- readonly __file?: string | undefined;
1334
- readonly __name?: string | undefined;
1335
- } | undefined;
1336
- readonly meta?: {} | undefined;
1337
- } | {
1338
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
1339
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
1340
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
1341
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
1342
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
1343
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
1344
- readonly name: string;
1345
- readonly disabled?: boolean | undefined;
1346
- readonly path: string | {
1347
- readonly path: any;
1348
- readonly params: {} | {
1349
- readonly [x: string]: any;
1350
- } | {
1351
- readonly [x: string]: any;
1352
- };
1353
- readonly toString: () => string;
1354
- };
1355
- readonly query?: string | {
1356
- readonly query: any;
1357
- readonly params: {} | {
1358
- readonly [x: string]: any;
1359
- } | {
1360
- readonly [x: string]: any;
1361
- };
1362
- readonly toString: () => string;
1363
- } | undefined;
1364
- readonly component: FunctionalComponent<any, {}, any, {}> | {
1365
- new (...args: any[]): any;
1366
- __isFragment?: undefined;
1367
- __isTeleport?: undefined;
1368
- __isSuspense?: undefined;
1369
- } | DefineComponent | AsyncComponentLoader | {
1370
- readonly [x: string]: any;
1371
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
1372
- attrs: {
1373
- [x: string]: unknown;
1374
- };
1375
- slots: Readonly<{
1376
- [name: string]: Slot<any> | undefined;
1377
- }>;
1378
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
1379
- expose: (exposed?: Record<string, any> | undefined) => void;
1380
- }) => any) | undefined;
1381
- readonly name?: string | undefined;
1382
- readonly template?: string | object | undefined;
1383
- readonly render?: Function | undefined;
1384
- readonly components?: {
1385
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
1386
- new (...args: any[]): any;
1387
- __isFragment?: undefined;
1388
- __isTeleport?: undefined;
1389
- __isSuspense?: undefined;
1390
- } | any;
1391
- } | undefined;
1392
- readonly directives?: {
1393
- readonly [x: string]: FunctionDirective<any, any> | {
1394
- readonly created?: DirectiveHook<any, null, any> | undefined;
1395
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
1396
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
1397
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
1398
- [key: string]: any;
1399
- }>, any> | undefined;
1400
- readonly updated?: DirectiveHook<any, VNode<any, any, {
1401
- [key: string]: any;
1402
- }>, any> | undefined;
1403
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
1404
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
1405
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
1406
- [key: string]: any;
1407
- }>) => {
1408
- [x: string]: unknown;
1409
- } | undefined) | undefined;
1410
- readonly deep?: boolean | undefined;
1411
- };
1412
- } | undefined;
1413
- readonly inheritAttrs?: boolean | undefined;
1414
- readonly emits?: any;
1415
- readonly slots?: {} | undefined;
1416
- readonly expose?: readonly string[] | undefined;
1417
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
1418
- readonly compilerOptions?: {
1419
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
1420
- readonly whitespace?: "preserve" | "condense" | undefined;
1421
- readonly comments?: boolean | undefined;
1422
- readonly delimiters?: readonly [string, string] | undefined;
1423
- } | undefined;
1424
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
1425
- readonly __isFragment?: undefined;
1426
- readonly __isTeleport?: undefined;
1427
- readonly __isSuspense?: undefined;
1428
- readonly __defaults?: any;
1429
- readonly compatConfig?: {
1430
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
1431
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
1432
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
1433
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
1434
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
1435
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
1436
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
1437
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
1438
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
1439
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
1440
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
1441
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
1442
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
1443
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
1444
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
1445
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
1446
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
1447
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
1448
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
1449
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
1450
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
1451
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
1452
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
1453
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
1454
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
1455
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
1456
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
1457
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
1458
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
1459
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
1460
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
1461
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
1462
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
1463
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
1464
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
1465
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
1466
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
1467
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
1468
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
1469
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
1470
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
1471
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
1472
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
1473
- } | undefined;
1474
- readonly data?: ((this: any, vm: any) => any) | undefined;
1475
- readonly computed?: {
1476
- readonly [x: string]: ComputedGetter<any> | {
1477
- readonly get: ComputedGetter<any>;
1478
- readonly set: ComputedSetter<any>;
1479
- };
1480
- } | undefined;
1481
- readonly methods?: {
1482
- readonly [x: string]: Function;
1483
- } | undefined;
1484
- readonly watch?: {
1485
- readonly [x: string]: string | WatchCallback<any, any> | {
1486
- readonly handler: string | WatchCallback<any, any>;
1487
- readonly immediate?: boolean | undefined;
1488
- readonly deep?: boolean | undefined;
1489
- readonly once?: boolean | undefined;
1490
- readonly flush?: "pre" | "post" | "sync" | undefined;
1491
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
1492
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
1493
- } | readonly (string | WatchCallback<any, any> | {
1494
- readonly handler: string | WatchCallback<any, any>;
1495
- readonly immediate?: boolean | undefined;
1496
- readonly deep?: boolean | undefined;
1497
- readonly once?: boolean | undefined;
1498
- readonly flush?: "pre" | "post" | "sync" | undefined;
1499
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
1500
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
1501
- })[];
1502
- } | undefined;
1503
- readonly provide?: Function | {
1504
- readonly [x: string]: Readonly<unknown>;
1505
- readonly [x: symbol]: Readonly<unknown>;
1506
- } | undefined;
1507
- readonly inject?: readonly string[] | {} | undefined;
1508
- readonly filters?: {
1509
- readonly [x: string]: Function;
1510
- } | undefined;
1511
- readonly mixins?: readonly any[] | undefined;
1512
- readonly extends?: any;
1513
- readonly beforeCreate?: (() => void) | undefined;
1514
- readonly created?: (() => void) | undefined;
1515
- readonly beforeMount?: (() => void) | undefined;
1516
- readonly mounted?: (() => void) | undefined;
1517
- readonly beforeUpdate?: (() => void) | undefined;
1518
- readonly updated?: (() => void) | undefined;
1519
- readonly activated?: (() => void) | undefined;
1520
- readonly deactivated?: (() => void) | undefined;
1521
- readonly beforeDestroy?: (() => void) | undefined;
1522
- readonly beforeUnmount?: (() => void) | undefined;
1523
- readonly destroyed?: (() => void) | undefined;
1524
- readonly unmounted?: (() => void) | undefined;
1525
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
1526
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
1527
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
1528
- readonly delimiters?: readonly [string, string] | undefined;
1529
- readonly __differentiator?: string | number | symbol | undefined;
1530
- readonly __isBuiltIn?: boolean | undefined;
1531
- readonly __file?: string | undefined;
1532
- readonly __name?: string | undefined;
1533
- };
1534
- readonly meta?: {} | undefined;
1535
- };
1536
- readonly matches: readonly ({
1537
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
1538
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
1539
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
1540
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
1541
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
1542
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
1543
- readonly name?: string | undefined;
1544
- readonly path: string | {
1545
- readonly path: any;
1546
- readonly params: {} | {
1547
- readonly [x: string]: any;
1548
- } | {
1549
- readonly [x: string]: any;
1550
- };
1551
- readonly toString: () => string;
1552
- };
1553
- readonly query?: string | {
1554
- readonly query: any;
1555
- readonly params: {} | {
1556
- readonly [x: string]: any;
1557
- } | {
1558
- readonly [x: string]: any;
1559
- };
1560
- readonly toString: () => string;
1561
- } | undefined;
1562
- readonly disabled?: boolean | undefined;
1563
- readonly children?: readonly {
1564
- readonly matched: any | {
1565
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
1566
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
1567
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
1568
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
1569
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
1570
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
1571
- readonly name: string;
1572
- readonly disabled?: boolean | undefined;
1573
- readonly path: string | {
1574
- readonly path: any;
1575
- readonly params: {} | {
1576
- readonly [x: string]: any;
1577
- } | {
1578
- readonly [x: string]: any;
1579
- };
1580
- readonly toString: () => string;
1581
- };
1582
- readonly query?: string | {
1583
- readonly query: any;
1584
- readonly params: {} | {
1585
- readonly [x: string]: any;
1586
- } | {
1587
- readonly [x: string]: any;
1588
- };
1589
- readonly toString: () => string;
1590
- } | undefined;
1591
- readonly component: FunctionalComponent<any, {}, any, {}> | {
1592
- new (...args: any[]): any;
1593
- __isFragment?: undefined;
1594
- __isTeleport?: undefined;
1595
- __isSuspense?: undefined;
1596
- } | DefineComponent | AsyncComponentLoader | {
1597
- readonly [x: string]: any;
1598
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
1599
- attrs: {
1600
- [x: string]: unknown;
1601
- };
1602
- slots: Readonly<{
1603
- [name: string]: Slot<any> | undefined;
1604
- }>;
1605
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
1606
- expose: (exposed?: Record<string, any> | undefined) => void;
1607
- }) => any) | undefined;
1608
- readonly name?: string | undefined;
1609
- readonly template?: string | object | undefined;
1610
- readonly render?: Function | undefined;
1611
- readonly components?: {
1612
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
1613
- new (...args: any[]): any;
1614
- __isFragment?: undefined;
1615
- __isTeleport?: undefined;
1616
- __isSuspense?: undefined;
1617
- } | any;
1618
- } | undefined;
1619
- readonly directives?: {
1620
- readonly [x: string]: FunctionDirective<any, any> | {
1621
- readonly created?: DirectiveHook<any, null, any> | undefined;
1622
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
1623
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
1624
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
1625
- [key: string]: any;
1626
- }>, any> | undefined;
1627
- readonly updated?: DirectiveHook<any, VNode<any, any, {
1628
- [key: string]: any;
1629
- }>, any> | undefined;
1630
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
1631
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
1632
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
1633
- [key: string]: any;
1634
- }>) => {
1635
- [x: string]: unknown;
1636
- } | undefined) | undefined;
1637
- readonly deep?: boolean | undefined;
1638
- };
1639
- } | undefined;
1640
- readonly inheritAttrs?: boolean | undefined;
1641
- readonly emits?: any;
1642
- readonly slots?: {} | undefined;
1643
- readonly expose?: readonly string[] | undefined;
1644
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
1645
- readonly compilerOptions?: {
1646
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
1647
- readonly whitespace?: "preserve" | "condense" | undefined;
1648
- readonly comments?: boolean | undefined;
1649
- readonly delimiters?: readonly [string, string] | undefined;
1650
- } | undefined;
1651
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
1652
- readonly __isFragment?: undefined;
1653
- readonly __isTeleport?: undefined;
1654
- readonly __isSuspense?: undefined;
1655
- readonly __defaults?: any;
1656
- readonly compatConfig?: {
1657
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
1658
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
1659
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
1660
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
1661
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
1662
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
1663
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
1664
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
1665
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
1666
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
1667
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
1668
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
1669
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
1670
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
1671
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
1672
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
1673
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
1674
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
1675
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
1676
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
1677
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
1678
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
1679
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
1680
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
1681
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
1682
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
1683
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
1684
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
1685
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
1686
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
1687
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
1688
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
1689
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
1690
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
1691
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
1692
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
1693
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
1694
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
1695
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
1696
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
1697
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
1698
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
1699
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
1700
- } | undefined;
1701
- readonly data?: ((this: any, vm: any) => any) | undefined;
1702
- readonly computed?: {
1703
- readonly [x: string]: ComputedGetter<any> | {
1704
- readonly get: ComputedGetter<any>;
1705
- readonly set: ComputedSetter<any>;
1706
- };
1707
- } | undefined;
1708
- readonly methods?: {
1709
- readonly [x: string]: Function;
1710
- } | undefined;
1711
- readonly watch?: {
1712
- readonly [x: string]: string | WatchCallback<any, any> | {
1713
- readonly handler: string | WatchCallback<any, any>;
1714
- readonly immediate?: boolean | undefined;
1715
- readonly deep?: boolean | undefined;
1716
- readonly once?: boolean | undefined;
1717
- readonly flush?: "pre" | "post" | "sync" | undefined;
1718
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
1719
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
1720
- } | readonly (string | WatchCallback<any, any> | {
1721
- readonly handler: string | WatchCallback<any, any>;
1722
- readonly immediate?: boolean | undefined;
1723
- readonly deep?: boolean | undefined;
1724
- readonly once?: boolean | undefined;
1725
- readonly flush?: "pre" | "post" | "sync" | undefined;
1726
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
1727
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
1728
- })[];
1729
- } | undefined;
1730
- readonly provide?: Function | {
1731
- readonly [x: string]: Readonly<unknown>;
1732
- readonly [x: symbol]: Readonly<unknown>;
1733
- } | undefined;
1734
- readonly inject?: readonly string[] | {} | undefined;
1735
- readonly filters?: {
1736
- readonly [x: string]: Function;
1737
- } | undefined;
1738
- readonly mixins?: readonly any[] | undefined;
1739
- readonly extends?: any;
1740
- readonly beforeCreate?: (() => void) | undefined;
1741
- readonly created?: (() => void) | undefined;
1742
- readonly beforeMount?: (() => void) | undefined;
1743
- readonly mounted?: (() => void) | undefined;
1744
- readonly beforeUpdate?: (() => void) | undefined;
1745
- readonly updated?: (() => void) | undefined;
1746
- readonly activated?: (() => void) | undefined;
1747
- readonly deactivated?: (() => void) | undefined;
1748
- readonly beforeDestroy?: (() => void) | undefined;
1749
- readonly beforeUnmount?: (() => void) | undefined;
1750
- readonly destroyed?: (() => void) | undefined;
1751
- readonly unmounted?: (() => void) | undefined;
1752
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
1753
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
1754
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
1755
- readonly delimiters?: readonly [string, string] | undefined;
1756
- readonly __differentiator?: string | number | symbol | undefined;
1757
- readonly __isBuiltIn?: boolean | undefined;
1758
- readonly __file?: string | undefined;
1759
- readonly __name?: string | undefined;
1760
- };
1761
- readonly meta?: {} | undefined;
1762
- };
1763
- readonly matches: readonly (any | {
1764
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
1765
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
1766
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
1767
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
1768
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
1769
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
1770
- readonly name: string;
1771
- readonly disabled?: boolean | undefined;
1772
- readonly path: string | {
1773
- readonly path: any;
1774
- readonly params: {} | {
1775
- readonly [x: string]: any;
1776
- } | {
1777
- readonly [x: string]: any;
1778
- };
1779
- readonly toString: () => string;
1780
- };
1781
- readonly query?: string | {
1782
- readonly query: any;
1783
- readonly params: {} | {
1784
- readonly [x: string]: any;
1785
- } | {
1786
- readonly [x: string]: any;
1787
- };
1788
- readonly toString: () => string;
1789
- } | undefined;
1790
- readonly component: FunctionalComponent<any, {}, any, {}> | {
1791
- new (...args: any[]): any;
1792
- __isFragment?: undefined;
1793
- __isTeleport?: undefined;
1794
- __isSuspense?: undefined;
1795
- } | DefineComponent | AsyncComponentLoader | {
1796
- readonly [x: string]: any;
1797
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
1798
- attrs: {
1799
- [x: string]: unknown;
1800
- };
1801
- slots: Readonly<{
1802
- [name: string]: Slot<any> | undefined;
1803
- }>;
1804
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
1805
- expose: (exposed?: Record<string, any> | undefined) => void;
1806
- }) => any) | undefined;
1807
- readonly name?: string | undefined;
1808
- readonly template?: string | object | undefined;
1809
- readonly render?: Function | undefined;
1810
- readonly components?: {
1811
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
1812
- new (...args: any[]): any;
1813
- __isFragment?: undefined;
1814
- __isTeleport?: undefined;
1815
- __isSuspense?: undefined;
1816
- } | any;
1817
- } | undefined;
1818
- readonly directives?: {
1819
- readonly [x: string]: FunctionDirective<any, any> | {
1820
- readonly created?: DirectiveHook<any, null, any> | undefined;
1821
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
1822
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
1823
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
1824
- [key: string]: any;
1825
- }>, any> | undefined;
1826
- readonly updated?: DirectiveHook<any, VNode<any, any, {
1827
- [key: string]: any;
1828
- }>, any> | undefined;
1829
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
1830
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
1831
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
1832
- [key: string]: any;
1833
- }>) => {
1834
- [x: string]: unknown;
1835
- } | undefined) | undefined;
1836
- readonly deep?: boolean | undefined;
1837
- };
1838
- } | undefined;
1839
- readonly inheritAttrs?: boolean | undefined;
1840
- readonly emits?: any;
1841
- readonly slots?: {} | undefined;
1842
- readonly expose?: readonly string[] | undefined;
1843
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
1844
- readonly compilerOptions?: {
1845
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
1846
- readonly whitespace?: "preserve" | "condense" | undefined;
1847
- readonly comments?: boolean | undefined;
1848
- readonly delimiters?: readonly [string, string] | undefined;
1849
- } | undefined;
1850
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
1851
- readonly __isFragment?: undefined;
1852
- readonly __isTeleport?: undefined;
1853
- readonly __isSuspense?: undefined;
1854
- readonly __defaults?: any;
1855
- readonly compatConfig?: {
1856
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
1857
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
1858
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
1859
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
1860
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
1861
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
1862
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
1863
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
1864
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
1865
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
1866
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
1867
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
1868
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
1869
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
1870
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
1871
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
1872
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
1873
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
1874
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
1875
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
1876
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
1877
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
1878
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
1879
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
1880
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
1881
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
1882
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
1883
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
1884
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
1885
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
1886
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
1887
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
1888
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
1889
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
1890
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
1891
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
1892
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
1893
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
1894
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
1895
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
1896
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
1897
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
1898
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
1899
- } | undefined;
1900
- readonly data?: ((this: any, vm: any) => any) | undefined;
1901
- readonly computed?: {
1902
- readonly [x: string]: ComputedGetter<any> | {
1903
- readonly get: ComputedGetter<any>;
1904
- readonly set: ComputedSetter<any>;
1905
- };
1906
- } | undefined;
1907
- readonly methods?: {
1908
- readonly [x: string]: Function;
1909
- } | undefined;
1910
- readonly watch?: {
1911
- readonly [x: string]: string | WatchCallback<any, any> | {
1912
- readonly handler: string | WatchCallback<any, any>;
1913
- readonly immediate?: boolean | undefined;
1914
- readonly deep?: boolean | undefined;
1915
- readonly once?: boolean | undefined;
1916
- readonly flush?: "pre" | "post" | "sync" | undefined;
1917
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
1918
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
1919
- } | readonly (string | WatchCallback<any, any> | {
1920
- readonly handler: string | WatchCallback<any, any>;
1921
- readonly immediate?: boolean | undefined;
1922
- readonly deep?: boolean | undefined;
1923
- readonly once?: boolean | undefined;
1924
- readonly flush?: "pre" | "post" | "sync" | undefined;
1925
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
1926
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
1927
- })[];
1928
- } | undefined;
1929
- readonly provide?: Function | {
1930
- readonly [x: string]: Readonly<unknown>;
1931
- readonly [x: symbol]: Readonly<unknown>;
1932
- } | undefined;
1933
- readonly inject?: readonly string[] | {} | undefined;
1934
- readonly filters?: {
1935
- readonly [x: string]: Function;
1936
- } | undefined;
1937
- readonly mixins?: readonly any[] | undefined;
1938
- readonly extends?: any;
1939
- readonly beforeCreate?: (() => void) | undefined;
1940
- readonly created?: (() => void) | undefined;
1941
- readonly beforeMount?: (() => void) | undefined;
1942
- readonly mounted?: (() => void) | undefined;
1943
- readonly beforeUpdate?: (() => void) | undefined;
1944
- readonly updated?: (() => void) | undefined;
1945
- readonly activated?: (() => void) | undefined;
1946
- readonly deactivated?: (() => void) | undefined;
1947
- readonly beforeDestroy?: (() => void) | undefined;
1948
- readonly beforeUnmount?: (() => void) | undefined;
1949
- readonly destroyed?: (() => void) | undefined;
1950
- readonly unmounted?: (() => void) | undefined;
1951
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
1952
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
1953
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
1954
- readonly delimiters?: readonly [string, string] | undefined;
1955
- readonly __differentiator?: string | number | symbol | undefined;
1956
- readonly __isBuiltIn?: boolean | undefined;
1957
- readonly __file?: string | undefined;
1958
- readonly __name?: string | undefined;
1959
- };
1960
- readonly meta?: {} | undefined;
1961
- })[];
1962
- readonly key: any;
1963
- readonly path: {
1964
- readonly path: any;
1965
- readonly params: {} | {
1966
- readonly [x: string]: any;
1967
- } | {
1968
- readonly [x: string]: any;
1969
- };
1970
- readonly toString: () => string;
1971
- };
1972
- readonly query: {
1973
- readonly query: any;
1974
- readonly params: {} | {
1975
- readonly [x: string]: any;
1976
- } | {
1977
- readonly [x: string]: any;
1978
- };
1979
- readonly toString: () => string;
1980
- };
1981
- readonly pathParams: {} | {
1982
- readonly [x: string]: any;
1983
- } | {
1984
- readonly [x: string]: any;
1985
- };
1986
- readonly queryParams: {} | {
1987
- readonly [x: string]: any;
1988
- } | {
1989
- readonly [x: string]: any;
1990
- };
1991
- readonly depth: number;
1992
- readonly disabled: boolean;
1993
- }[] | undefined;
1994
- readonly component?: FunctionalComponent<any, {}, any, {}> | {
1995
- new (...args: any[]): any;
1996
- __isFragment?: undefined;
1997
- __isTeleport?: undefined;
1998
- __isSuspense?: undefined;
1999
- } | DefineComponent | AsyncComponentLoader | {
2000
- readonly [x: string]: any;
2001
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
2002
- attrs: {
2003
- [x: string]: unknown;
2004
- };
2005
- slots: Readonly<{
2006
- [name: string]: Slot<any> | undefined;
2007
- }>;
2008
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
2009
- expose: (exposed?: Record<string, any> | undefined) => void;
2010
- }) => any) | undefined;
2011
- readonly name?: string | undefined;
2012
- readonly template?: string | object | undefined;
2013
- readonly render?: Function | undefined;
2014
- readonly components?: {
2015
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
2016
- new (...args: any[]): any;
2017
- __isFragment?: undefined;
2018
- __isTeleport?: undefined;
2019
- __isSuspense?: undefined;
2020
- } | any;
2021
- } | undefined;
2022
- readonly directives?: {
2023
- readonly [x: string]: FunctionDirective<any, any> | {
2024
- readonly created?: DirectiveHook<any, null, any> | undefined;
2025
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
2026
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
2027
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
2028
- [key: string]: any;
2029
- }>, any> | undefined;
2030
- readonly updated?: DirectiveHook<any, VNode<any, any, {
2031
- [key: string]: any;
2032
- }>, any> | undefined;
2033
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
2034
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
2035
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
2036
- [key: string]: any;
2037
- }>) => {
2038
- [x: string]: unknown;
2039
- } | undefined) | undefined;
2040
- readonly deep?: boolean | undefined;
2041
- };
2042
- } | undefined;
2043
- readonly inheritAttrs?: boolean | undefined;
2044
- readonly emits?: any;
2045
- readonly slots?: {} | undefined;
2046
- readonly expose?: readonly string[] | undefined;
2047
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
2048
- readonly compilerOptions?: {
2049
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
2050
- readonly whitespace?: "preserve" | "condense" | undefined;
2051
- readonly comments?: boolean | undefined;
2052
- readonly delimiters?: readonly [string, string] | undefined;
2053
- } | undefined;
2054
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
2055
- readonly __isFragment?: undefined;
2056
- readonly __isTeleport?: undefined;
2057
- readonly __isSuspense?: undefined;
2058
- readonly __defaults?: any;
2059
- readonly compatConfig?: {
2060
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
2061
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
2062
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
2063
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
2064
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
2065
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
2066
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
2067
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
2068
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
2069
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
2070
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
2071
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
2072
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
2073
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
2074
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
2075
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
2076
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
2077
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
2078
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
2079
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
2080
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
2081
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
2082
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
2083
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
2084
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
2085
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
2086
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
2087
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
2088
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
2089
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
2090
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
2091
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
2092
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
2093
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
2094
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
2095
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
2096
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
2097
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
2098
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
2099
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
2100
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
2101
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
2102
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
2103
- } | undefined;
2104
- readonly data?: ((this: any, vm: any) => any) | undefined;
2105
- readonly computed?: {
2106
- readonly [x: string]: ComputedGetter<any> | {
2107
- readonly get: ComputedGetter<any>;
2108
- readonly set: ComputedSetter<any>;
2109
- };
2110
- } | undefined;
2111
- readonly methods?: {
2112
- readonly [x: string]: Function;
2113
- } | undefined;
2114
- readonly watch?: {
2115
- readonly [x: string]: string | WatchCallback<any, any> | {
2116
- readonly handler: string | WatchCallback<any, any>;
2117
- readonly immediate?: boolean | undefined;
2118
- readonly deep?: boolean | undefined;
2119
- readonly once?: boolean | undefined;
2120
- readonly flush?: "pre" | "post" | "sync" | undefined;
2121
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
2122
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
2123
- } | readonly (string | WatchCallback<any, any> | {
2124
- readonly handler: string | WatchCallback<any, any>;
2125
- readonly immediate?: boolean | undefined;
2126
- readonly deep?: boolean | undefined;
2127
- readonly once?: boolean | undefined;
2128
- readonly flush?: "pre" | "post" | "sync" | undefined;
2129
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
2130
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
2131
- })[];
2132
- } | undefined;
2133
- readonly provide?: Function | {
2134
- readonly [x: string]: Readonly<unknown>;
2135
- readonly [x: symbol]: Readonly<unknown>;
2136
- } | undefined;
2137
- readonly inject?: readonly string[] | {} | undefined;
2138
- readonly filters?: {
2139
- readonly [x: string]: Function;
2140
- } | undefined;
2141
- readonly mixins?: readonly any[] | undefined;
2142
- readonly extends?: any;
2143
- readonly beforeCreate?: (() => void) | undefined;
2144
- readonly created?: (() => void) | undefined;
2145
- readonly beforeMount?: (() => void) | undefined;
2146
- readonly mounted?: (() => void) | undefined;
2147
- readonly beforeUpdate?: (() => void) | undefined;
2148
- readonly updated?: (() => void) | undefined;
2149
- readonly activated?: (() => void) | undefined;
2150
- readonly deactivated?: (() => void) | undefined;
2151
- readonly beforeDestroy?: (() => void) | undefined;
2152
- readonly beforeUnmount?: (() => void) | undefined;
2153
- readonly destroyed?: (() => void) | undefined;
2154
- readonly unmounted?: (() => void) | undefined;
2155
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
2156
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
2157
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
2158
- readonly delimiters?: readonly [string, string] | undefined;
2159
- readonly __differentiator?: string | number | symbol | undefined;
2160
- readonly __isBuiltIn?: boolean | undefined;
2161
- readonly __file?: string | undefined;
2162
- readonly __name?: string | undefined;
2163
- } | undefined;
2164
- readonly meta?: {} | undefined;
2165
- } | {
2166
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
2167
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
2168
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
2169
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
2170
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
2171
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
2172
- readonly name: string;
2173
- readonly disabled?: boolean | undefined;
2174
- readonly path: string | {
2175
- readonly path: any;
2176
- readonly params: {} | {
2177
- readonly [x: string]: any;
2178
- } | {
2179
- readonly [x: string]: any;
2180
- };
2181
- readonly toString: () => string;
2182
- };
2183
- readonly query?: string | {
2184
- readonly query: any;
2185
- readonly params: {} | {
2186
- readonly [x: string]: any;
2187
- } | {
2188
- readonly [x: string]: any;
2189
- };
2190
- readonly toString: () => string;
2191
- } | undefined;
2192
- readonly component: FunctionalComponent<any, {}, any, {}> | {
2193
- new (...args: any[]): any;
2194
- __isFragment?: undefined;
2195
- __isTeleport?: undefined;
2196
- __isSuspense?: undefined;
2197
- } | DefineComponent | AsyncComponentLoader | {
2198
- readonly [x: string]: any;
2199
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
2200
- attrs: {
2201
- [x: string]: unknown;
2202
- };
2203
- slots: Readonly<{
2204
- [name: string]: Slot<any> | undefined;
2205
- }>;
2206
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
2207
- expose: (exposed?: Record<string, any> | undefined) => void;
2208
- }) => any) | undefined;
2209
- readonly name?: string | undefined;
2210
- readonly template?: string | object | undefined;
2211
- readonly render?: Function | undefined;
2212
- readonly components?: {
2213
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
2214
- new (...args: any[]): any;
2215
- __isFragment?: undefined;
2216
- __isTeleport?: undefined;
2217
- __isSuspense?: undefined;
2218
- } | any;
2219
- } | undefined;
2220
- readonly directives?: {
2221
- readonly [x: string]: FunctionDirective<any, any> | {
2222
- readonly created?: DirectiveHook<any, null, any> | undefined;
2223
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
2224
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
2225
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
2226
- [key: string]: any;
2227
- }>, any> | undefined;
2228
- readonly updated?: DirectiveHook<any, VNode<any, any, {
2229
- [key: string]: any;
2230
- }>, any> | undefined;
2231
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
2232
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
2233
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
2234
- [key: string]: any;
2235
- }>) => {
2236
- [x: string]: unknown;
2237
- } | undefined) | undefined;
2238
- readonly deep?: boolean | undefined;
2239
- };
2240
- } | undefined;
2241
- readonly inheritAttrs?: boolean | undefined;
2242
- readonly emits?: any;
2243
- readonly slots?: {} | undefined;
2244
- readonly expose?: readonly string[] | undefined;
2245
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
2246
- readonly compilerOptions?: {
2247
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
2248
- readonly whitespace?: "preserve" | "condense" | undefined;
2249
- readonly comments?: boolean | undefined;
2250
- readonly delimiters?: readonly [string, string] | undefined;
2251
- } | undefined;
2252
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
2253
- readonly __isFragment?: undefined;
2254
- readonly __isTeleport?: undefined;
2255
- readonly __isSuspense?: undefined;
2256
- readonly __defaults?: any;
2257
- readonly compatConfig?: {
2258
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
2259
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
2260
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
2261
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
2262
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
2263
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
2264
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
2265
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
2266
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
2267
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
2268
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
2269
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
2270
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
2271
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
2272
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
2273
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
2274
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
2275
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
2276
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
2277
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
2278
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
2279
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
2280
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
2281
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
2282
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
2283
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
2284
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
2285
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
2286
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
2287
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
2288
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
2289
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
2290
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
2291
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
2292
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
2293
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
2294
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
2295
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
2296
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
2297
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
2298
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
2299
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
2300
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
2301
- } | undefined;
2302
- readonly data?: ((this: any, vm: any) => any) | undefined;
2303
- readonly computed?: {
2304
- readonly [x: string]: ComputedGetter<any> | {
2305
- readonly get: ComputedGetter<any>;
2306
- readonly set: ComputedSetter<any>;
2307
- };
2308
- } | undefined;
2309
- readonly methods?: {
2310
- readonly [x: string]: Function;
2311
- } | undefined;
2312
- readonly watch?: {
2313
- readonly [x: string]: string | WatchCallback<any, any> | {
2314
- readonly handler: string | WatchCallback<any, any>;
2315
- readonly immediate?: boolean | undefined;
2316
- readonly deep?: boolean | undefined;
2317
- readonly once?: boolean | undefined;
2318
- readonly flush?: "pre" | "post" | "sync" | undefined;
2319
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
2320
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
2321
- } | readonly (string | WatchCallback<any, any> | {
2322
- readonly handler: string | WatchCallback<any, any>;
2323
- readonly immediate?: boolean | undefined;
2324
- readonly deep?: boolean | undefined;
2325
- readonly once?: boolean | undefined;
2326
- readonly flush?: "pre" | "post" | "sync" | undefined;
2327
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
2328
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
2329
- })[];
2330
- } | undefined;
2331
- readonly provide?: Function | {
2332
- readonly [x: string]: Readonly<unknown>;
2333
- readonly [x: symbol]: Readonly<unknown>;
2334
- } | undefined;
2335
- readonly inject?: readonly string[] | {} | undefined;
2336
- readonly filters?: {
2337
- readonly [x: string]: Function;
2338
- } | undefined;
2339
- readonly mixins?: readonly any[] | undefined;
2340
- readonly extends?: any;
2341
- readonly beforeCreate?: (() => void) | undefined;
2342
- readonly created?: (() => void) | undefined;
2343
- readonly beforeMount?: (() => void) | undefined;
2344
- readonly mounted?: (() => void) | undefined;
2345
- readonly beforeUpdate?: (() => void) | undefined;
2346
- readonly updated?: (() => void) | undefined;
2347
- readonly activated?: (() => void) | undefined;
2348
- readonly deactivated?: (() => void) | undefined;
2349
- readonly beforeDestroy?: (() => void) | undefined;
2350
- readonly beforeUnmount?: (() => void) | undefined;
2351
- readonly destroyed?: (() => void) | undefined;
2352
- readonly unmounted?: (() => void) | undefined;
2353
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
2354
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
2355
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
2356
- readonly delimiters?: readonly [string, string] | undefined;
2357
- readonly __differentiator?: string | number | symbol | undefined;
2358
- readonly __isBuiltIn?: boolean | undefined;
2359
- readonly __file?: string | undefined;
2360
- readonly __name?: string | undefined;
2361
- };
2362
- readonly meta?: {} | undefined;
2363
- })[];
2364
- readonly key: any;
2365
- readonly query: {
2366
- readonly get: (key: string) => string | null;
2367
- readonly getAll: (key: string) => string[];
2368
- };
2369
- readonly params: {};
2370
- };
872
+ route: RouterRoute;
2371
873
  component: RouteComponent;
2372
874
  }) => unknown) | undefined;
2373
875
  }> & {
2374
876
  default?: ((props: {
2375
- route: {
2376
- readonly matched: {
2377
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
2378
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
2379
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
2380
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
2381
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
2382
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
2383
- readonly name?: string | undefined;
2384
- readonly path: string | {
2385
- readonly path: any;
2386
- readonly params: {} | {
2387
- readonly [x: string]: any;
2388
- } | {
2389
- readonly [x: string]: any;
2390
- };
2391
- readonly toString: () => string;
2392
- };
2393
- readonly query?: string | {
2394
- readonly query: any;
2395
- readonly params: {} | {
2396
- readonly [x: string]: any;
2397
- } | {
2398
- readonly [x: string]: any;
2399
- };
2400
- readonly toString: () => string;
2401
- } | undefined;
2402
- readonly disabled?: boolean | undefined;
2403
- readonly children?: readonly {
2404
- readonly matched: any | {
2405
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
2406
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
2407
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
2408
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
2409
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
2410
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
2411
- readonly name: string;
2412
- readonly disabled?: boolean | undefined;
2413
- readonly path: string | {
2414
- readonly path: any;
2415
- readonly params: {} | {
2416
- readonly [x: string]: any;
2417
- } | {
2418
- readonly [x: string]: any;
2419
- };
2420
- readonly toString: () => string;
2421
- };
2422
- readonly query?: string | {
2423
- readonly query: any;
2424
- readonly params: {} | {
2425
- readonly [x: string]: any;
2426
- } | {
2427
- readonly [x: string]: any;
2428
- };
2429
- readonly toString: () => string;
2430
- } | undefined;
2431
- readonly component: FunctionalComponent<any, {}, any, {}> | {
2432
- new (...args: any[]): any;
2433
- __isFragment?: undefined;
2434
- __isTeleport?: undefined;
2435
- __isSuspense?: undefined;
2436
- } | DefineComponent | AsyncComponentLoader | {
2437
- readonly [x: string]: any;
2438
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
2439
- attrs: {
2440
- [x: string]: unknown;
2441
- };
2442
- slots: Readonly<{
2443
- [name: string]: Slot<any> | undefined;
2444
- }>;
2445
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
2446
- expose: (exposed?: Record<string, any> | undefined) => void;
2447
- }) => any) | undefined;
2448
- readonly name?: string | undefined;
2449
- readonly template?: string | object | undefined;
2450
- readonly render?: Function | undefined;
2451
- readonly components?: {
2452
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
2453
- new (...args: any[]): any;
2454
- __isFragment?: undefined;
2455
- __isTeleport?: undefined;
2456
- __isSuspense?: undefined;
2457
- } | any;
2458
- } | undefined;
2459
- readonly directives?: {
2460
- readonly [x: string]: FunctionDirective<any, any> | {
2461
- readonly created?: DirectiveHook<any, null, any> | undefined;
2462
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
2463
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
2464
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
2465
- [key: string]: any;
2466
- }>, any> | undefined;
2467
- readonly updated?: DirectiveHook<any, VNode<any, any, {
2468
- [key: string]: any;
2469
- }>, any> | undefined;
2470
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
2471
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
2472
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
2473
- [key: string]: any;
2474
- }>) => {
2475
- [x: string]: unknown;
2476
- } | undefined) | undefined;
2477
- readonly deep?: boolean | undefined;
2478
- };
2479
- } | undefined;
2480
- readonly inheritAttrs?: boolean | undefined;
2481
- readonly emits?: any;
2482
- readonly slots?: {} | undefined;
2483
- readonly expose?: readonly string[] | undefined;
2484
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
2485
- readonly compilerOptions?: {
2486
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
2487
- readonly whitespace?: "preserve" | "condense" | undefined;
2488
- readonly comments?: boolean | undefined;
2489
- readonly delimiters?: readonly [string, string] | undefined;
2490
- } | undefined;
2491
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
2492
- readonly __isFragment?: undefined;
2493
- readonly __isTeleport?: undefined;
2494
- readonly __isSuspense?: undefined;
2495
- readonly __defaults?: any;
2496
- readonly compatConfig?: {
2497
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
2498
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
2499
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
2500
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
2501
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
2502
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
2503
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
2504
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
2505
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
2506
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
2507
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
2508
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
2509
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
2510
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
2511
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
2512
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
2513
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
2514
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
2515
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
2516
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
2517
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
2518
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
2519
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
2520
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
2521
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
2522
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
2523
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
2524
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
2525
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
2526
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
2527
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
2528
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
2529
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
2530
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
2531
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
2532
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
2533
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
2534
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
2535
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
2536
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
2537
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
2538
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
2539
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
2540
- } | undefined;
2541
- readonly data?: ((this: any, vm: any) => any) | undefined;
2542
- readonly computed?: {
2543
- readonly [x: string]: ComputedGetter<any> | {
2544
- readonly get: ComputedGetter<any>;
2545
- readonly set: ComputedSetter<any>;
2546
- };
2547
- } | undefined;
2548
- readonly methods?: {
2549
- readonly [x: string]: Function;
2550
- } | undefined;
2551
- readonly watch?: {
2552
- readonly [x: string]: string | WatchCallback<any, any> | {
2553
- readonly handler: string | WatchCallback<any, any>;
2554
- readonly immediate?: boolean | undefined;
2555
- readonly deep?: boolean | undefined;
2556
- readonly once?: boolean | undefined;
2557
- readonly flush?: "pre" | "post" | "sync" | undefined;
2558
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
2559
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
2560
- } | readonly (string | WatchCallback<any, any> | {
2561
- readonly handler: string | WatchCallback<any, any>;
2562
- readonly immediate?: boolean | undefined;
2563
- readonly deep?: boolean | undefined;
2564
- readonly once?: boolean | undefined;
2565
- readonly flush?: "pre" | "post" | "sync" | undefined;
2566
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
2567
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
2568
- })[];
2569
- } | undefined;
2570
- readonly provide?: Function | {
2571
- readonly [x: string]: Readonly<unknown>;
2572
- readonly [x: symbol]: Readonly<unknown>;
2573
- } | undefined;
2574
- readonly inject?: readonly string[] | {} | undefined;
2575
- readonly filters?: {
2576
- readonly [x: string]: Function;
2577
- } | undefined;
2578
- readonly mixins?: readonly any[] | undefined;
2579
- readonly extends?: any;
2580
- readonly beforeCreate?: (() => void) | undefined;
2581
- readonly created?: (() => void) | undefined;
2582
- readonly beforeMount?: (() => void) | undefined;
2583
- readonly mounted?: (() => void) | undefined;
2584
- readonly beforeUpdate?: (() => void) | undefined;
2585
- readonly updated?: (() => void) | undefined;
2586
- readonly activated?: (() => void) | undefined;
2587
- readonly deactivated?: (() => void) | undefined;
2588
- readonly beforeDestroy?: (() => void) | undefined;
2589
- readonly beforeUnmount?: (() => void) | undefined;
2590
- readonly destroyed?: (() => void) | undefined;
2591
- readonly unmounted?: (() => void) | undefined;
2592
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
2593
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
2594
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
2595
- readonly delimiters?: readonly [string, string] | undefined;
2596
- readonly __differentiator?: string | number | symbol | undefined;
2597
- readonly __isBuiltIn?: boolean | undefined;
2598
- readonly __file?: string | undefined;
2599
- readonly __name?: string | undefined;
2600
- };
2601
- readonly meta?: {} | undefined;
2602
- };
2603
- readonly matches: readonly (any | {
2604
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
2605
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
2606
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
2607
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
2608
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
2609
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
2610
- readonly name: string;
2611
- readonly disabled?: boolean | undefined;
2612
- readonly path: string | {
2613
- readonly path: any;
2614
- readonly params: {} | {
2615
- readonly [x: string]: any;
2616
- } | {
2617
- readonly [x: string]: any;
2618
- };
2619
- readonly toString: () => string;
2620
- };
2621
- readonly query?: string | {
2622
- readonly query: any;
2623
- readonly params: {} | {
2624
- readonly [x: string]: any;
2625
- } | {
2626
- readonly [x: string]: any;
2627
- };
2628
- readonly toString: () => string;
2629
- } | undefined;
2630
- readonly component: FunctionalComponent<any, {}, any, {}> | {
2631
- new (...args: any[]): any;
2632
- __isFragment?: undefined;
2633
- __isTeleport?: undefined;
2634
- __isSuspense?: undefined;
2635
- } | DefineComponent | AsyncComponentLoader | {
2636
- readonly [x: string]: any;
2637
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
2638
- attrs: {
2639
- [x: string]: unknown;
2640
- };
2641
- slots: Readonly<{
2642
- [name: string]: Slot<any> | undefined;
2643
- }>;
2644
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
2645
- expose: (exposed?: Record<string, any> | undefined) => void;
2646
- }) => any) | undefined;
2647
- readonly name?: string | undefined;
2648
- readonly template?: string | object | undefined;
2649
- readonly render?: Function | undefined;
2650
- readonly components?: {
2651
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
2652
- new (...args: any[]): any;
2653
- __isFragment?: undefined;
2654
- __isTeleport?: undefined;
2655
- __isSuspense?: undefined;
2656
- } | any;
2657
- } | undefined;
2658
- readonly directives?: {
2659
- readonly [x: string]: FunctionDirective<any, any> | {
2660
- readonly created?: DirectiveHook<any, null, any> | undefined;
2661
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
2662
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
2663
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
2664
- [key: string]: any;
2665
- }>, any> | undefined;
2666
- readonly updated?: DirectiveHook<any, VNode<any, any, {
2667
- [key: string]: any;
2668
- }>, any> | undefined;
2669
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
2670
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
2671
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
2672
- [key: string]: any;
2673
- }>) => {
2674
- [x: string]: unknown;
2675
- } | undefined) | undefined;
2676
- readonly deep?: boolean | undefined;
2677
- };
2678
- } | undefined;
2679
- readonly inheritAttrs?: boolean | undefined;
2680
- readonly emits?: any;
2681
- readonly slots?: {} | undefined;
2682
- readonly expose?: readonly string[] | undefined;
2683
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
2684
- readonly compilerOptions?: {
2685
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
2686
- readonly whitespace?: "preserve" | "condense" | undefined;
2687
- readonly comments?: boolean | undefined;
2688
- readonly delimiters?: readonly [string, string] | undefined;
2689
- } | undefined;
2690
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
2691
- readonly __isFragment?: undefined;
2692
- readonly __isTeleport?: undefined;
2693
- readonly __isSuspense?: undefined;
2694
- readonly __defaults?: any;
2695
- readonly compatConfig?: {
2696
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
2697
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
2698
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
2699
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
2700
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
2701
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
2702
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
2703
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
2704
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
2705
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
2706
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
2707
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
2708
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
2709
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
2710
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
2711
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
2712
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
2713
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
2714
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
2715
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
2716
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
2717
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
2718
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
2719
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
2720
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
2721
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
2722
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
2723
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
2724
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
2725
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
2726
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
2727
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
2728
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
2729
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
2730
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
2731
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
2732
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
2733
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
2734
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
2735
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
2736
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
2737
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
2738
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
2739
- } | undefined;
2740
- readonly data?: ((this: any, vm: any) => any) | undefined;
2741
- readonly computed?: {
2742
- readonly [x: string]: ComputedGetter<any> | {
2743
- readonly get: ComputedGetter<any>;
2744
- readonly set: ComputedSetter<any>;
2745
- };
2746
- } | undefined;
2747
- readonly methods?: {
2748
- readonly [x: string]: Function;
2749
- } | undefined;
2750
- readonly watch?: {
2751
- readonly [x: string]: string | WatchCallback<any, any> | {
2752
- readonly handler: string | WatchCallback<any, any>;
2753
- readonly immediate?: boolean | undefined;
2754
- readonly deep?: boolean | undefined;
2755
- readonly once?: boolean | undefined;
2756
- readonly flush?: "pre" | "post" | "sync" | undefined;
2757
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
2758
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
2759
- } | readonly (string | WatchCallback<any, any> | {
2760
- readonly handler: string | WatchCallback<any, any>;
2761
- readonly immediate?: boolean | undefined;
2762
- readonly deep?: boolean | undefined;
2763
- readonly once?: boolean | undefined;
2764
- readonly flush?: "pre" | "post" | "sync" | undefined;
2765
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
2766
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
2767
- })[];
2768
- } | undefined;
2769
- readonly provide?: Function | {
2770
- readonly [x: string]: Readonly<unknown>;
2771
- readonly [x: symbol]: Readonly<unknown>;
2772
- } | undefined;
2773
- readonly inject?: readonly string[] | {} | undefined;
2774
- readonly filters?: {
2775
- readonly [x: string]: Function;
2776
- } | undefined;
2777
- readonly mixins?: readonly any[] | undefined;
2778
- readonly extends?: any;
2779
- readonly beforeCreate?: (() => void) | undefined;
2780
- readonly created?: (() => void) | undefined;
2781
- readonly beforeMount?: (() => void) | undefined;
2782
- readonly mounted?: (() => void) | undefined;
2783
- readonly beforeUpdate?: (() => void) | undefined;
2784
- readonly updated?: (() => void) | undefined;
2785
- readonly activated?: (() => void) | undefined;
2786
- readonly deactivated?: (() => void) | undefined;
2787
- readonly beforeDestroy?: (() => void) | undefined;
2788
- readonly beforeUnmount?: (() => void) | undefined;
2789
- readonly destroyed?: (() => void) | undefined;
2790
- readonly unmounted?: (() => void) | undefined;
2791
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
2792
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
2793
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
2794
- readonly delimiters?: readonly [string, string] | undefined;
2795
- readonly __differentiator?: string | number | symbol | undefined;
2796
- readonly __isBuiltIn?: boolean | undefined;
2797
- readonly __file?: string | undefined;
2798
- readonly __name?: string | undefined;
2799
- };
2800
- readonly meta?: {} | undefined;
2801
- })[];
2802
- readonly key: any;
2803
- readonly path: {
2804
- readonly path: any;
2805
- readonly params: {} | {
2806
- readonly [x: string]: any;
2807
- } | {
2808
- readonly [x: string]: any;
2809
- };
2810
- readonly toString: () => string;
2811
- };
2812
- readonly query: {
2813
- readonly query: any;
2814
- readonly params: {} | {
2815
- readonly [x: string]: any;
2816
- } | {
2817
- readonly [x: string]: any;
2818
- };
2819
- readonly toString: () => string;
2820
- };
2821
- readonly pathParams: {} | {
2822
- readonly [x: string]: any;
2823
- } | {
2824
- readonly [x: string]: any;
2825
- };
2826
- readonly queryParams: {} | {
2827
- readonly [x: string]: any;
2828
- } | {
2829
- readonly [x: string]: any;
2830
- };
2831
- readonly depth: number;
2832
- readonly disabled: boolean;
2833
- }[] | undefined;
2834
- readonly component?: FunctionalComponent<any, {}, any, {}> | {
2835
- new (...args: any[]): any;
2836
- __isFragment?: undefined;
2837
- __isTeleport?: undefined;
2838
- __isSuspense?: undefined;
2839
- } | DefineComponent | AsyncComponentLoader | {
2840
- readonly [x: string]: any;
2841
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
2842
- attrs: {
2843
- [x: string]: unknown;
2844
- };
2845
- slots: Readonly<{
2846
- [name: string]: Slot<any> | undefined;
2847
- }>;
2848
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
2849
- expose: (exposed?: Record<string, any> | undefined) => void;
2850
- }) => any) | undefined;
2851
- readonly name?: string | undefined;
2852
- readonly template?: string | object | undefined;
2853
- readonly render?: Function | undefined;
2854
- readonly components?: {
2855
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
2856
- new (...args: any[]): any;
2857
- __isFragment?: undefined;
2858
- __isTeleport?: undefined;
2859
- __isSuspense?: undefined;
2860
- } | any;
2861
- } | undefined;
2862
- readonly directives?: {
2863
- readonly [x: string]: FunctionDirective<any, any> | {
2864
- readonly created?: DirectiveHook<any, null, any> | undefined;
2865
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
2866
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
2867
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
2868
- [key: string]: any;
2869
- }>, any> | undefined;
2870
- readonly updated?: DirectiveHook<any, VNode<any, any, {
2871
- [key: string]: any;
2872
- }>, any> | undefined;
2873
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
2874
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
2875
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
2876
- [key: string]: any;
2877
- }>) => {
2878
- [x: string]: unknown;
2879
- } | undefined) | undefined;
2880
- readonly deep?: boolean | undefined;
2881
- };
2882
- } | undefined;
2883
- readonly inheritAttrs?: boolean | undefined;
2884
- readonly emits?: any;
2885
- readonly slots?: {} | undefined;
2886
- readonly expose?: readonly string[] | undefined;
2887
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
2888
- readonly compilerOptions?: {
2889
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
2890
- readonly whitespace?: "preserve" | "condense" | undefined;
2891
- readonly comments?: boolean | undefined;
2892
- readonly delimiters?: readonly [string, string] | undefined;
2893
- } | undefined;
2894
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
2895
- readonly __isFragment?: undefined;
2896
- readonly __isTeleport?: undefined;
2897
- readonly __isSuspense?: undefined;
2898
- readonly __defaults?: any;
2899
- readonly compatConfig?: {
2900
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
2901
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
2902
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
2903
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
2904
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
2905
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
2906
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
2907
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
2908
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
2909
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
2910
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
2911
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
2912
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
2913
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
2914
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
2915
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
2916
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
2917
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
2918
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
2919
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
2920
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
2921
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
2922
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
2923
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
2924
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
2925
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
2926
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
2927
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
2928
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
2929
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
2930
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
2931
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
2932
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
2933
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
2934
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
2935
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
2936
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
2937
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
2938
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
2939
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
2940
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
2941
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
2942
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
2943
- } | undefined;
2944
- readonly data?: ((this: any, vm: any) => any) | undefined;
2945
- readonly computed?: {
2946
- readonly [x: string]: ComputedGetter<any> | {
2947
- readonly get: ComputedGetter<any>;
2948
- readonly set: ComputedSetter<any>;
2949
- };
2950
- } | undefined;
2951
- readonly methods?: {
2952
- readonly [x: string]: Function;
2953
- } | undefined;
2954
- readonly watch?: {
2955
- readonly [x: string]: string | WatchCallback<any, any> | {
2956
- readonly handler: string | WatchCallback<any, any>;
2957
- readonly immediate?: boolean | undefined;
2958
- readonly deep?: boolean | undefined;
2959
- readonly once?: boolean | undefined;
2960
- readonly flush?: "pre" | "post" | "sync" | undefined;
2961
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
2962
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
2963
- } | readonly (string | WatchCallback<any, any> | {
2964
- readonly handler: string | WatchCallback<any, any>;
2965
- readonly immediate?: boolean | undefined;
2966
- readonly deep?: boolean | undefined;
2967
- readonly once?: boolean | undefined;
2968
- readonly flush?: "pre" | "post" | "sync" | undefined;
2969
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
2970
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
2971
- })[];
2972
- } | undefined;
2973
- readonly provide?: Function | {
2974
- readonly [x: string]: Readonly<unknown>;
2975
- readonly [x: symbol]: Readonly<unknown>;
2976
- } | undefined;
2977
- readonly inject?: readonly string[] | {} | undefined;
2978
- readonly filters?: {
2979
- readonly [x: string]: Function;
2980
- } | undefined;
2981
- readonly mixins?: readonly any[] | undefined;
2982
- readonly extends?: any;
2983
- readonly beforeCreate?: (() => void) | undefined;
2984
- readonly created?: (() => void) | undefined;
2985
- readonly beforeMount?: (() => void) | undefined;
2986
- readonly mounted?: (() => void) | undefined;
2987
- readonly beforeUpdate?: (() => void) | undefined;
2988
- readonly updated?: (() => void) | undefined;
2989
- readonly activated?: (() => void) | undefined;
2990
- readonly deactivated?: (() => void) | undefined;
2991
- readonly beforeDestroy?: (() => void) | undefined;
2992
- readonly beforeUnmount?: (() => void) | undefined;
2993
- readonly destroyed?: (() => void) | undefined;
2994
- readonly unmounted?: (() => void) | undefined;
2995
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
2996
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
2997
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
2998
- readonly delimiters?: readonly [string, string] | undefined;
2999
- readonly __differentiator?: string | number | symbol | undefined;
3000
- readonly __isBuiltIn?: boolean | undefined;
3001
- readonly __file?: string | undefined;
3002
- readonly __name?: string | undefined;
3003
- } | undefined;
3004
- readonly meta?: {} | undefined;
3005
- } | {
3006
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3007
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3008
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3009
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3010
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3011
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3012
- readonly name: string;
3013
- readonly disabled?: boolean | undefined;
3014
- readonly path: string | {
3015
- readonly path: any;
3016
- readonly params: {} | {
3017
- readonly [x: string]: any;
3018
- } | {
3019
- readonly [x: string]: any;
3020
- };
3021
- readonly toString: () => string;
3022
- };
3023
- readonly query?: string | {
3024
- readonly query: any;
3025
- readonly params: {} | {
3026
- readonly [x: string]: any;
3027
- } | {
3028
- readonly [x: string]: any;
3029
- };
3030
- readonly toString: () => string;
3031
- } | undefined;
3032
- readonly component: FunctionalComponent<any, {}, any, {}> | {
3033
- new (...args: any[]): any;
3034
- __isFragment?: undefined;
3035
- __isTeleport?: undefined;
3036
- __isSuspense?: undefined;
3037
- } | DefineComponent | AsyncComponentLoader | {
3038
- readonly [x: string]: any;
3039
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
3040
- attrs: {
3041
- [x: string]: unknown;
3042
- };
3043
- slots: Readonly<{
3044
- [name: string]: Slot<any> | undefined;
3045
- }>;
3046
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
3047
- expose: (exposed?: Record<string, any> | undefined) => void;
3048
- }) => any) | undefined;
3049
- readonly name?: string | undefined;
3050
- readonly template?: string | object | undefined;
3051
- readonly render?: Function | undefined;
3052
- readonly components?: {
3053
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
3054
- new (...args: any[]): any;
3055
- __isFragment?: undefined;
3056
- __isTeleport?: undefined;
3057
- __isSuspense?: undefined;
3058
- } | any;
3059
- } | undefined;
3060
- readonly directives?: {
3061
- readonly [x: string]: FunctionDirective<any, any> | {
3062
- readonly created?: DirectiveHook<any, null, any> | undefined;
3063
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
3064
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
3065
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
3066
- [key: string]: any;
3067
- }>, any> | undefined;
3068
- readonly updated?: DirectiveHook<any, VNode<any, any, {
3069
- [key: string]: any;
3070
- }>, any> | undefined;
3071
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
3072
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
3073
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
3074
- [key: string]: any;
3075
- }>) => {
3076
- [x: string]: unknown;
3077
- } | undefined) | undefined;
3078
- readonly deep?: boolean | undefined;
3079
- };
3080
- } | undefined;
3081
- readonly inheritAttrs?: boolean | undefined;
3082
- readonly emits?: any;
3083
- readonly slots?: {} | undefined;
3084
- readonly expose?: readonly string[] | undefined;
3085
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
3086
- readonly compilerOptions?: {
3087
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
3088
- readonly whitespace?: "preserve" | "condense" | undefined;
3089
- readonly comments?: boolean | undefined;
3090
- readonly delimiters?: readonly [string, string] | undefined;
3091
- } | undefined;
3092
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
3093
- readonly __isFragment?: undefined;
3094
- readonly __isTeleport?: undefined;
3095
- readonly __isSuspense?: undefined;
3096
- readonly __defaults?: any;
3097
- readonly compatConfig?: {
3098
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
3099
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
3100
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
3101
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
3102
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
3103
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
3104
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
3105
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
3106
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
3107
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
3108
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
3109
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
3110
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
3111
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
3112
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
3113
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
3114
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
3115
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
3116
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
3117
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
3118
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
3119
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
3120
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
3121
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
3122
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
3123
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
3124
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
3125
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
3126
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
3127
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
3128
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
3129
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
3130
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
3131
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
3132
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
3133
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
3134
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
3135
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
3136
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
3137
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
3138
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
3139
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
3140
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
3141
- } | undefined;
3142
- readonly data?: ((this: any, vm: any) => any) | undefined;
3143
- readonly computed?: {
3144
- readonly [x: string]: ComputedGetter<any> | {
3145
- readonly get: ComputedGetter<any>;
3146
- readonly set: ComputedSetter<any>;
3147
- };
3148
- } | undefined;
3149
- readonly methods?: {
3150
- readonly [x: string]: Function;
3151
- } | undefined;
3152
- readonly watch?: {
3153
- readonly [x: string]: string | WatchCallback<any, any> | {
3154
- readonly handler: string | WatchCallback<any, any>;
3155
- readonly immediate?: boolean | undefined;
3156
- readonly deep?: boolean | undefined;
3157
- readonly once?: boolean | undefined;
3158
- readonly flush?: "pre" | "post" | "sync" | undefined;
3159
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
3160
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
3161
- } | readonly (string | WatchCallback<any, any> | {
3162
- readonly handler: string | WatchCallback<any, any>;
3163
- readonly immediate?: boolean | undefined;
3164
- readonly deep?: boolean | undefined;
3165
- readonly once?: boolean | undefined;
3166
- readonly flush?: "pre" | "post" | "sync" | undefined;
3167
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
3168
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
3169
- })[];
3170
- } | undefined;
3171
- readonly provide?: Function | {
3172
- readonly [x: string]: Readonly<unknown>;
3173
- readonly [x: symbol]: Readonly<unknown>;
3174
- } | undefined;
3175
- readonly inject?: readonly string[] | {} | undefined;
3176
- readonly filters?: {
3177
- readonly [x: string]: Function;
3178
- } | undefined;
3179
- readonly mixins?: readonly any[] | undefined;
3180
- readonly extends?: any;
3181
- readonly beforeCreate?: (() => void) | undefined;
3182
- readonly created?: (() => void) | undefined;
3183
- readonly beforeMount?: (() => void) | undefined;
3184
- readonly mounted?: (() => void) | undefined;
3185
- readonly beforeUpdate?: (() => void) | undefined;
3186
- readonly updated?: (() => void) | undefined;
3187
- readonly activated?: (() => void) | undefined;
3188
- readonly deactivated?: (() => void) | undefined;
3189
- readonly beforeDestroy?: (() => void) | undefined;
3190
- readonly beforeUnmount?: (() => void) | undefined;
3191
- readonly destroyed?: (() => void) | undefined;
3192
- readonly unmounted?: (() => void) | undefined;
3193
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
3194
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
3195
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
3196
- readonly delimiters?: readonly [string, string] | undefined;
3197
- readonly __differentiator?: string | number | symbol | undefined;
3198
- readonly __isBuiltIn?: boolean | undefined;
3199
- readonly __file?: string | undefined;
3200
- readonly __name?: string | undefined;
3201
- };
3202
- readonly meta?: {} | undefined;
3203
- };
3204
- readonly matches: readonly ({
3205
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3206
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3207
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3208
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3209
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3210
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3211
- readonly name?: string | undefined;
3212
- readonly path: string | {
3213
- readonly path: any;
3214
- readonly params: {} | {
3215
- readonly [x: string]: any;
3216
- } | {
3217
- readonly [x: string]: any;
3218
- };
3219
- readonly toString: () => string;
3220
- };
3221
- readonly query?: string | {
3222
- readonly query: any;
3223
- readonly params: {} | {
3224
- readonly [x: string]: any;
3225
- } | {
3226
- readonly [x: string]: any;
3227
- };
3228
- readonly toString: () => string;
3229
- } | undefined;
3230
- readonly disabled?: boolean | undefined;
3231
- readonly children?: readonly {
3232
- readonly matched: any | {
3233
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3234
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3235
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3236
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3237
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3238
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3239
- readonly name: string;
3240
- readonly disabled?: boolean | undefined;
3241
- readonly path: string | {
3242
- readonly path: any;
3243
- readonly params: {} | {
3244
- readonly [x: string]: any;
3245
- } | {
3246
- readonly [x: string]: any;
3247
- };
3248
- readonly toString: () => string;
3249
- };
3250
- readonly query?: string | {
3251
- readonly query: any;
3252
- readonly params: {} | {
3253
- readonly [x: string]: any;
3254
- } | {
3255
- readonly [x: string]: any;
3256
- };
3257
- readonly toString: () => string;
3258
- } | undefined;
3259
- readonly component: FunctionalComponent<any, {}, any, {}> | {
3260
- new (...args: any[]): any;
3261
- __isFragment?: undefined;
3262
- __isTeleport?: undefined;
3263
- __isSuspense?: undefined;
3264
- } | DefineComponent | AsyncComponentLoader | {
3265
- readonly [x: string]: any;
3266
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
3267
- attrs: {
3268
- [x: string]: unknown;
3269
- };
3270
- slots: Readonly<{
3271
- [name: string]: Slot<any> | undefined;
3272
- }>;
3273
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
3274
- expose: (exposed?: Record<string, any> | undefined) => void;
3275
- }) => any) | undefined;
3276
- readonly name?: string | undefined;
3277
- readonly template?: string | object | undefined;
3278
- readonly render?: Function | undefined;
3279
- readonly components?: {
3280
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
3281
- new (...args: any[]): any;
3282
- __isFragment?: undefined;
3283
- __isTeleport?: undefined;
3284
- __isSuspense?: undefined;
3285
- } | any;
3286
- } | undefined;
3287
- readonly directives?: {
3288
- readonly [x: string]: FunctionDirective<any, any> | {
3289
- readonly created?: DirectiveHook<any, null, any> | undefined;
3290
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
3291
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
3292
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
3293
- [key: string]: any;
3294
- }>, any> | undefined;
3295
- readonly updated?: DirectiveHook<any, VNode<any, any, {
3296
- [key: string]: any;
3297
- }>, any> | undefined;
3298
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
3299
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
3300
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
3301
- [key: string]: any;
3302
- }>) => {
3303
- [x: string]: unknown;
3304
- } | undefined) | undefined;
3305
- readonly deep?: boolean | undefined;
3306
- };
3307
- } | undefined;
3308
- readonly inheritAttrs?: boolean | undefined;
3309
- readonly emits?: any;
3310
- readonly slots?: {} | undefined;
3311
- readonly expose?: readonly string[] | undefined;
3312
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
3313
- readonly compilerOptions?: {
3314
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
3315
- readonly whitespace?: "preserve" | "condense" | undefined;
3316
- readonly comments?: boolean | undefined;
3317
- readonly delimiters?: readonly [string, string] | undefined;
3318
- } | undefined;
3319
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
3320
- readonly __isFragment?: undefined;
3321
- readonly __isTeleport?: undefined;
3322
- readonly __isSuspense?: undefined;
3323
- readonly __defaults?: any;
3324
- readonly compatConfig?: {
3325
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
3326
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
3327
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
3328
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
3329
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
3330
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
3331
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
3332
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
3333
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
3334
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
3335
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
3336
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
3337
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
3338
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
3339
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
3340
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
3341
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
3342
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
3343
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
3344
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
3345
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
3346
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
3347
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
3348
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
3349
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
3350
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
3351
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
3352
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
3353
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
3354
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
3355
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
3356
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
3357
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
3358
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
3359
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
3360
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
3361
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
3362
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
3363
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
3364
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
3365
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
3366
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
3367
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
3368
- } | undefined;
3369
- readonly data?: ((this: any, vm: any) => any) | undefined;
3370
- readonly computed?: {
3371
- readonly [x: string]: ComputedGetter<any> | {
3372
- readonly get: ComputedGetter<any>;
3373
- readonly set: ComputedSetter<any>;
3374
- };
3375
- } | undefined;
3376
- readonly methods?: {
3377
- readonly [x: string]: Function;
3378
- } | undefined;
3379
- readonly watch?: {
3380
- readonly [x: string]: string | WatchCallback<any, any> | {
3381
- readonly handler: string | WatchCallback<any, any>;
3382
- readonly immediate?: boolean | undefined;
3383
- readonly deep?: boolean | undefined;
3384
- readonly once?: boolean | undefined;
3385
- readonly flush?: "pre" | "post" | "sync" | undefined;
3386
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
3387
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
3388
- } | readonly (string | WatchCallback<any, any> | {
3389
- readonly handler: string | WatchCallback<any, any>;
3390
- readonly immediate?: boolean | undefined;
3391
- readonly deep?: boolean | undefined;
3392
- readonly once?: boolean | undefined;
3393
- readonly flush?: "pre" | "post" | "sync" | undefined;
3394
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
3395
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
3396
- })[];
3397
- } | undefined;
3398
- readonly provide?: Function | {
3399
- readonly [x: string]: Readonly<unknown>;
3400
- readonly [x: symbol]: Readonly<unknown>;
3401
- } | undefined;
3402
- readonly inject?: readonly string[] | {} | undefined;
3403
- readonly filters?: {
3404
- readonly [x: string]: Function;
3405
- } | undefined;
3406
- readonly mixins?: readonly any[] | undefined;
3407
- readonly extends?: any;
3408
- readonly beforeCreate?: (() => void) | undefined;
3409
- readonly created?: (() => void) | undefined;
3410
- readonly beforeMount?: (() => void) | undefined;
3411
- readonly mounted?: (() => void) | undefined;
3412
- readonly beforeUpdate?: (() => void) | undefined;
3413
- readonly updated?: (() => void) | undefined;
3414
- readonly activated?: (() => void) | undefined;
3415
- readonly deactivated?: (() => void) | undefined;
3416
- readonly beforeDestroy?: (() => void) | undefined;
3417
- readonly beforeUnmount?: (() => void) | undefined;
3418
- readonly destroyed?: (() => void) | undefined;
3419
- readonly unmounted?: (() => void) | undefined;
3420
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
3421
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
3422
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
3423
- readonly delimiters?: readonly [string, string] | undefined;
3424
- readonly __differentiator?: string | number | symbol | undefined;
3425
- readonly __isBuiltIn?: boolean | undefined;
3426
- readonly __file?: string | undefined;
3427
- readonly __name?: string | undefined;
3428
- };
3429
- readonly meta?: {} | undefined;
3430
- };
3431
- readonly matches: readonly (any | {
3432
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3433
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3434
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3435
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3436
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3437
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3438
- readonly name: string;
3439
- readonly disabled?: boolean | undefined;
3440
- readonly path: string | {
3441
- readonly path: any;
3442
- readonly params: {} | {
3443
- readonly [x: string]: any;
3444
- } | {
3445
- readonly [x: string]: any;
3446
- };
3447
- readonly toString: () => string;
3448
- };
3449
- readonly query?: string | {
3450
- readonly query: any;
3451
- readonly params: {} | {
3452
- readonly [x: string]: any;
3453
- } | {
3454
- readonly [x: string]: any;
3455
- };
3456
- readonly toString: () => string;
3457
- } | undefined;
3458
- readonly component: FunctionalComponent<any, {}, any, {}> | {
3459
- new (...args: any[]): any;
3460
- __isFragment?: undefined;
3461
- __isTeleport?: undefined;
3462
- __isSuspense?: undefined;
3463
- } | DefineComponent | AsyncComponentLoader | {
3464
- readonly [x: string]: any;
3465
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
3466
- attrs: {
3467
- [x: string]: unknown;
3468
- };
3469
- slots: Readonly<{
3470
- [name: string]: Slot<any> | undefined;
3471
- }>;
3472
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
3473
- expose: (exposed?: Record<string, any> | undefined) => void;
3474
- }) => any) | undefined;
3475
- readonly name?: string | undefined;
3476
- readonly template?: string | object | undefined;
3477
- readonly render?: Function | undefined;
3478
- readonly components?: {
3479
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
3480
- new (...args: any[]): any;
3481
- __isFragment?: undefined;
3482
- __isTeleport?: undefined;
3483
- __isSuspense?: undefined;
3484
- } | any;
3485
- } | undefined;
3486
- readonly directives?: {
3487
- readonly [x: string]: FunctionDirective<any, any> | {
3488
- readonly created?: DirectiveHook<any, null, any> | undefined;
3489
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
3490
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
3491
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
3492
- [key: string]: any;
3493
- }>, any> | undefined;
3494
- readonly updated?: DirectiveHook<any, VNode<any, any, {
3495
- [key: string]: any;
3496
- }>, any> | undefined;
3497
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
3498
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
3499
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
3500
- [key: string]: any;
3501
- }>) => {
3502
- [x: string]: unknown;
3503
- } | undefined) | undefined;
3504
- readonly deep?: boolean | undefined;
3505
- };
3506
- } | undefined;
3507
- readonly inheritAttrs?: boolean | undefined;
3508
- readonly emits?: any;
3509
- readonly slots?: {} | undefined;
3510
- readonly expose?: readonly string[] | undefined;
3511
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
3512
- readonly compilerOptions?: {
3513
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
3514
- readonly whitespace?: "preserve" | "condense" | undefined;
3515
- readonly comments?: boolean | undefined;
3516
- readonly delimiters?: readonly [string, string] | undefined;
3517
- } | undefined;
3518
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
3519
- readonly __isFragment?: undefined;
3520
- readonly __isTeleport?: undefined;
3521
- readonly __isSuspense?: undefined;
3522
- readonly __defaults?: any;
3523
- readonly compatConfig?: {
3524
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
3525
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
3526
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
3527
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
3528
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
3529
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
3530
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
3531
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
3532
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
3533
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
3534
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
3535
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
3536
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
3537
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
3538
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
3539
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
3540
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
3541
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
3542
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
3543
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
3544
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
3545
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
3546
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
3547
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
3548
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
3549
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
3550
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
3551
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
3552
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
3553
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
3554
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
3555
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
3556
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
3557
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
3558
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
3559
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
3560
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
3561
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
3562
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
3563
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
3564
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
3565
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
3566
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
3567
- } | undefined;
3568
- readonly data?: ((this: any, vm: any) => any) | undefined;
3569
- readonly computed?: {
3570
- readonly [x: string]: ComputedGetter<any> | {
3571
- readonly get: ComputedGetter<any>;
3572
- readonly set: ComputedSetter<any>;
3573
- };
3574
- } | undefined;
3575
- readonly methods?: {
3576
- readonly [x: string]: Function;
3577
- } | undefined;
3578
- readonly watch?: {
3579
- readonly [x: string]: string | WatchCallback<any, any> | {
3580
- readonly handler: string | WatchCallback<any, any>;
3581
- readonly immediate?: boolean | undefined;
3582
- readonly deep?: boolean | undefined;
3583
- readonly once?: boolean | undefined;
3584
- readonly flush?: "pre" | "post" | "sync" | undefined;
3585
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
3586
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
3587
- } | readonly (string | WatchCallback<any, any> | {
3588
- readonly handler: string | WatchCallback<any, any>;
3589
- readonly immediate?: boolean | undefined;
3590
- readonly deep?: boolean | undefined;
3591
- readonly once?: boolean | undefined;
3592
- readonly flush?: "pre" | "post" | "sync" | undefined;
3593
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
3594
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
3595
- })[];
3596
- } | undefined;
3597
- readonly provide?: Function | {
3598
- readonly [x: string]: Readonly<unknown>;
3599
- readonly [x: symbol]: Readonly<unknown>;
3600
- } | undefined;
3601
- readonly inject?: readonly string[] | {} | undefined;
3602
- readonly filters?: {
3603
- readonly [x: string]: Function;
3604
- } | undefined;
3605
- readonly mixins?: readonly any[] | undefined;
3606
- readonly extends?: any;
3607
- readonly beforeCreate?: (() => void) | undefined;
3608
- readonly created?: (() => void) | undefined;
3609
- readonly beforeMount?: (() => void) | undefined;
3610
- readonly mounted?: (() => void) | undefined;
3611
- readonly beforeUpdate?: (() => void) | undefined;
3612
- readonly updated?: (() => void) | undefined;
3613
- readonly activated?: (() => void) | undefined;
3614
- readonly deactivated?: (() => void) | undefined;
3615
- readonly beforeDestroy?: (() => void) | undefined;
3616
- readonly beforeUnmount?: (() => void) | undefined;
3617
- readonly destroyed?: (() => void) | undefined;
3618
- readonly unmounted?: (() => void) | undefined;
3619
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
3620
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
3621
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
3622
- readonly delimiters?: readonly [string, string] | undefined;
3623
- readonly __differentiator?: string | number | symbol | undefined;
3624
- readonly __isBuiltIn?: boolean | undefined;
3625
- readonly __file?: string | undefined;
3626
- readonly __name?: string | undefined;
3627
- };
3628
- readonly meta?: {} | undefined;
3629
- })[];
3630
- readonly key: any;
3631
- readonly path: {
3632
- readonly path: any;
3633
- readonly params: {} | {
3634
- readonly [x: string]: any;
3635
- } | {
3636
- readonly [x: string]: any;
3637
- };
3638
- readonly toString: () => string;
3639
- };
3640
- readonly query: {
3641
- readonly query: any;
3642
- readonly params: {} | {
3643
- readonly [x: string]: any;
3644
- } | {
3645
- readonly [x: string]: any;
3646
- };
3647
- readonly toString: () => string;
3648
- };
3649
- readonly pathParams: {} | {
3650
- readonly [x: string]: any;
3651
- } | {
3652
- readonly [x: string]: any;
3653
- };
3654
- readonly queryParams: {} | {
3655
- readonly [x: string]: any;
3656
- } | {
3657
- readonly [x: string]: any;
3658
- };
3659
- readonly depth: number;
3660
- readonly disabled: boolean;
3661
- }[] | undefined;
3662
- readonly component?: FunctionalComponent<any, {}, any, {}> | {
3663
- new (...args: any[]): any;
3664
- __isFragment?: undefined;
3665
- __isTeleport?: undefined;
3666
- __isSuspense?: undefined;
3667
- } | DefineComponent | AsyncComponentLoader | {
3668
- readonly [x: string]: any;
3669
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
3670
- attrs: {
3671
- [x: string]: unknown;
3672
- };
3673
- slots: Readonly<{
3674
- [name: string]: Slot<any> | undefined;
3675
- }>;
3676
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
3677
- expose: (exposed?: Record<string, any> | undefined) => void;
3678
- }) => any) | undefined;
3679
- readonly name?: string | undefined;
3680
- readonly template?: string | object | undefined;
3681
- readonly render?: Function | undefined;
3682
- readonly components?: {
3683
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
3684
- new (...args: any[]): any;
3685
- __isFragment?: undefined;
3686
- __isTeleport?: undefined;
3687
- __isSuspense?: undefined;
3688
- } | any;
3689
- } | undefined;
3690
- readonly directives?: {
3691
- readonly [x: string]: FunctionDirective<any, any> | {
3692
- readonly created?: DirectiveHook<any, null, any> | undefined;
3693
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
3694
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
3695
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
3696
- [key: string]: any;
3697
- }>, any> | undefined;
3698
- readonly updated?: DirectiveHook<any, VNode<any, any, {
3699
- [key: string]: any;
3700
- }>, any> | undefined;
3701
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
3702
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
3703
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
3704
- [key: string]: any;
3705
- }>) => {
3706
- [x: string]: unknown;
3707
- } | undefined) | undefined;
3708
- readonly deep?: boolean | undefined;
3709
- };
3710
- } | undefined;
3711
- readonly inheritAttrs?: boolean | undefined;
3712
- readonly emits?: any;
3713
- readonly slots?: {} | undefined;
3714
- readonly expose?: readonly string[] | undefined;
3715
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
3716
- readonly compilerOptions?: {
3717
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
3718
- readonly whitespace?: "preserve" | "condense" | undefined;
3719
- readonly comments?: boolean | undefined;
3720
- readonly delimiters?: readonly [string, string] | undefined;
3721
- } | undefined;
3722
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
3723
- readonly __isFragment?: undefined;
3724
- readonly __isTeleport?: undefined;
3725
- readonly __isSuspense?: undefined;
3726
- readonly __defaults?: any;
3727
- readonly compatConfig?: {
3728
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
3729
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
3730
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
3731
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
3732
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
3733
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
3734
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
3735
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
3736
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
3737
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
3738
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
3739
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
3740
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
3741
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
3742
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
3743
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
3744
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
3745
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
3746
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
3747
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
3748
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
3749
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
3750
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
3751
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
3752
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
3753
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
3754
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
3755
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
3756
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
3757
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
3758
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
3759
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
3760
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
3761
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
3762
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
3763
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
3764
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
3765
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
3766
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
3767
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
3768
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
3769
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
3770
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
3771
- } | undefined;
3772
- readonly data?: ((this: any, vm: any) => any) | undefined;
3773
- readonly computed?: {
3774
- readonly [x: string]: ComputedGetter<any> | {
3775
- readonly get: ComputedGetter<any>;
3776
- readonly set: ComputedSetter<any>;
3777
- };
3778
- } | undefined;
3779
- readonly methods?: {
3780
- readonly [x: string]: Function;
3781
- } | undefined;
3782
- readonly watch?: {
3783
- readonly [x: string]: string | WatchCallback<any, any> | {
3784
- readonly handler: string | WatchCallback<any, any>;
3785
- readonly immediate?: boolean | undefined;
3786
- readonly deep?: boolean | undefined;
3787
- readonly once?: boolean | undefined;
3788
- readonly flush?: "pre" | "post" | "sync" | undefined;
3789
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
3790
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
3791
- } | readonly (string | WatchCallback<any, any> | {
3792
- readonly handler: string | WatchCallback<any, any>;
3793
- readonly immediate?: boolean | undefined;
3794
- readonly deep?: boolean | undefined;
3795
- readonly once?: boolean | undefined;
3796
- readonly flush?: "pre" | "post" | "sync" | undefined;
3797
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
3798
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
3799
- })[];
3800
- } | undefined;
3801
- readonly provide?: Function | {
3802
- readonly [x: string]: Readonly<unknown>;
3803
- readonly [x: symbol]: Readonly<unknown>;
3804
- } | undefined;
3805
- readonly inject?: readonly string[] | {} | undefined;
3806
- readonly filters?: {
3807
- readonly [x: string]: Function;
3808
- } | undefined;
3809
- readonly mixins?: readonly any[] | undefined;
3810
- readonly extends?: any;
3811
- readonly beforeCreate?: (() => void) | undefined;
3812
- readonly created?: (() => void) | undefined;
3813
- readonly beforeMount?: (() => void) | undefined;
3814
- readonly mounted?: (() => void) | undefined;
3815
- readonly beforeUpdate?: (() => void) | undefined;
3816
- readonly updated?: (() => void) | undefined;
3817
- readonly activated?: (() => void) | undefined;
3818
- readonly deactivated?: (() => void) | undefined;
3819
- readonly beforeDestroy?: (() => void) | undefined;
3820
- readonly beforeUnmount?: (() => void) | undefined;
3821
- readonly destroyed?: (() => void) | undefined;
3822
- readonly unmounted?: (() => void) | undefined;
3823
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
3824
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
3825
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
3826
- readonly delimiters?: readonly [string, string] | undefined;
3827
- readonly __differentiator?: string | number | symbol | undefined;
3828
- readonly __isBuiltIn?: boolean | undefined;
3829
- readonly __file?: string | undefined;
3830
- readonly __name?: string | undefined;
3831
- } | undefined;
3832
- readonly meta?: {} | undefined;
3833
- } | {
3834
- readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3835
- readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3836
- readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
3837
- readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3838
- readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3839
- readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
3840
- readonly name: string;
3841
- readonly disabled?: boolean | undefined;
3842
- readonly path: string | {
3843
- readonly path: any;
3844
- readonly params: {} | {
3845
- readonly [x: string]: any;
3846
- } | {
3847
- readonly [x: string]: any;
3848
- };
3849
- readonly toString: () => string;
3850
- };
3851
- readonly query?: string | {
3852
- readonly query: any;
3853
- readonly params: {} | {
3854
- readonly [x: string]: any;
3855
- } | {
3856
- readonly [x: string]: any;
3857
- };
3858
- readonly toString: () => string;
3859
- } | undefined;
3860
- readonly component: FunctionalComponent<any, {}, any, {}> | {
3861
- new (...args: any[]): any;
3862
- __isFragment?: undefined;
3863
- __isTeleport?: undefined;
3864
- __isSuspense?: undefined;
3865
- } | DefineComponent | AsyncComponentLoader | {
3866
- readonly [x: string]: any;
3867
- readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
3868
- attrs: {
3869
- [x: string]: unknown;
3870
- };
3871
- slots: Readonly<{
3872
- [name: string]: Slot<any> | undefined;
3873
- }>;
3874
- emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
3875
- expose: (exposed?: Record<string, any> | undefined) => void;
3876
- }) => any) | undefined;
3877
- readonly name?: string | undefined;
3878
- readonly template?: string | object | undefined;
3879
- readonly render?: Function | undefined;
3880
- readonly components?: {
3881
- readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
3882
- new (...args: any[]): any;
3883
- __isFragment?: undefined;
3884
- __isTeleport?: undefined;
3885
- __isSuspense?: undefined;
3886
- } | any;
3887
- } | undefined;
3888
- readonly directives?: {
3889
- readonly [x: string]: FunctionDirective<any, any> | {
3890
- readonly created?: DirectiveHook<any, null, any> | undefined;
3891
- readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
3892
- readonly mounted?: DirectiveHook<any, null, any> | undefined;
3893
- readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
3894
- [key: string]: any;
3895
- }>, any> | undefined;
3896
- readonly updated?: DirectiveHook<any, VNode<any, any, {
3897
- [key: string]: any;
3898
- }>, any> | undefined;
3899
- readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
3900
- readonly unmounted?: DirectiveHook<any, null, any> | undefined;
3901
- readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
3902
- [key: string]: any;
3903
- }>) => {
3904
- [x: string]: unknown;
3905
- } | undefined) | undefined;
3906
- readonly deep?: boolean | undefined;
3907
- };
3908
- } | undefined;
3909
- readonly inheritAttrs?: boolean | undefined;
3910
- readonly emits?: any;
3911
- readonly slots?: {} | undefined;
3912
- readonly expose?: readonly string[] | undefined;
3913
- readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
3914
- readonly compilerOptions?: {
3915
- readonly isCustomElement?: ((tag: string) => boolean) | undefined;
3916
- readonly whitespace?: "preserve" | "condense" | undefined;
3917
- readonly comments?: boolean | undefined;
3918
- readonly delimiters?: readonly [string, string] | undefined;
3919
- } | undefined;
3920
- readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
3921
- readonly __isFragment?: undefined;
3922
- readonly __isTeleport?: undefined;
3923
- readonly __isSuspense?: undefined;
3924
- readonly __defaults?: any;
3925
- readonly compatConfig?: {
3926
- readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
3927
- readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
3928
- readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
3929
- readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
3930
- readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
3931
- readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
3932
- readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
3933
- readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
3934
- readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
3935
- readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
3936
- readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
3937
- readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
3938
- readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
3939
- readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
3940
- readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
3941
- readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
3942
- readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
3943
- readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
3944
- readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
3945
- readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
3946
- readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
3947
- readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
3948
- readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
3949
- readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
3950
- readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
3951
- readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
3952
- readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
3953
- readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
3954
- readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
3955
- readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
3956
- readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
3957
- readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
3958
- readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
3959
- readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
3960
- readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
3961
- readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
3962
- readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
3963
- readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
3964
- readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
3965
- readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
3966
- readonly FILTERS?: boolean | "suppress-warning" | undefined;
3967
- readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
3968
- readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
3969
- } | undefined;
3970
- readonly data?: ((this: any, vm: any) => any) | undefined;
3971
- readonly computed?: {
3972
- readonly [x: string]: ComputedGetter<any> | {
3973
- readonly get: ComputedGetter<any>;
3974
- readonly set: ComputedSetter<any>;
3975
- };
3976
- } | undefined;
3977
- readonly methods?: {
3978
- readonly [x: string]: Function;
3979
- } | undefined;
3980
- readonly watch?: {
3981
- readonly [x: string]: string | WatchCallback<any, any> | {
3982
- readonly handler: string | WatchCallback<any, any>;
3983
- readonly immediate?: boolean | undefined;
3984
- readonly deep?: boolean | undefined;
3985
- readonly once?: boolean | undefined;
3986
- readonly flush?: "pre" | "post" | "sync" | undefined;
3987
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
3988
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
3989
- } | readonly (string | WatchCallback<any, any> | {
3990
- readonly handler: string | WatchCallback<any, any>;
3991
- readonly immediate?: boolean | undefined;
3992
- readonly deep?: boolean | undefined;
3993
- readonly once?: boolean | undefined;
3994
- readonly flush?: "pre" | "post" | "sync" | undefined;
3995
- readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
3996
- readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
3997
- })[];
3998
- } | undefined;
3999
- readonly provide?: Function | {
4000
- readonly [x: string]: Readonly<unknown>;
4001
- readonly [x: symbol]: Readonly<unknown>;
4002
- } | undefined;
4003
- readonly inject?: readonly string[] | {} | undefined;
4004
- readonly filters?: {
4005
- readonly [x: string]: Function;
4006
- } | undefined;
4007
- readonly mixins?: readonly any[] | undefined;
4008
- readonly extends?: any;
4009
- readonly beforeCreate?: (() => void) | undefined;
4010
- readonly created?: (() => void) | undefined;
4011
- readonly beforeMount?: (() => void) | undefined;
4012
- readonly mounted?: (() => void) | undefined;
4013
- readonly beforeUpdate?: (() => void) | undefined;
4014
- readonly updated?: (() => void) | undefined;
4015
- readonly activated?: (() => void) | undefined;
4016
- readonly deactivated?: (() => void) | undefined;
4017
- readonly beforeDestroy?: (() => void) | undefined;
4018
- readonly beforeUnmount?: (() => void) | undefined;
4019
- readonly destroyed?: (() => void) | undefined;
4020
- readonly unmounted?: (() => void) | undefined;
4021
- readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
4022
- readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
4023
- readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance< {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
4024
- readonly delimiters?: readonly [string, string] | undefined;
4025
- readonly __differentiator?: string | number | symbol | undefined;
4026
- readonly __isBuiltIn?: boolean | undefined;
4027
- readonly __file?: string | undefined;
4028
- readonly __name?: string | undefined;
4029
- };
4030
- readonly meta?: {} | undefined;
4031
- })[];
4032
- readonly key: any;
4033
- readonly query: {
4034
- readonly get: (key: string) => string | null;
4035
- readonly getAll: (key: string) => string[];
4036
- };
4037
- readonly params: {};
4038
- };
877
+ route: RouterRoute;
4039
878
  component: RouteComponent;
4040
879
  }) => unknown) | undefined;
4041
880
  }>;
4042
881
 
882
+ /**
883
+ * Represents an immutable array of Route instances. Return value of `createRoutes`, expected param for `createRouter`.
884
+ */
4043
885
  export declare type Routes = Readonly<Route[]>;
4044
886
 
4045
- export declare const routes: [Route<"parentA", Path<"/:paramA", {}>, Query<"", {}>, false>, Route<"parentA.childA", Path<"/:paramA/:?paramB", MergeParams< {
4046
- paramA: StringConstructor;
4047
- }, {
4048
- paramB: StringConstructor | undefined;
4049
- }>>, Query<"", MergeParams< {}, {}>>, false>, Route<"parentA.childA.grandChildA", Path<"/:paramA/:?paramB/:paramC", MergeParams< {
4050
- paramA: StringConstructor;
4051
- }, {
4052
- paramB: StringConstructor | undefined;
4053
- paramC: StringConstructor;
4054
- }>>, Query<"", MergeParams< {}, {}>>, false>, Route<"parentA.childB", Path<"/:paramA/:paramD", MergeParams< {
4055
- paramA: StringConstructor;
4056
- }, {
4057
- paramD: StringConstructor;
4058
- }>>, Query<"", MergeParams< {}, {}>>, false>, Route<"parentB", Path<"/parentB", {}>, Query<"", {}>, false>];
4059
-
4060
- export declare type RoutesKey<TRoutes extends Routes> = string & keyof RoutesMap<TRoutes>;
4061
-
4062
- export declare type RoutesMap<TRoutes extends Routes = []> = {
887
+ declare type RoutesKey<TRoutes extends Routes> = string & keyof RoutesMap<TRoutes>;
888
+
889
+ declare type RoutesMap<TRoutes extends Routes = []> = {
4063
890
  [K in TRoutes[number] as NamedNotDisabled<K> extends {
4064
891
  key: string;
4065
892
  } ? NamedNotDisabled<K>['key'] : never]: NamedNotDisabled<K>;
4066
893
  };
4067
894
 
4068
- declare type RouteSortMethod = (aRoute: Route, bRoute: Route) => number;
4069
-
4070
- export declare function setParamValue(value: unknown, param: Param): string;
4071
-
4072
- export declare function setParamValueOnUrl(path: string, paramReplace?: ParamReplace): string;
895
+ declare type RouteUpdate<TRoute extends ResolvedRoute = ResolvedRoute> = {
896
+ <TKey extends keyof TRoute['params']>(key: TKey, value: TRoute['params'][TKey], options?: RouterPushOptions): Promise<void>;
897
+ (params: Partial<TRoute['params']>, options?: RouterPushOptions): Promise<void>;
898
+ };
4073
899
 
4074
- export declare function stringHasValue(value: string | undefined): boolean;
900
+ declare type StringHasValue<T extends string | undefined> = T extends undefined ? false : '' extends T ? false : true;
4075
901
 
4076
902
  declare type ToCallback = (resolve: RegisteredRouter['resolve']) => string;
4077
903
 
4078
- export declare type ToPath<T extends string | Path> = T extends string ? Path<T, {}> : T;
4079
-
4080
- export declare function toPath<T extends string | Path>(value: T): ToPath<T>;
4081
-
4082
- export declare type ToQuery<T extends string | Query | undefined> = T extends string ? Query<T, {}> : T extends undefined ? Query<'', {}> : unknown extends T ? Query<'', {}> : T;
904
+ declare type ToPath<T extends string | Path> = T extends string ? Path<T, {}> : T;
4083
905
 
4084
- export declare function toQuery<T extends string | Query | undefined>(value: T): ToQuery<T>;
906
+ declare type ToQuery<T extends string | Query | undefined> = T extends string ? Query<T, {}> : T extends undefined ? Query<'', {}> : unknown extends T ? Query<'', {}> : T;
4085
907
 
4086
- export declare type Url = `http://${string}` | `https://${string}` | `/${string}` | '/';
4087
-
4088
- export declare function useParam<T>(param: string): Ref<T | undefined>;
4089
-
4090
- export declare function useParam<T>(param: string, defaultValue: T): Ref<T>;
4091
-
4092
- export declare function useParamRaw(param: string): Ref<string | undefined>;
4093
-
4094
- export declare function useParamRaw(param: string, defaultValue: string): Ref<string>;
908
+ declare type Url = `http://${string}` | `https://${string}` | `/${string}` | '/';
4095
909
 
910
+ /**
911
+ * A composition to access the router's rejection state.
912
+ *
913
+ * @returns {RouterRejection} The rejection state object from the router, which can be used to handle route rejections
914
+ * such as authentication failures or permission denials.
915
+ * @throws {Error} Throws an error if the router's rejection state is not available, typically indicating
916
+ * that createRouter was never called.
917
+ */
4096
918
  export declare function useRejection(): RouterRejection;
4097
919
 
4098
- export declare function useRoute<TRouteKey extends string & keyof RegisteredRouteMap>(routeKey: TRouteKey): DeepReadonly<ResolvedRoute<RegisteredRouteMap[TRouteKey]>>;
4099
-
4100
- export declare function useRoute(): DeepReadonly<ResolvedRoute>;
4101
-
4102
- export declare function useRouteParam<TRoute extends Route, TParam extends keyof ExtractRouteParamTypes<TRoute>, TParamType = ExtractRouteParamTypes<TRoute>[TParam]>(_route: TRoute, _param: TParam, _defaultValue?: TParamType): Ref<TParamType>;
4103
-
4104
- export declare function useRouteParamRaw<TRoute extends Route, TParam extends keyof ExtractRouteParamTypes<TRoute>, TParamType extends ParamRawValue<ExtractRouteParamTypes<TRoute>[TParam]>>(_route: TRoute, _param: TParam, _defaultValue?: TParamType): Ref<ParamRawValue<TParamType>>;
920
+ /**
921
+ * A composition to access the current route or verify a specific route key within a Vue component.
922
+ * This function provides two overloads:
923
+ * 1. When called without arguments, it returns the current route from the router without types.
924
+ * 2. When called with a route key, it checks if the current active route includes the specified route key.
925
+ *
926
+ * @template TRouteKey - A string type that should match route key of RegisteredRouteMap, ensuring the route key exists.
927
+ * @param routeKey - Optional. The key of the route to validate against the current active routes.
928
+ * @returns The current router route. If a route key is provided, it validates the route key first.
929
+ * @throws {UseRouteInvalidError} Throws an error if the provided route key is not valid or does not match the current route.
930
+ *
931
+ * The function also sets up a reactive watcher on the route object from the router to continually check the validity of the route key
932
+ * if provided, throwing an error if the validation fails at any point during the component's lifecycle.
933
+ */
934
+ export declare function useRoute<TRouteKey extends string & keyof RegisteredRouteMap>(routeKey: TRouteKey): RouterRoute<ResolvedRoute<RegisteredRouteMap[TRouteKey]>>;
935
+
936
+ export declare function useRoute(): RouterRoute;
937
+
938
+ /**
939
+ * An error thrown when there is a mismatch between an expected route and the one actually used.
940
+ */
941
+ export declare class UseRouteInvalidError extends Error {
942
+ /**
943
+ * Constructs a new UseRouteInvalidError instance with a message that specifies both the given and expected route names.
944
+ * This detailed error message aids in quickly identifying and resolving mismatches in route usage.
945
+ * @param routeName - The route name that was incorrectly used.
946
+ * @param actualRouteName - The expected route name that should have been used.
947
+ */
948
+ constructor(routeName: string, actualRouteName: string);
949
+ }
4105
950
 
951
+ /**
952
+ * A composition to access the registered router instance within a Vue component.
953
+ *
954
+ * @returns The registered router instance.
955
+ * @throws {RouterNotInstalledError} Throws an error if the router has not been installed,
956
+ * ensuring the component does not operate without routing functionality.
957
+ */
4106
958
  export declare function useRouter(): RegisteredRouter;
4107
959
 
960
+ /**
961
+ * Defines route hooks that can be applied before entering, updating, or leaving a route, as well as after these events.
962
+ */
4108
963
  declare type WithHooks = {
4109
964
  onBeforeRouteEnter?: MaybeArray<BeforeRouteHook>;
4110
965
  onBeforeRouteUpdate?: MaybeArray<BeforeRouteHook>;
@@ -4118,7 +973,9 @@ declare type WithOptionalProperties<T> = {
4118
973
  [P in keyof T]-?: undefined extends T[P] ? P : never;
4119
974
  }[keyof T];
4120
975
 
4121
- export declare function withQuery(url: string, query?: Record<string, string>): string;
976
+ declare type Writable<T> = {
977
+ -readonly [P in keyof T]: T[P];
978
+ };
4122
979
 
4123
980
  export { }
4124
981