1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
| import {
| Component,
| AsyncComponent,
| ComponentOptions,
| FunctionalComponentOptions,
| WatchOptionsWithHandler,
| WatchHandler,
| DirectiveOptions,
| DirectiveFunction,
| RecordPropsDefinition,
| ThisTypedComponentOptionsWithArrayProps,
| ThisTypedComponentOptionsWithRecordProps,
| WatchOptions,
| } from "./options";
| import { VNode, VNodeData, VNodeChildren, NormalizedScopedSlot } from "./vnode";
| import { PluginFunction, PluginObject } from "./plugin";
|
| export interface CreateElement {
| (tag?: string | Component<any, any, any, any> | AsyncComponent<any, any, any, any> | (() => Component), children?: VNodeChildren): VNode;
| (tag?: string | Component<any, any, any, any> | AsyncComponent<any, any, any, any> | (() => Component), data?: VNodeData, children?: VNodeChildren): VNode;
| }
|
| export interface Vue {
| readonly $el: Element;
| readonly $options: ComponentOptions<Vue>;
| readonly $parent: Vue;
| readonly $root: Vue;
| readonly $children: Vue[];
| readonly $refs: { [key: string]: Vue | Element | (Vue | Element)[] | undefined };
| readonly $slots: { [key: string]: VNode[] | undefined };
| readonly $scopedSlots: { [key: string]: NormalizedScopedSlot | undefined };
| readonly $isServer: boolean;
| readonly $data: Record<string, any>;
| readonly $props: Record<string, any>;
| readonly $ssrContext: any;
| readonly $vnode: VNode;
| readonly $attrs: Record<string, string>;
| readonly $listeners: Record<string, Function | Function[]>;
|
| $mount(elementOrSelector?: Element | string, hydrating?: boolean): this;
| $forceUpdate(): void;
| $destroy(): void;
| $set: typeof Vue.set;
| $delete: typeof Vue.delete;
| $watch(
| expOrFn: string,
| callback: (this: this, n: any, o: any) => void,
| options?: WatchOptions
| ): (() => void);
| $watch<T>(
| expOrFn: (this: this) => T,
| callback: (this: this, n: T, o: T) => void,
| options?: WatchOptions
| ): (() => void);
| $on(event: string | string[], callback: Function): this;
| $once(event: string | string[], callback: Function): this;
| $off(event?: string | string[], callback?: Function): this;
| $emit(event: string, ...args: any[]): this;
| $nextTick(callback: (this: this) => void): void;
| $nextTick(): Promise<void>;
| $createElement: CreateElement;
| }
|
| export type CombinedVueInstance<Instance extends Vue, Data, Methods, Computed, Props> = Data & Methods & Computed & Props & Instance;
| export type ExtendedVue<Instance extends Vue, Data, Methods, Computed, Props> = VueConstructor<CombinedVueInstance<Instance, Data, Methods, Computed, Props> & Vue>;
|
| export interface VueConfiguration {
| silent: boolean;
| optionMergeStrategies: any;
| devtools: boolean;
| productionTip: boolean;
| performance: boolean;
| errorHandler(err: Error, vm: Vue, info: string): void;
| warnHandler(msg: string, vm: Vue, trace: string): void;
| ignoredElements: (string | RegExp)[];
| keyCodes: { [key: string]: number | number[] };
| async: boolean;
| }
|
| export interface VueConstructor<V extends Vue = Vue> {
| new <Data = object, Methods = object, Computed = object, PropNames extends string = never>(options?: ThisTypedComponentOptionsWithArrayProps<V, Data, Methods, Computed, PropNames>): CombinedVueInstance<V, Data, Methods, Computed, Record<PropNames, any>>;
| // ideally, the return type should just contain Props, not Record<keyof Props, any>. But TS requires to have Base constructors with the same return type.
| new <Data = object, Methods = object, Computed = object, Props = object>(options?: ThisTypedComponentOptionsWithRecordProps<V, Data, Methods, Computed, Props>): CombinedVueInstance<V, Data, Methods, Computed, Record<keyof Props, any>>;
| new (options?: ComponentOptions<V>): CombinedVueInstance<V, object, object, object, Record<keyof object, any>>;
|
| extend<Data, Methods, Computed, PropNames extends string = never>(options?: ThisTypedComponentOptionsWithArrayProps<V, Data, Methods, Computed, PropNames>): ExtendedVue<V, Data, Methods, Computed, Record<PropNames, any>>;
| extend<Data, Methods, Computed, Props>(options?: ThisTypedComponentOptionsWithRecordProps<V, Data, Methods, Computed, Props>): ExtendedVue<V, Data, Methods, Computed, Props>;
| extend<PropNames extends string = never>(definition: FunctionalComponentOptions<Record<PropNames, any>, PropNames[]>): ExtendedVue<V, {}, {}, {}, Record<PropNames, any>>;
| extend<Props>(definition: FunctionalComponentOptions<Props, RecordPropsDefinition<Props>>): ExtendedVue<V, {}, {}, {}, Props>;
| extend(options?: ComponentOptions<V>): ExtendedVue<V, {}, {}, {}, {}>;
|
| nextTick<T>(callback: (this: T) => void, context?: T): void;
| nextTick(): Promise<void>
| set<T>(object: object, key: string | number, value: T): T;
| set<T>(array: T[], key: number, value: T): T;
| delete(object: object, key: string | number): void;
| delete<T>(array: T[], key: number): void;
|
| directive(
| id: string,
| definition?: DirectiveOptions | DirectiveFunction
| ): DirectiveOptions;
| filter(id: string, definition?: Function): Function;
|
| component(id: string): VueConstructor;
| component<VC extends VueConstructor>(id: string, constructor: VC): VC;
| component<Data, Methods, Computed, Props>(id: string, definition: AsyncComponent<Data, Methods, Computed, Props>): ExtendedVue<V, Data, Methods, Computed, Props>;
| component<Data, Methods, Computed, PropNames extends string = never>(id: string, definition?: ThisTypedComponentOptionsWithArrayProps<V, Data, Methods, Computed, PropNames>): ExtendedVue<V, Data, Methods, Computed, Record<PropNames, any>>;
| component<Data, Methods, Computed, Props>(id: string, definition?: ThisTypedComponentOptionsWithRecordProps<V, Data, Methods, Computed, Props>): ExtendedVue<V, Data, Methods, Computed, Props>;
| component<PropNames extends string>(id: string, definition: FunctionalComponentOptions<Record<PropNames, any>, PropNames[]>): ExtendedVue<V, {}, {}, {}, Record<PropNames, any>>;
| component<Props>(id: string, definition: FunctionalComponentOptions<Props, RecordPropsDefinition<Props>>): ExtendedVue<V, {}, {}, {}, Props>;
| component(id: string, definition?: ComponentOptions<V>): ExtendedVue<V, {}, {}, {}, {}>;
|
| use<T>(plugin: PluginObject<T> | PluginFunction<T>, options?: T): VueConstructor<V>;
| use(plugin: PluginObject<any> | PluginFunction<any>, ...options: any[]): VueConstructor<V>;
| mixin(mixin: VueConstructor | ComponentOptions<Vue>): VueConstructor<V>;
| compile(template: string): {
| render(createElement: typeof Vue.prototype.$createElement): VNode;
| staticRenderFns: (() => VNode)[];
| };
|
| observable<T>(obj: T): T;
|
| util: {
| warn(msg: string, vm?: InstanceType<VueConstructor>): void;
| };
|
| config: VueConfiguration;
| version: string;
| }
|
| export const Vue: VueConstructor;
|
|
