vize 0.605.0 → 0.607.0

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.
@@ -0,0 +1,522 @@
1
+ // Generated from the shared virtual TypeScript helpers. Do not edit.
2
+ // One module for every content-mapper virtual file.
3
+ declare global {
4
+ // ============================================
5
+ // Shared ambient helpers for vize virtual TypeScript
6
+ // Generated by vize
7
+ // ============================================
8
+ // Global script: one copy of these declarations per program replaces the
9
+ // preamble previously embedded in every generated .vue.ts module.
10
+
11
+ // ImportMeta augmentation (reference existing framework types)
12
+ // Extend ImportMeta with Nuxt-specific properties not covered by vite/client
13
+ interface ImportMeta {
14
+ client: boolean;
15
+ server: boolean;
16
+ dev: boolean;
17
+ prod: boolean;
18
+ ssr: boolean;
19
+ }
20
+
21
+ namespace JSX { interface IntrinsicAttributes { class?: unknown; style?: unknown; } }
22
+ // vue-tsc generic library components accept unknown attrs through this
23
+ // fallback, which vue-tsc itself declares unless `checkUnknownProps` is set.
24
+ var __VLS_PROPS_FALLBACK: Record<string, unknown>;
25
+
26
+ // Shared type helpers used by generated virtual modules
27
+
28
+ type __EmitShape<T> = T extends (...args: any[]) => any ? T : T extends Record<string, any> ? { [K in keyof T]: T[K] extends (...args: infer A) => any ? A : T[K] extends any[] ? T[K] : any[]; } : Record<string, any[]>;
29
+ type __EmitArgs<T, K extends keyof T> = T[K] extends any[] ? T[K] : any[];
30
+ type __EmitFn<T, __S = __EmitShape<T>, __K extends keyof __S & string = keyof __S & string, __U = { [K in __K]: (event: K, ...args: __EmitArgs<__S, K>) => void }[__K]> = __S extends (...args: any[]) => any ? __S : [__K] extends [never] ? (event: never, ...args: any[]) => void : (__U extends unknown ? (fn: __U) => void : never) extends (fn: infer __I) => void ? __I : never;
31
+ type __RuntimePropValue<T> = T extends abstract new (...args: any[]) => infer V ? V : T extends (...args: any[]) => infer V ? V : never;
32
+ type __RuntimePropCtorInner<T> = T extends null | undefined ? never : T extends readonly (infer U)[] ? __RuntimePropCtorInner<U> : T extends { type: infer U } ? __RuntimePropCtorInner<U> : T extends StringConstructor ? string : T extends NumberConstructor ? number : T extends BooleanConstructor ? boolean : T extends ArrayConstructor ? unknown[] : T extends ObjectConstructor ? Record<string, any> : T extends DateConstructor ? Date : T extends FunctionConstructor ? (...args: any[]) => any : __RuntimePropValue<T>;
33
+ type __RuntimePropCtor<T> = [__RuntimePropCtorInner<T>] extends [never] ? unknown : __RuntimePropCtorInner<T>;
34
+ type __RuntimePropHasBoolean<T> = T extends BooleanConstructor ? true : T extends readonly (infer U)[] ? __RuntimePropHasBoolean<U> : T extends { type: infer U } ? __RuntimePropHasBoolean<U> : false;
35
+ type __RuntimePropResolved<T> = T extends { required: true } ? true : T extends { default: any } ? true : __RuntimePropHasBoolean<T>;
36
+ type __RuntimePropShape<T extends Record<string, any>> = { [K in keyof T]: __RuntimePropResolved<T[K]> extends true ? __RuntimePropCtor<T[K]> : __RuntimePropCtor<T[K]> | undefined; };
37
+ type __VizeIsAny<T> = 0 extends (1 & T) ? true : false;
38
+
39
+ type __LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P] };
40
+ type __VizeBooleanKey<T, K extends keyof T = keyof T> = K extends any ? [Exclude<T[K], undefined>] extends [never] ? never : [Exclude<T[K], undefined>] extends [boolean] ? K : never : never; type __DefineProps<T, __BKeys extends keyof T = __VizeBooleanKey<T>> = Readonly<T> & { readonly [K in __BKeys]-?: boolean };
41
+ type __VizeIfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
42
+ type __VizeNotUndefined<T> = T extends undefined ? never : T;
43
+ type __VizeMappedOmit<T, K extends keyof any> = { [P in keyof T as P extends K ? never : P]: T[P] };
44
+ type __VizeDefaultNativeType = null | number | string | boolean | symbol | Function;
45
+ type __VizeInferDefault<P, T> = ((props: P) => T & {}) | (T extends __VizeDefaultNativeType ? T : never);
46
+ type __WithDefaultsArgs<T> = { [K in keyof T]?: __VizeInferDefault<T, T[K]> };
47
+ type __WithDefaultsResult<T, D, __BKeys extends keyof T = never> = T extends unknown ? Readonly<__VizeMappedOmit<T, keyof D>> & { readonly [K in keyof D as K extends keyof T ? K : never]-?: K extends keyof T ? D[K] extends undefined ? __VizeIfAny<D[K], __VizeNotUndefined<T[K]>, T[K]> : __VizeNotUndefined<T[K]> : never } & { readonly [K in __BKeys]-?: K extends keyof D ? D[K] extends undefined ? boolean | undefined : boolean : boolean } : never;
48
+ type __Ref<T> = import('vue').Ref<T>;
49
+ type __ShallowRef<T> = import('vue').ShallowRef<T>;
50
+
51
+ type __VizeKebabCase<S extends string, Acc extends string = ""> = S extends `${infer Head}${infer Tail}` ? Head extends Lowercase<Head> ? __VizeKebabCase<Tail, `${Acc}${Head}`> : __VizeKebabCase<Tail, `${Acc}-${Lowercase<Head>}`> : `${Acc}${S}`;
52
+ type __VizeKebabProps<T> = { [K in keyof T & string as __VizeKebabCase<K>]: T[K] };
53
+
54
+ // @ts-ignore TS2694/TS2307: a `vue` without `NativeElements` must degrade native prop checks to unchecked, never error. See virtual_ts/expressions/native_props.rs.
55
+ type __VizeNativeElements = import('vue').NativeElements;
56
+ type __VizeNativeElement<Tag extends PropertyKey> = Tag extends keyof __VizeNativeElements ? __VizeNativeElements[Tag] : unknown;
57
+ type __VizeNativeElementProp<Element, Prop extends PropertyKey> = Prop extends keyof Element ? Element[Prop] : unknown;
58
+ function __vizeNativeElementProp<__Tag extends PropertyKey, __Prop extends PropertyKey>(value: __VizeNativeElementProp<__VizeNativeElement<__Tag>, __Prop>): void;
59
+
60
+ type __VizeComponentAttrCamel<S extends string> = S extends `${infer __H}-${infer __T}` ? `${__H}${Capitalize<__VizeComponentAttrCamel<__T>>}` : S;
61
+ type __VizeComponentNativeAttrNames = { [K in keyof __VizeNativeElements & string]: keyof __VizeNativeElements[K] }[keyof __VizeNativeElements & string] & string;
62
+ type __VizeComponentGlobalHtmlAttrs = __VizeIsAny<__VizeNativeElements> extends true ? {} : { [K in __VizeComponentNativeAttrNames as K | __VizeComponentAttrCamel<K>]?: unknown } & { [K in `data-${string}` | `data${Capitalize<string>}`]?: unknown };
63
+ function __vizeComponentGlobalHtmlAttrs(value: __VizeComponentGlobalHtmlAttrs): void;
64
+
65
+ function __vForList<const T>(source: T): T extends number ? [item: number, key: number][] : T extends string ? [item: string, key: number][] : T extends readonly any[] ? (T extends readonly (infer U)[] ? [item: U, key: number] : never)[] : T extends Iterable<any> ? (T extends Iterable<infer U> ? [item: U, key: number] : never)[] : [item: T[keyof T], key: keyof T extends string ? keyof T : `${keyof T & (string | number)}`, index: number][];
66
+
67
+ type __VizeDirectiveHook<D, H = Extract<D[keyof D & ('created' | 'beforeMount' | 'mounted' | 'beforeUpdate' | 'updated' | 'beforeUnmount' | 'unmounted')], (...args: any[]) => any>> = D extends (...args: any[]) => any ? D : [H] extends [never] ? (el: unknown, binding: { value?: unknown; arg?: unknown; modifiers?: unknown }, ...args: any[]) => void : H;
68
+ type __VizeDirectiveCall<H> = H extends (...args: any[]) => any ? Parameters<H>['length'] extends 0 | 1 ? (el: unknown, binding: { value?: unknown; arg?: unknown; modifiers?: unknown }) => void : H : never;
69
+ function __vizeDirective<D>(directive: D): __VizeDirectiveCall<__VizeDirectiveHook<D>>;
70
+ // @ts-ignore TS2694/TS2307: a `vue` without `GlobalDirectives` must degrade registered directives to unchecked, never error.
71
+ type __VizeGlobalDirectives = import('vue').GlobalDirectives;
72
+ // @ts-ignore TS2694/TS2307: a `vue` without `Directive` must degrade registered directives to unchecked, never error.
73
+ type __VizeOwnDirectives<D> = D extends infer L & Record<string, import('vue').Directive> ? L : D;
74
+ type __VizeLocalDirectives<C> = C extends { directives?: infer D } ? { [K in keyof __VizeOwnDirectives<NonNullable<D>> & string as string extends K ? never : `v${Capitalize<K>}`]: __VizeOwnDirectives<NonNullable<D>>[K] } : {};
75
+ function __vizeRegisteredDirective<C, K extends string>(): K extends keyof __VizeLocalDirectives<C> ? __VizeLocalDirectives<C>[K] : K extends keyof __VizeGlobalDirectives ? __VizeGlobalDirectives[K] : unknown;
76
+ function __vizeVaporDirective<D>(directive: D): D extends (...args: any[]) => any ? D : (node: unknown, value?: () => unknown, argument?: unknown, modifiers?: unknown) => void;
77
+ const __vizeDirectiveBindingRest: { instance: null; oldValue: null; modifiers: any; dir: any };
78
+ function __vizeDirectiveTail<F extends (...args: any[]) => any>(hook: F): 4 extends Parameters<F>['length'] ? [never, never] : 3 extends Parameters<F>['length'] ? [never] : [];
79
+
80
+ type __VizeOverloadProps<TOverload> = Pick<TOverload, keyof TOverload>;
81
+ type __VizeOverloadUnionRecursive<TOverload, TPartialOverload = unknown, TDepth extends unknown[] = []> = TDepth['length'] extends 32 ? never : TOverload extends (...args: infer TArgs) => infer TReturn ? TPartialOverload extends TOverload ? never : __VizeOverloadUnionRecursive<TPartialOverload & TOverload, TPartialOverload & ((...args: TArgs) => TReturn) & __VizeOverloadProps<TOverload>, [...TDepth, unknown]> | ((...args: TArgs) => TReturn) : never;
82
+ type __VizeOverloadUnion<TOverload extends (...args: any[]) => any> = Exclude<__VizeOverloadUnionRecursive<(() => never) & TOverload>, TOverload extends () => never ? never : () => never>;
83
+ type __VizeOverloadParameters<T extends (...args: any[]) => any> = Parameters<__VizeOverloadUnion<T>>;
84
+ type __VizeIsStringLiteral<T> = T extends string ? string extends T ? false : true : false;
85
+ type __VizeParametersToFns<T extends any[]> = string extends T[0] ? { [K in string]: (...args: T extends [e: any, ...args: infer P] ? P : any[]) => any } : { [K in T[0]]: __VizeIsStringLiteral<K> extends true ? (...args: T extends [e: infer E, ...args: infer P] ? K extends E ? P : never : never) => any : never };
86
+ type __EmitOptions<T, S = __EmitShape<T>> = { [K in keyof S as K extends string ? K : never]: (...args: __EmitArgs<S, K>) => any } & (__EmitShape<T> extends (...args: any[]) => any ? __VizeParametersToFns<__VizeOverloadParameters<__EmitShape<T>>> : {});
87
+ type __VizeCamelize<S extends string> = S extends `${infer Head}-${infer Tail}` ? `${Head}${Capitalize<__VizeCamelize<Tail>>}` : S;
88
+ type __VizeHandlerKey<K extends string> = `on${Capitalize<__VizeCamelize<K>>}`;
89
+
90
+ // Compiler-macro signatures (aliased inside each module's __setup() scope)
91
+ function __vize_defineProps<_T = unknown>(): __DefineProps<__LooseRequired<_T>, Extract<__VizeBooleanKey<_T>, keyof __LooseRequired<_T>>>;
92
+ function __vize_defineProps<const _T extends readonly string[]>(_props: _T): { [K in _T[number]]?: any };
93
+ function __vize_defineProps<const _T extends Record<string, any>>(_props: _T): __RuntimePropShape<_T>;
94
+ function __vize_defineEmits<_T = unknown>(): __EmitFn<_T>;
95
+ function __vize_defineEmits<const _T extends readonly string[]>(_events: _T): (event: _T[number], ...args: any[]) => void;
96
+ function __vize_defineEmits<const _T extends Record<string, any>>(_events: _T): __EmitFn<_T>;
97
+ function __vize_defineExpose<_T = unknown>(_exposed?: _T): void;
98
+ const __vize_defineModel: typeof import('vue') extends { defineModel: infer __Macro } ? __Macro : never;
99
+ function __vize_defineSlots<_T = unknown>(): _T;
100
+ function __vize_withDefaults<_T, _BKeys extends keyof _T, _D extends __WithDefaultsArgs<_T>>(_props: __DefineProps<_T, _BKeys>, _defaults: _D): __WithDefaultsResult<_T, _D, _BKeys>;
101
+ function __vize_useTemplateRef<_T = any>(_key: string): __ShallowRef<_T | null>;
102
+
103
+ // Adapted from vuejs/language-tools e68d41bfef1770f8428f92097abe959b57de62d2.
104
+ // MIT license; see pattern_matching.LICENSE.
105
+ // Kept as a checked declaration file, shared once per TypeScript program.
106
+ /*
107
+ MIT License
108
+
109
+ Copyright (c) 2021-present Johnson Chu
110
+
111
+ Permission is hereby granted, free of charge, to any person obtaining a copy
112
+ of this software and associated documentation files (the "Software"), to deal
113
+ in the Software without restriction, including without limitation the rights
114
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
115
+ copies of the Software, and to permit persons to whom the Software is
116
+ furnished to do so, subject to the following conditions:
117
+
118
+ The above copyright notice and this permission notice shall be included in all
119
+ copies or substantial portions of the Software.
120
+
121
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
122
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
123
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
124
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
125
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
126
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
127
+ SOFTWARE.
128
+ */
129
+ namespace __VizePatterns {
130
+ type Reachable<T> = [T] extends [never] ? { "Unreachable v-when": never } : true;
131
+ /**
132
+ * RFC 823 pattern types. Match narrows an arm; Subtract keeps the values left
133
+ * for later arms. Objects split by property and arrays by head/tail, so nested
134
+ * unions do not need their entire Cartesian product expanded up front.
135
+ */
136
+ type Pattern =
137
+ | ["any"]
138
+ | ["literal" | "value", unknown]
139
+ | ["or", Pattern[]]
140
+ | ["object", [PropertyKey, Pattern][]]
141
+ | ["array", Pattern[], boolean];
142
+
143
+ type IsAny<T> = 0 extends 1 & T ? true : false;
144
+
145
+ // Vue can unwrap unknown to {}. Keep that space conservative too.
146
+ type IsUnknownLike<T> = [keyof T] extends [never] ? ({} extends T ? true : false) : false;
147
+
148
+ type IsUnion<T, C = T> = T extends C ? ([C] extends [T] ? false : true) : never;
149
+
150
+ // A runtime value with a union type matches one member, so it cannot cover the whole union.
151
+ type IsSingleton<T> =
152
+ IsAny<T> extends true
153
+ ? false
154
+ : true extends IsUnion<T>
155
+ ? false
156
+ : T extends string | number | bigint | boolean | null | undefined
157
+ ? string extends T
158
+ ? false
159
+ : number extends T
160
+ ? false
161
+ : bigint extends T
162
+ ? false
163
+ : boolean extends T
164
+ ? false
165
+ : true
166
+ : false;
167
+
168
+ type Simplify<T> = { [K in keyof T]: T[K] };
169
+
170
+ // Remove optionality before substituting V. A homomorphic -? mapping would
171
+ // strip undefined from V when exactOptionalPropertyTypes is disabled.
172
+ type PresentProperty<T, K extends keyof T, V> = {
173
+ [Q in keyof Required<Pick<T, K>>]: V;
174
+ };
175
+
176
+ // Retain the original type when refinement changes nothing, including its readonly modifiers.
177
+ type ReplaceProperty<T, K extends keyof T, V> = [V] extends [never]
178
+ ? never
179
+ : {} extends Pick<T, K>
180
+ ? Simplify<Omit<T, K> & PresentProperty<T, K, V>>
181
+ : [T[K]] extends [V]
182
+ ? [V] extends [T[K]]
183
+ ? T
184
+ : Simplify<Omit<T, K> & PresentProperty<T, K, V>>
185
+ : Simplify<Omit<T, K> & PresentProperty<T, K, V>>;
186
+
187
+ // Turn the pattern descriptor emitted by vMatch.ts into a positive type constraint.
188
+ type PatternType<P> = P extends ["any"]
189
+ ? unknown
190
+ : P extends ["literal" | "value", infer V]
191
+ ? V
192
+ : P extends ["or", infer A extends unknown[]]
193
+ ? PatternType<A[number]>
194
+ : P extends ["object", infer A extends [PropertyKey, unknown][]]
195
+ ? { [Q in A[number] as Q[0]]: PatternType<Q[1]> }
196
+ : P extends ["array", infer A extends unknown[], infer R]
197
+ ? [...{ [I in keyof A]: PatternType<A[I]> }, ...(R extends true ? unknown[] : [])]
198
+ : never;
199
+
200
+ type Match<T, P extends Pattern> = MatchImpl<T, P>;
201
+ type Subtract<T, P extends Pattern> = SubtractImpl<T, P>;
202
+
203
+ // Narrow one union member at a time. Object patterns constrain only their listed properties.
204
+ type MatchImpl<T, P> = P extends ["any"]
205
+ ? T
206
+ : IsAny<T> extends true
207
+ ? PatternType<P>
208
+ : unknown extends T
209
+ ? PatternType<P>
210
+ : IsUnknownLike<T> extends true
211
+ ? T & PatternType<P>
212
+ : T extends unknown
213
+ ? P extends ["literal" | "value", infer V]
214
+ ? T & V
215
+ : P extends ["or", infer A extends unknown[]]
216
+ ? MatchImpl<T, A[number]>
217
+ : P extends ["object", infer A extends [PropertyKey, unknown][]]
218
+ ? T extends null | undefined
219
+ ? never
220
+ : MatchObject<T, A>
221
+ : P extends ["array", infer A extends unknown[], infer R]
222
+ ? T extends readonly unknown[]
223
+ ? T extends unknown[]
224
+ ? MatchArray<T, A, R>
225
+ : Readonly<MatchArray<T, A, R>>
226
+ : never
227
+ : never
228
+ : never;
229
+
230
+ // Presence does not remove undefined from an optional property value.
231
+ type RequireProperty<T, K extends keyof T> =
232
+ {} extends Pick<T, K> ? Simplify<Omit<T, K> & PresentProperty<T, K, T[K]>> : T;
233
+
234
+ type MatchObject<T, A> = A extends [infer H extends [PropertyKey, unknown], ...infer R]
235
+ ? H[0] extends keyof T
236
+ ? H[1] extends ["any"]
237
+ ? MatchObject<RequireProperty<T, H[0]>, R>
238
+ : MatchObject<ReplaceProperty<T, H[0], MatchImpl<T[H[0]], H[1]>>, R>
239
+ : MatchObject<T & { [K in H[0]]: PatternType<H[1]> }, R>
240
+ : T;
241
+
242
+ type MatchArray<T extends readonly unknown[], A extends unknown[], R> = A extends [
243
+ infer H,
244
+ ...infer Tail,
245
+ ]
246
+ ? T extends readonly []
247
+ ? never
248
+ : T extends readonly [infer V, ...infer Rest]
249
+ ? Prepend<MatchImpl<V, H>, MatchArray<Rest, Tail, R>>
250
+ : T extends readonly [(infer V)?, ...infer Rest]
251
+ ? Prepend<MatchImpl<T[0], H>, MatchArray<Rest, Tail, R>>
252
+ : never
253
+ : R extends true
254
+ ? T
255
+ : [] extends T
256
+ ? []
257
+ : never;
258
+
259
+ type Prepend<H, T> = [H] extends [never]
260
+ ? never
261
+ : T extends readonly unknown[]
262
+ ? [H, ...T]
263
+ : never;
264
+
265
+ // Only unguarded arms call this helper. Unknown and open primitive spaces stay uncovered.
266
+ type SubtractImpl<T, P> = [T] extends [never]
267
+ ? never
268
+ : P extends ["any"]
269
+ ? never
270
+ : IsAny<T> extends true
271
+ ? T
272
+ : unknown extends T
273
+ ? T
274
+ : IsUnknownLike<T> extends true
275
+ ? T
276
+ : string extends T
277
+ ? T
278
+ : number extends T
279
+ ? T
280
+ : bigint extends T
281
+ ? T
282
+ : P extends ["or", infer A extends unknown[]]
283
+ ? SubtractAlternatives<T, A>
284
+ : T extends unknown
285
+ ? P extends ["literal", infer V]
286
+ ? Exclude<T, V>
287
+ : P extends ["value", infer V]
288
+ ? IsSingleton<V> extends true
289
+ ? Exclude<T, V>
290
+ : T
291
+ : P extends ["object", infer A extends [PropertyKey, unknown][]]
292
+ ? T extends null | undefined
293
+ ? T
294
+ : SubtractObject<T, A>
295
+ : P extends ["array", infer A extends unknown[], infer R]
296
+ ? T extends readonly unknown[]
297
+ ? T extends unknown[]
298
+ ? SubtractArray<T, A, R>
299
+ : Readonly<SubtractArray<T, A, R>>
300
+ : T
301
+ : T
302
+ : never;
303
+
304
+ type SubtractAlternatives<T, A> = A extends [infer H, ...infer R]
305
+ ? SubtractAlternatives<SubtractImpl<T, H>, R>
306
+ : T;
307
+
308
+ // The remaining object space has three cases: the key is absent, its pattern fails,
309
+ // or its pattern matches and a later property fails.
310
+ type SubtractObject<T, A> = [T] extends [never]
311
+ ? never
312
+ : A extends [infer H extends [PropertyKey, unknown], ...infer R]
313
+ ? H[0] extends keyof T
314
+ ? H[1] extends ["any"]
315
+ ?
316
+ | ({} extends Pick<T, H[0]> ? Omit<T, H[0]> & { [K in H[0]]?: never } : never)
317
+ | SubtractObject<RequireProperty<T, H[0]>, R>
318
+ :
319
+ | ({} extends Pick<T, H[0]> ? Omit<T, H[0]> & { [K in H[0]]?: never } : never)
320
+ | ReplaceProperty<T, H[0], SubtractImpl<T[H[0]], H[1]>>
321
+ | SubtractObject<ReplaceProperty<T, H[0], MatchImpl<T[H[0]], H[1]>>, R>
322
+ : T
323
+ : never;
324
+
325
+ // Split a tuple or array into its head and tail. Exact-length patterns also leave longer arrays.
326
+ type SubtractArray<T extends readonly unknown[], A extends unknown[], R> = A extends [
327
+ infer H,
328
+ ...infer Tail,
329
+ ]
330
+ ? T extends readonly []
331
+ ? T
332
+ : T extends readonly [infer V, ...infer Rest]
333
+ ? Prepend<SubtractImpl<V, H>, Rest> | Prepend<MatchImpl<V, H>, SubtractArray<Rest, Tail, R>>
334
+ : T extends readonly [(infer V)?, ...infer Rest]
335
+ ?
336
+ | []
337
+ | Prepend<SubtractImpl<T[0], H>, Rest>
338
+ | Prepend<MatchImpl<T[0], H>, SubtractArray<Rest, Tail, R>>
339
+ : T
340
+ : R extends true
341
+ ? never
342
+ : T extends readonly []
343
+ ? never
344
+ : T extends readonly [unknown, ...unknown[]]
345
+ ? T
346
+ : T extends readonly [(infer V)?, ...infer Rest]
347
+ ? [T[0], ...Rest]
348
+ : never;
349
+
350
+ // Diagnostic examples must be valid pattern syntax. Fall back to _ when a literal needs escaping.
351
+ type FormatPattern<T> = T extends string
352
+ ? string extends T
353
+ ? "_"
354
+ : T extends `${string}${"'" | '"' | "\\" | "\n" | "\r"}${string}`
355
+ ? "_"
356
+ : `'${T}'`
357
+ : T extends bigint
358
+ ? bigint extends T
359
+ ? "_"
360
+ : `${T}n`
361
+ : T extends number
362
+ ? number extends T
363
+ ? "_"
364
+ : `${T}`
365
+ : T extends boolean | null | undefined
366
+ ? `${T}`
367
+ : T extends readonly unknown[]
368
+ ? `[${FormatTuple<T>}]`
369
+ : "_";
370
+
371
+ type FormatTuple<T extends readonly unknown[]> = T extends readonly []
372
+ ? ""
373
+ : T extends readonly [infer H, ...infer R]
374
+ ? `${FormatPattern<H>}${R extends [] ? "" : `, ${FormatTuple<R>}`}`
375
+ : "...";
376
+
377
+ type MissingPatternMessage<T> =
378
+ IsAny<T> extends true
379
+ ? 'Add an unguarded v-when="_" to prove coverage.'
380
+ : T extends string
381
+ ? string extends T
382
+ ? "An open string requires an unguarded catch-all."
383
+ : T extends `${string}${"'" | '"' | "\\" | "\n" | "\r"}${string}`
384
+ ? 'Add an unguarded v-when="_".'
385
+ : `Missing v-when="'${T}'".`
386
+ : T extends bigint
387
+ ? bigint extends T
388
+ ? "An open bigint requires an unguarded catch-all."
389
+ : `Missing v-when="${T}n".`
390
+ : T extends number
391
+ ? number extends T
392
+ ? "An open number requires an unguarded catch-all."
393
+ : `Missing v-when="${T}".`
394
+ : T extends boolean | null | undefined
395
+ ? `Missing v-when="${T}".`
396
+ : T extends readonly unknown[]
397
+ ? `Missing v-when="[${FormatTuple<T>}]".`
398
+ : 'Coverage cannot be proven. Add missing structural arms or an unguarded v-when="_".';
399
+
400
+ // A nonempty remaining space produces an error mapped to the v-match subject.
401
+ type Exhaustiveness<T> = [T] extends [never]
402
+ ? true
403
+ : {
404
+ "Non-exhaustive v-match": T;
405
+ } & { [K in MissingPatternMessage<T>]: never };
406
+ }
407
+
408
+ type __VizeRequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
409
+ type __VizeDomListenerProps = { [K in keyof GlobalEventHandlersEventMap as K extends string ? `on${Capitalize<K>}` : never]?: (event: GlobalEventHandlersEventMap[K]) => void };
410
+ type __VizeFallthroughAttrs<Owned = {}> = { class?: unknown; style?: unknown } & { [K in `data-${string}` | `data${Capitalize<string>}`]?: unknown } & { [K in `aria-${string}` | `aria${Capitalize<string>}`]?: unknown } & Omit<__VizeDomListenerProps, keyof Owned>;
411
+ // Match Vue's public prop contract, including runtime-core module augmentations.
412
+ type __VizePublicComponentInputProps = import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
413
+ type __VizeComponentMetadataKeys<T> = __VizeIsAny<T> extends true ? never : T extends unknown ? keyof NonNullable<T> : never;
414
+ type __VizeComponentOwnKeys<P = {}, E = {}> = keyof __VizePublicComponentInputProps | __VizeComponentMetadataKeys<P> | __VizeComponentMetadataKeys<E>;
415
+ type __VizeUnownedComponentAttrs<F, P = {}, E = {}> = __VizeIsAny<F> extends true ? F : unknown extends F ? F : F extends unknown ? F extends null | undefined ? F : { [K in keyof F as K extends __VizeComponentOwnKeys<P, E> ? never : K]: F[K] } : never;
416
+ type __VizePrettify<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
417
+ type __VizeComponentFallthroughSurface<C> = (C extends { new (...args: any[]): { $props: infer __P } } ? __P : C extends (props: infer __P, ...args: any[]) => any ? __P : Record<string, unknown>) & (C extends { readonly __vizeFallthroughProps?: infer __F } ? __VizeIsAny<__F> extends true ? {} : NonNullable<__F> : {});
418
+ type __VizeComponentFallthroughProps<C> = { [K in keyof __VizeComponentFallthroughSurface<C>]: __VizeComponentFallthroughSurface<C>[K] };
419
+ type __VizeComponentInputProps<T, Declared = {}> = T extends unknown ? Partial<T> & Partial<__VizeKebabProps<T>> & Declared & __VizeFallthroughAttrs<T & Declared> & __VizePublicComponentInputProps : never;
420
+ type __VizeMissingRequiredInputKeys<T, Authored, K extends __VizeRequiredKeys<T> & string = __VizeRequiredKeys<T> & string> = K extends unknown ? K extends keyof Authored ? never : __VizeKebabCase<K> extends keyof Authored ? never : K : never;
421
+ type __VizeIsPropKeyUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : false;
422
+ type __VizeIsSinglePropKey<T> = [T] extends [never] ? false : __VizeIsPropKeyUnion<T> extends true ? false : true;
423
+ type __VizeRelaxedDynamicUnionExtra<T, Declared, Authored, K extends keyof Authored> = [keyof Declared] extends [never] ? __VizeIsSinglePropKey<__VizeRequiredKeys<T>> extends true ? K extends string ? K extends `on${string}` ? false : Authored[K] extends true ? false : true : false : false : false;
424
+ type __VizeExtraInputKeys<T, Declared, Authored, Allowed, K extends keyof Authored = Exclude<keyof Authored, keyof Allowed>> = K extends unknown ? __VizeRelaxedDynamicUnionExtra<T, Declared, Authored, K> extends true ? never : K : never;
425
+ type __VizeComponentMissingInputGuard<T, Authored> = T extends unknown ? [__VizeMissingRequiredInputKeys<T, Authored>] extends [never] ? {} : { readonly __vizeInvalidComponentProps: { readonly missing: __VizeMissingRequiredInputKeys<T, Authored>; readonly extra: never; } } : never;
426
+ type __VizeComponentInputGuardFor<T, Declared, Authored, Allowed> = [__VizeMissingRequiredInputKeys<T, Authored> | __VizeExtraInputKeys<T, Declared, Authored, Allowed>] extends [never] ? {} : { readonly __vizeInvalidComponentProps: { readonly missing: __VizeMissingRequiredInputKeys<T, Authored>; readonly extra: __VizeExtraInputKeys<T, Declared, Authored, Allowed>; } };
427
+ type __VizeComponentInputGuard<T, Declared, Authored> = __VizeUsePublicInstance<Authored> extends true ? {} : T extends unknown ? __VizeComponentInputGuardFor<T, Declared, Authored, __VizeComponentInputProps<T, Declared>> : never;
428
+ type __VizeComponentInputFor<T, Declared, Authored, Allowed> = Allowed & __VizeComponentInputGuardFor<T, Declared, Authored, Allowed>;
429
+ type __VizeComponentInput<T, Declared, Authored> = __VizeUsePublicInstance<Authored> extends true ? __VizeComponentInputProps<T, Declared> : T extends unknown ? __VizeComponentInputFor<T, Declared, Authored, __VizeComponentInputProps<T, Declared>> : never;
430
+ type __VizeAuthoredKeyWitness<T> = { [K in keyof T]: unknown };
431
+ type __VizeIsUnknown<T> = unknown extends T ? [keyof T] extends [never] ? true : false : false;
432
+ type __VizeUsePublicInstance<T> = __VizeIsAny<T> extends true ? true : __VizeIsUnknown<T>;
433
+ type __VizeLiteralKeys<T> = keyof { [K in keyof T as K extends string ? string extends K ? never : K extends `$${infer R}` ? string extends R ? never : K : K : number extends K ? never : symbol extends K ? never : K]: unknown };
434
+ type __VizeReplaceComponentProps<T, P> = Omit<T, '$props'> & Pick<T, Exclude<__VizeLiteralKeys<T>, '$props'>> & { $props: P };
435
+ type __VizePublicEmit<T, S = __EmitShape<T>, K extends keyof S & string = keyof S & string> = S extends (...args: any[]) => any ? S : [K] extends [never] ? (event: string, ...args: any[]) => void : __EmitFn<T>;
436
+ type __VizePublicSlots<T> = [keyof T] extends [never] ? import('vue').ComponentPublicInstance['$slots'] : T;
437
+ // @ts-ignore TS2694/TS2307: a `vue` without `ComponentPublicInstance` must degrade component public extras to unchecked, never error.
438
+ type __VizeComponentPublicBase = Omit<import('vue').ComponentPublicInstance, '$props' | '$emit' | '$slots'>;
439
+ }
440
+
441
+ // Template-ref widening. Hoisted-only, deliberately absent from the per-file
442
+ // preamble: a module-scope copy is dead code (TS6196) in every component whose
443
+ // template scope emits no __U, and only generated template scopes use it.
444
+ type __VizeIsUnion<T, __U = T> = T extends unknown ? ([__U] extends [T] ? false : true) : false;
445
+ export type __VizeWidenTemplateRef<T> = __VizeIsAny<T> extends true ? T : __VizeIsUnion<T> extends true ? T : T extends string ? string extends T ? string : T : T extends number ? number extends T ? number : T : T extends boolean ? boolean extends T ? boolean : T : T;
446
+
447
+
448
+ // Emit-overload helpers (consumed by the per-file __EmitProps alias)
449
+
450
+ export type __VizeSlotHostSlots<C> = C extends { readonly __vizeSlots?: infer __S } ? NonNullable<__S> : C extends { new (): { $slots: infer __S } } ? __S : C extends (props: any, context: infer __Ctx, ...args: any[]) => any ? NonNullable<__Ctx> extends { slots: infer __S } ? __S : any : unknown;
451
+ declare function __vizeFunctionalSlots<P, C, R>(component: (props: P, context: C, ...args: any[]) => R): (props: P) => "__ctx" extends keyof R ? NonNullable<R["__ctx"]> extends { slots: infer S } ? S : any : NonNullable<C> extends { slots: infer S } ? S : any;
452
+ type __VizeNativeSlotsFactory<C> = C extends new (...args: any[]) => any ? (component: C) => (props: any) => __VizeSlotHostSlots<C> : C extends (...args: any[]) => any ? typeof __vizeFunctionalSlots : (component: C) => (props: any) => __VizeSlotHostSlots<C>;
453
+ export type __VizeSlotsFactory<C> = __VizeIsAny<C> extends true ? (component: C) => (props: any) => any : C extends { __vizeResolveSlots?: infer F } ? F extends (...args: any[]) => any ? (component: C) => F : __VizeNativeSlotsFactory<C> : C extends { readonly __vizeComponentMarker: true } ? (component: C) => (props: any) => __VizeSlotHostSlots<C> : __VizeNativeSlotsFactory<C>;
454
+ type __VizeHasSlotResolver<C> = C extends { __vizeResolveSlots?: infer F } ? F extends (...args: any[]) => any ? true : false : false;
455
+ type __VizeDirectSlotConstructor<C> = __VizeIsAny<C> extends true ? never : __VizeHasSlotResolver<C> extends true ? never : C extends { readonly __vizeComponentMarker: true } ? never : C extends new (...args: any[]) => { $slots: any } ? C : never;
456
+ export type __VizeSlotConstructor<C> = [__VizeDirectSlotConstructor<C>] extends [never] ? new (props: any, ...args: any[]) => { $slots: never } : __VizeDirectSlotConstructor<C>;
457
+ export type __VizeSlotConstructorArgs<C> = C extends new (props: any, ...args: infer A) => any ? { [K in keyof A]: any } : [];
458
+ export type __VizeSlotHostSelector<C> = [__VizeDirectSlotConstructor<C>] extends [never] ? <S>(instance: unknown, slots: S) => S : <I extends { $slots: any }>(instance: I, slots: unknown) => I["$slots"];
459
+
460
+ // @ts-ignore The unchecked payload of an untyped host: an error type, never reported.
461
+ type __VizeSilentAny = {}["__vizeSilentAny"];
462
+ type __VizeNamedSlotPayload<S, N> = { [K in keyof S & N]-?: NonNullable<S[K]> extends (props: infer P, ...args: any[]) => any ? P : never }[keyof S & N] extends infer P ? ([P] extends [never] ? any : P) : any;
463
+ export type __VizeSlotPayload<S, N> = __VizeIsAny<S> extends true ? __VizeSilentAny : string extends N ? string extends keyof S ? __VizeNamedSlotPayload<S, N> : any : __VizeNamedSlotPayload<S, N>;
464
+
465
+ export type __EmitProps<T> = { [K in keyof __EmitOptions<T> & string as __VizeHandlerKey<K> | `on${Capitalize<K>}`]?: __EmitOptions<T>[K] };
466
+
467
+ type __VizeEmitRequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
468
+ type __VizeEmitRequiredFields<T> = T extends unknown ? Pick<T, __VizeEmitRequiredKeys<T>> : never;
469
+ type __VizeEmitFiniteFields<T> = { [K in keyof T as {} extends Record<K, unknown> ? never : K]: T[K] };
470
+ type __VizeEmitFallthrough<F> = __VizeIsAny<F> extends true ? {} : [NonNullable<F>] extends [never] ? {} : NonNullable<F>;
471
+ export type __VizeEmitOwnedKeys<C> = __VizeComponentOwnKeys<C extends { readonly __vizeRawProps?: infer P } ? P : {}, C extends { readonly __vizeEmitProps?: infer E } ? E : {}>;
472
+ type __VizeEmitInput<P, F, O extends PropertyKey, A> = P extends unknown ? F extends unknown ? { [K in keyof A]: K extends O ? K extends keyof P ? P[K] : never : K extends keyof F ? F[K] : K extends keyof P ? P[K] : unknown } & __VizeEmitRequiredFields<P> & __VizeEmitRequiredFields<Omit<__VizeEmitFiniteFields<F>, O>> : never : never;
473
+ declare function __vizeConstructorEmitProps<P, E>(component: new (props: P, ...args: any[]) => { $emit: E }): (props: P) => __EmitProps<E>;
474
+ type __VizeConstructorEmitPropsFactory<F, O extends PropertyKey> = <P, E>(component: new (props: P, ...args: any[]) => { $emit: E }) => <A>(props: __VizeEmitInput<P, __VizeEmitFallthrough<F>, O, A>) => __EmitProps<E>;
475
+ type __VizeNativeEmitPropsFactory<C> = C extends new (...args: any[]) => { $emit: any } ? C extends { readonly __vizeComponentMarker: true } ? __VizeConstructorEmitPropsFactory<C extends { readonly __vizeFallthroughProps?: infer F } ? F : {}, __VizeEmitOwnedKeys<C>> : typeof __vizeConstructorEmitProps : (component: C) => (props: any) => {};
476
+ export type __VizeEmitPropsFactory<C> = __VizeIsAny<C> extends true ? (component: C) => (props: any) => {} : C extends { __vizeResolveEmitProps?: infer F } ? F extends (...args: any[]) => any ? (component: C) => F : __VizeNativeEmitPropsFactory<C> : C extends { __vizeResolveProps?: infer F } ? F extends (...args: any[]) => any ? (component: C) => F : __VizeNativeEmitPropsFactory<C> : __VizeNativeEmitPropsFactory<C>;
477
+
478
+ // Component usage helpers shared by every generated module in a batch project.
479
+ export type IsAny<T> = __VizeIsAny<T>;
480
+ export type ComponentGlobalHtmlAttrs = __VizeComponentGlobalHtmlAttrs;
481
+ export type __VizeComponentNavigationProps<P> = __VizeIsAny<P> extends true ? Record<string, unknown> : unknown extends P ? {} : P;
482
+ export type __VizeEmitListeners<C> = C extends { __vizeEmitProps?: infer __E } ? __VizeIsAny<__E> extends true ? {} : NonNullable<__E> : {};
483
+ export type __VizeIsGeneratedComponent<C> = C extends { readonly __vizeComponentMarker: true } ? true : false;
484
+ export type __VizeHasFallthroughProps<C> = __VizeIsGeneratedComponent<C> extends true ? C extends { readonly __vizeHasFallthroughProps: true } ? true : false : false;
485
+ export type __VizeFallthroughProps<C> = __VizeHasFallthroughProps<C> extends true ? C extends { readonly __vizeFallthroughProps?: infer __F } ? __VizeIsAny<__F> extends true ? {} : NonNullable<__F> : {} : {};
486
+ export type __VizeRequiredFallthroughProps<C, __F = __VizeFallthroughProps<C>, __K = __VizeRequiredKeys<__F>> = [__K] extends [never] ? {} : { [K in keyof __F as K extends __K ? K : never]: __F[K] };
487
+ type __VizeComponentCheckProps<P, T> = { readonly [K in keyof P]: P[K] } & T;
488
+ type __VizePublicProps<C> = C extends abstract new (...args: any[]) => infer __I ? __VizeIsAny<__I> extends true ? Record<string, unknown> : __I extends { $props: infer __P } ? __P : {} : C extends (props: infer __P, ...args: any[]) => any ? __P : {};
489
+ type __VizeInstanceRawProps<C> = C extends { new (): { readonly __vizeRawProps?: infer __P } } ? __VizeIsAny<__P> extends true ? __VizePublicProps<C> : __P : __VizePublicProps<C>;
490
+ type __VizeStaticRawProps<C> = C extends { readonly __vizeRawProps?: infer __P } ? __VizeIsAny<__P> extends true ? __VizePublicProps<C> : __P : __VizePublicProps<C>;
491
+ type __VizeHasInstanceRawProps<C> = __VizeIsGeneratedComponent<C> extends true ? C extends { new (): { readonly __vizeRawProps?: infer __P } } ? __VizeIsAny<__P> extends true ? false : true : false : false;
492
+ type __VizeHasStaticRawProps<C> = __VizeIsGeneratedComponent<C> extends true ? C extends { readonly __vizeRawProps?: infer __P } ? __VizeIsAny<__P> extends true ? false : true : false : false;
493
+ export type __VizeComponentRawProps<C, __P = __VizeHasInstanceRawProps<C> extends true ? __VizeInstanceRawProps<C> : __VizeHasStaticRawProps<C> extends true ? __VizeStaticRawProps<C> : __VizePublicProps<C>> = unknown extends __P ? Record<string, unknown> : __P;
494
+ type __VizeHasRawProps<C> = __VizeHasInstanceRawProps<C> extends true ? true : __VizeHasStaticRawProps<C>;
495
+ export type __VizeFallthroughValue<C, K extends PropertyKey> = __VizeHasFallthroughProps<C> extends true ? C extends { readonly __vizeFallthroughProps?: infer __F } ? __VizeIsAny<__F> extends true ? unknown : __VizePropValue<NonNullable<__F>, K, unknown> : unknown : unknown;
496
+ type __VizeEventName<K extends string> = K extends `on${infer E}` ? Uncapitalize<E> | __VizeKebabCase<Uncapitalize<E>> : never;
497
+ type __VizeKebabEventAliases<E> = { [K in keyof E & string as __VizeKebabCase<K> extends K ? never : __VizeKebabCase<K>]: E[K] };
498
+ export type __VizeComponentEvents<C> = C extends { __vizeRawEmits?: infer __R; __vizeEventMap?: infer __E } ? [keyof NonNullable<__R>] extends [never] ? NonNullable<__E> : NonNullable<__R> & __VizeKebabEventAliases<NonNullable<__R>> : { [K in keyof (C extends { new (...args: any[]): { $props: infer __P } } ? __P : C extends (props: infer __P, ...args: any[]) => any ? __P : {}) & string as __VizeEventName<K>]: (C extends { new (...args: any[]): { $props: infer __P } } ? __P : C extends (props: infer __P, ...args: any[]) => any ? __P : {})[K] };
499
+ export type __VizeIsLibraryGenericExport<C> = C extends { __vizeCheck: any } | { readonly __vizeComponentMarker: true } ? false : C extends (...args: any[]) => infer __R ? 0 extends (1 & __R) ? false : '__ctx' extends keyof __R ? true : false : false;
500
+ export type __VizePropChecker<C, P, T> = __VizeIsAny<C> extends true ? (props: { readonly [K in keyof P]: P[K] } & Record<string, unknown>) => void : C extends { __vizeCheck: infer __F } ? __VizeIsAny<__F> extends true ? (props: __VizeComponentCheckProps<P, T>) => void : unknown extends __F ? (props: __VizeComponentCheckProps<P, T>) => void : __F extends (...args: any[]) => any ? __F : (props: __VizeComponentCheckProps<P, T>) => void : __VizeIsLibraryGenericExport<C> extends true ? C : (props: __VizeComponentCheckProps<P, T>) => void;
501
+ export type __VizePropValue<P, K extends PropertyKey, F = unknown, __V = P extends unknown ? (K extends keyof P ? P[K] : never) : never> = [__V] extends [never] ? F : __V;
502
+ type __VizeInvalidFallthroughSpreadKeys<P, F, A> = { [K in keyof A]-?: K extends keyof P | keyof __VizeKebabProps<P> ? never : K extends keyof F ? __VizeIsAny<A[K]> extends true ? never : A[K] extends F[K] ? never : K extends "id" ? A[K] extends string | number ? never : K : K : never }[keyof A];
503
+ type __VizeFallthroughSpreadGuard<C, P, A, __K = __VizeInvalidFallthroughSpreadKeys<P, __VizeFallthroughProps<C>, A>> = [__K] extends [never] ? unknown : { readonly __vizeInvalidFallthroughSpreadValues: __K };
504
+ export type __VizeFallthroughSpreadChecker<C, P> = <A>(props: A & __VizeFallthroughSpreadGuard<C, P, NoInfer<A>>) => A;
505
+ export type __VizeCallableProp<T> = __VizeIsAny<T> extends true ? T : unknown extends T ? (...args: any[]) => any : T;
506
+ export type __VizePropsResolver<C> = C extends { __vizeResolveProps?: infer __F } ? (__F extends (...args: any[]) => any ? __F : (props: any) => {}) : __VizeIsLibraryGenericExport<C> extends true ? C : (props: any) => {};
507
+ export type __VizeResolvedContextProps = <R>(resolved: R) => R extends { __ctx?: infer __X } ? NonNullable<__X> extends { props: infer __P } ? __P : R : R;
508
+ export type __VizePropsSelector<R> = <A extends Partial<R> & Record<string, unknown>>(props: A) => A;
509
+ type __VizeMissingProp = { readonly __vizeMissingProp: unique symbol };
510
+ type __VizeResolvedPropEntry<R, K extends PropertyKey> = R extends unknown ? K extends keyof R ? { value: R[K] } : __VizeMissingProp : never;
511
+ type __VizeSelectedProps<R, A> = R extends unknown ? A extends Partial<R> ? R : never : never;
512
+ export type __VizeResolvedProp<R, A, K extends PropertyKey, F, __S = __VizeSelectedProps<R, A>, __E = __VizeResolvedPropEntry<__S, K>, __A = __VizeResolvedPropEntry<R, K>, __P = Extract<__E, { value: unknown }>> = [__S] extends [never] ? F : [__P] extends [never] ? [Extract<__A, { value: unknown }>] extends [never] ? F : never : __P extends { value: infer V } ? V : never;
513
+ export type __VizeComponentRefCallback = (ref: any, refs: Record<string, any>) => void;
514
+ export type __VizeStructuralSlots<C> = C extends { readonly __vizeSlots?: infer __S } ? NonNullable<__S> : any;
515
+ type __VizeEmptyVueNavigationSlots<C> = ('__isFragment' | '__isTeleport' | '__isSuspense' | 'slots') extends keyof C ? __VizeIsAny<C[Extract<'__isFragment' | '__isTeleport' | '__isSuspense', keyof C>]> extends true ? any : [NonNullable<C[Extract<'__isFragment' | '__isTeleport' | '__isSuspense', keyof C>]>] extends [never] ? C extends { slots?: infer __S } ? __VizeIsAny<__S> extends true ? any : unknown extends __S ? any : [keyof NonNullable<__S>] extends [never] ? C extends { setup?: (props: infer __P, ...args: any[]) => any } ? string extends keyof __P ? any : {} : {} : any : any : any : any;
516
+ type __VizeNativeNavigationSlots<C> = C extends new (...args: any[]) => { $slots: any } ? __VizeIsAny<InstanceType<C>> extends true ? __VizeEmptyVueNavigationSlots<C> : __VizeIsAny<InstanceType<C>['$slots']> extends true ? any : unknown extends InstanceType<C>['$slots'] ? any : InstanceType<C>['$slots'] : any;
517
+ export type __VizeNavigationSlots<C> = __VizeIsAny<C> extends true ? any : C extends { readonly __vizeSlots?: infer __S } ? __VizeIsAny<__S> extends true ? __S : unknown extends __S ? [keyof NonNullable<__S>] extends [never] ? __VizeNativeNavigationSlots<C> : NonNullable<__S> : NonNullable<__S> : __VizeNativeNavigationSlots<C>;
518
+ type __VizeRequiredSlotKeys<__S> = { [__K in keyof __S]-?: undefined extends __S[__K] ? never : __K }[keyof __S];
519
+ type __VizeMissingRequiredSlots<__S, __P> = Exclude<__VizeRequiredSlotKeys<__S>, keyof __P>;
520
+ export type __VizeRequiredSlots<__S, __P> = __VizeIsAny<__S> extends true ? {} : string extends keyof __S ? {} : [keyof __S] extends [never] ? {} : [__VizeMissingRequiredSlots<__S, __P>] extends [never] ? {} : { readonly __vizeMissingSlots: __VizeMissingRequiredSlots<__S, __P> };
521
+ export type __VizeSlotChildren<__S, __K extends PropertyKey> = __VizeIsAny<__S> extends true ? any : string extends keyof __S ? any : __K extends keyof __S ? ReturnType<Extract<NonNullable<__S[__K]>, (...args: any[]) => any>> : any;
522
+ export type __VizeProvidedSlotChildren<__T extends unknown[]> = __T extends [infer __Only] ? __Only | __T : __T;