vize 0.606.0 → 0.608.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
+ 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[]>;
28
+ type __EmitArgs<T, K extends keyof T> = T[K] extends any[] ? T[K] : any[];
29
+ 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;
30
+ type __RuntimePropValue<T> = T extends abstract new (...args: any[]) => infer V ? V : T extends (...args: any[]) => infer V ? V : never;
31
+ 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>;
32
+ type __RuntimePropCtor<T> = [__RuntimePropCtorInner<T>] extends [never] ? unknown : __RuntimePropCtorInner<T>;
33
+ type __RuntimePropHasBoolean<T> = T extends BooleanConstructor ? true : T extends readonly (infer U)[] ? __RuntimePropHasBoolean<U> : T extends { type: infer U } ? __RuntimePropHasBoolean<U> : false;
34
+ type __RuntimePropResolved<T> = T extends { required: true } ? true : T extends { default: any } ? true : __RuntimePropHasBoolean<T>;
35
+ type __RuntimePropShape<T extends Record<string, any>> = { [K in keyof T]: __RuntimePropResolved<T[K]> extends true ? __RuntimePropCtor<T[K]> : __RuntimePropCtor<T[K]> | undefined; };
36
+ type $IsAny<T> = 0 extends (1 & T) ? true : false;
37
+ type __LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P] };
38
+ type $BooleanKey<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 = $BooleanKey<T>> = Readonly<T> & { readonly [K in __BKeys]-?: boolean };
39
+ type $IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
40
+ type $NotUndefined<T> = T extends undefined ? never : T;
41
+ type $MappedOmit<T, K extends keyof any> = { [P in keyof T as P extends K ? never : P]: T[P] };
42
+ type $DefaultNativeType = null | number | string | boolean | symbol | Function;
43
+ type $InferDefault<P, T> = ((props: P) => T & {}) | (T extends $DefaultNativeType ? T : never);
44
+ type __WithDefaultsArgs<T> = { [K in keyof T]?: $InferDefault<T, T[K]> };
45
+ type __WithDefaultsResult<T, D, __BKeys extends keyof T = never> = T extends unknown ? Readonly<$MappedOmit<T, keyof D>> & { readonly [K in keyof D as K extends keyof T ? K : never]-?: K extends keyof T ? D[K] extends undefined ? $IfAny<D[K], $NotUndefined<T[K]>, T[K]> : $NotUndefined<T[K]> : never } & { readonly [K in __BKeys]-?: K extends keyof D ? D[K] extends undefined ? boolean | undefined : boolean : boolean } : never;
46
+ type __Ref<T> = import('vue').Ref<T>;
47
+ type __ShallowRef<T> = import('vue').ShallowRef<T>;
48
+ type $KebabCase<S extends string, Acc extends string = ""> = S extends `${infer Head}${infer Tail}` ? Head extends Lowercase<Head> ? $KebabCase<Tail, `${Acc}${Head}`> : $KebabCase<Tail, `${Acc}-${Lowercase<Head>}`> : `${Acc}${S}`;
49
+ type $KebabProps<T> = { [K in keyof T & string as $KebabCase<K>]: T[K] };type $RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
50
+ type $DomListenerProps = { [K in keyof GlobalEventHandlersEventMap as K extends string ? `on${Capitalize<K>}` : never]?: (event: GlobalEventHandlersEventMap[K]) => void };
51
+ type $FallthroughAttrs<Owned = {}> = { class?: unknown; style?: unknown } & { [K in `data-${string}` | `data${Capitalize<string>}`]?: unknown } & { [K in `aria-${string}` | `aria${Capitalize<string>}`]?: unknown } & Omit<$DomListenerProps, keyof Owned>;
52
+ // Match Vue's public prop contract, including runtime-core module augmentations.
53
+ type $PublicComponentInputProps = import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
54
+ type $ComponentMetadataKeys<T> = $IsAny<T> extends true ? never : T extends unknown ? keyof NonNullable<T> : never;
55
+ type $ComponentOwnKeys<P = {}, E = {}> = keyof $PublicComponentInputProps | $ComponentMetadataKeys<P> | $ComponentMetadataKeys<E>;
56
+ type $UnownedComponentAttrs<F, P = {}, E = {}> = $IsAny<F> extends true ? F : unknown extends F ? F : F extends unknown ? F extends null | undefined ? F : { [K in keyof F as K extends $ComponentOwnKeys<P, E> ? never : K]: F[K] } : never;
57
+ type $Prettify<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
58
+ type $ComponentFallthroughSurface<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 } ? $IsAny<__F> extends true ? {} : NonNullable<__F> : {});
59
+ type $ComponentFallthroughProps<C> = { [K in keyof $ComponentFallthroughSurface<C>]: $ComponentFallthroughSurface<C>[K] };
60
+ type $ComponentInputProps<T, Declared = {}> = T extends unknown ? Partial<T> & Partial<$KebabProps<T>> & Declared & $FallthroughAttrs<T & Declared> & $PublicComponentInputProps : never;
61
+ type $MissingRequiredInputKeys<T, Authored, K extends $RequiredKeys<T> & string = $RequiredKeys<T> & string> = K extends unknown ? K extends keyof Authored ? never : $KebabCase<K> extends keyof Authored ? never : K : never;
62
+ type $IsPropKeyUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : false;
63
+ type $IsSinglePropKey<T> = [T] extends [never] ? false : $IsPropKeyUnion<T> extends true ? false : true;
64
+ type $RelaxedDynamicUnionExtra<T, Declared, Authored, K extends keyof Authored> = [keyof Declared] extends [never] ? $IsSinglePropKey<$RequiredKeys<T>> extends true ? K extends string ? K extends `on${string}` ? false : Authored[K] extends true ? false : true : false : false : false;
65
+ type $ExtraInputKeys<T, Declared, Authored, Allowed, K extends keyof Authored = Exclude<keyof Authored, keyof Allowed>> = K extends unknown ? $RelaxedDynamicUnionExtra<T, Declared, Authored, K> extends true ? never : K : never;
66
+ type $ComponentMissingInputGuard<T, Authored> = T extends unknown ? [$MissingRequiredInputKeys<T, Authored>] extends [never] ? {} : { readonly __vizeInvalidComponentProps: { readonly missing: $MissingRequiredInputKeys<T, Authored>; readonly extra: never; } } : never;
67
+ type $ComponentInputGuardFor<T, Declared, Authored, Allowed> = [$MissingRequiredInputKeys<T, Authored> | $ExtraInputKeys<T, Declared, Authored, Allowed>] extends [never] ? {} : { readonly __vizeInvalidComponentProps: { readonly missing: $MissingRequiredInputKeys<T, Authored>; readonly extra: $ExtraInputKeys<T, Declared, Authored, Allowed>; } };
68
+ type $ComponentInputGuard<T, Declared, Authored> = $UsePublicInstance<Authored> extends true ? {} : T extends unknown ? $ComponentInputGuardFor<T, Declared, Authored, $ComponentInputProps<T, Declared>> : never;
69
+ type $ComponentInputFor<T, Declared, Authored, Allowed> = Allowed & $ComponentInputGuardFor<T, Declared, Authored, Allowed>;
70
+ type $ComponentInput<T, Declared, Authored> = $UsePublicInstance<Authored> extends true ? $ComponentInputProps<T, Declared> : T extends unknown ? $ComponentInputFor<T, Declared, Authored, $ComponentInputProps<T, Declared>> : never;
71
+ type $AuthoredKeyWitness<T> = { [K in keyof T]: unknown };
72
+ type $IsUnknown<T> = unknown extends T ? [keyof T] extends [never] ? true : false : false;
73
+ type $UsePublicInstance<T> = $IsAny<T> extends true ? true : $IsUnknown<T>;
74
+ type $LiteralKeys<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 };
75
+ type $ReplaceComponentProps<T, P> = Omit<T, '$props'> & Pick<T, Exclude<$LiteralKeys<T>, '$props'>> & { $props: P };
76
+ type $PublicEmit<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>;
77
+ type $PublicSlots<T> = [keyof T] extends [never] ? import('vue').ComponentPublicInstance['$slots'] : T;
78
+ // @ts-ignore TS2694/TS2307: a `vue` without `ComponentPublicInstance` must degrade component public extras to unchecked, never error.
79
+ type $ComponentPublicBase = Omit<import('vue').ComponentPublicInstance, '$props' | '$emit' | '$slots'>;
80
+ // @ts-ignore TS2694/TS2307: a `vue` without `NativeElements` must degrade native prop checks to unchecked, never error. See virtual_ts/expressions/native_props.rs.
81
+ type $NativeElements = import('vue').NativeElements;
82
+ type $NativeElement<Tag extends PropertyKey> = Tag extends keyof $NativeElements ? $NativeElements[Tag] : unknown;
83
+ type $NativeElementProp<Element, Prop extends PropertyKey> = Prop extends keyof Element ? Element[Prop] : unknown;
84
+ function __vizeNativeElementProp<__Tag extends PropertyKey, __Prop extends PropertyKey>(value: $NativeElementProp<$NativeElement<__Tag>, __Prop>): void;
85
+ type $ComponentAttrCamel<S extends string> = S extends `${infer __H}-${infer __T}` ? `${__H}${Capitalize<$ComponentAttrCamel<__T>>}` : S;
86
+ type $ComponentNativeAttrNames = { [K in keyof $NativeElements & string]: keyof $NativeElements[K] }[keyof $NativeElements & string] & string;
87
+ type $ComponentGlobalHtmlAttrs = $IsAny<$NativeElements> extends true ? {} : { [K in $ComponentNativeAttrNames as K | $ComponentAttrCamel<K>]?: unknown } & { [K in `data-${string}` | `data${Capitalize<string>}`]?: unknown };
88
+ function __vizeComponentGlobalHtmlAttrs(value: $ComponentGlobalHtmlAttrs): void;
89
+ 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][];type $DirectiveHook<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;
90
+ type $DirectiveCall<H> = H extends (...args: any[]) => any ? Parameters<H>['length'] extends 0 | 1 ? (el: unknown, binding: { value?: unknown; arg?: unknown; modifiers?: unknown }) => void : H : never;
91
+ function __vizeDirective<D>(directive: D): $DirectiveCall<$DirectiveHook<D>>;
92
+ // @ts-ignore TS2694/TS2307: a `vue` without `GlobalDirectives` must degrade registered directives to unchecked, never error.
93
+ type $GlobalDirectives = import('vue').GlobalDirectives;
94
+ // @ts-ignore TS2694/TS2307: a `vue` without `Directive` must degrade registered directives to unchecked, never error.
95
+ type $OwnDirectives<D> = D extends infer L & Record<string, import('vue').Directive> ? L : D;
96
+ type $LocalDirectives<C> = C extends { directives?: infer D } ? { [K in keyof $OwnDirectives<NonNullable<D>> & string as string extends K ? never : `v${Capitalize<K>}`]: $OwnDirectives<NonNullable<D>>[K] } : {};
97
+ function __vizeRegisteredDirective<C, K extends string>(): K extends keyof $LocalDirectives<C> ? $LocalDirectives<C>[K] : K extends keyof $GlobalDirectives ? $GlobalDirectives[K] : unknown;
98
+ function __vizeVaporDirective<D>(directive: D): D extends (...args: any[]) => any ? D : (node: unknown, value?: () => unknown, argument?: unknown, modifiers?: unknown) => void;
99
+ const __vizeDirectiveBindingRest: { instance: null; oldValue: null; modifiers: any; dir: any };
100
+ function __vizeDirectiveTail<F extends (...args: any[]) => any>(hook: F): 4 extends Parameters<F>['length'] ? [never, never] : 3 extends Parameters<F>['length'] ? [never] : [];
101
+
102
+
103
+
104
+
105
+ // Emit-overload helpers (consumed by the per-file __EmitProps alias)
106
+
107
+
108
+ type $OverloadProps<TOverload> = Pick<TOverload, keyof TOverload>;
109
+ type $OverloadUnionRecursive<TOverload, TPartialOverload = unknown, TDepth extends unknown[] = []> = TDepth['length'] extends 32 ? never : TOverload extends (...args: infer TArgs) => infer TReturn ? TPartialOverload extends TOverload ? never : $OverloadUnionRecursive<TPartialOverload & TOverload, TPartialOverload & ((...args: TArgs) => TReturn) & $OverloadProps<TOverload>, [...TDepth, unknown]> | ((...args: TArgs) => TReturn) : never;
110
+ type $OverloadUnion<TOverload extends (...args: any[]) => any> = Exclude<$OverloadUnionRecursive<(() => never) & TOverload>, TOverload extends () => never ? never : () => never>;
111
+ type $OverloadParameters<T extends (...args: any[]) => any> = Parameters<$OverloadUnion<T>>;
112
+ type $IsStringLiteral<T> = T extends string ? string extends T ? false : true : false;
113
+ type $ParametersToFns<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]]: $IsStringLiteral<K> extends true ? (...args: T extends [e: infer E, ...args: infer P] ? K extends E ? P : never : never) => any : never };
114
+ 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 ? $ParametersToFns<$OverloadParameters<__EmitShape<T>>> : {});
115
+ type $Camelize<S extends string> = S extends `${infer Head}-${infer Tail}` ? `${Head}${Capitalize<$Camelize<Tail>>}` : S;
116
+ type $HandlerKey<K extends string> = `on${Capitalize<$Camelize<K>>}`;
117
+
118
+
119
+
120
+
121
+ // Compiler-macro signatures (aliased inside each module's __setup() scope)
122
+ function __vize_defineProps<_T = unknown>(): __DefineProps<__LooseRequired<_T>, Extract<$BooleanKey<_T>, keyof __LooseRequired<_T>>>;
123
+ function __vize_defineProps<const _T extends readonly string[]>(_props: _T): { [K in _T[number]]?: any };
124
+ function __vize_defineProps<const _T extends Record<string, any>>(_props: _T): __RuntimePropShape<_T>;
125
+ function __vize_defineEmits<_T = unknown>(): __EmitFn<_T>;
126
+ function __vize_defineEmits<const _T extends readonly string[]>(_events: _T): (event: _T[number], ...args: any[]) => void;
127
+ function __vize_defineEmits<const _T extends Record<string, any>>(_events: _T): __EmitFn<_T>;
128
+ function __vize_defineExpose<_T = unknown>(_exposed?: _T): void;
129
+ const __vize_defineModel: typeof import('vue') extends { defineModel: infer __Macro } ? __Macro : never;
130
+ function __vize_defineSlots<_T = unknown>(): _T;
131
+ function __vize_withDefaults<_T, _BKeys extends keyof _T, _D extends __WithDefaultsArgs<_T>>(_props: __DefineProps<_T, _BKeys>, _defaults: _D): __WithDefaultsResult<_T, _D, _BKeys>;
132
+ function __vize_useTemplateRef<_T = any>(_key: string): __ShallowRef<_T | null>;
133
+ // Adapted from vuejs/language-tools e68d41bfef1770f8428f92097abe959b57de62d2.
134
+ // MIT license; see pattern_matching.LICENSE.
135
+ // Kept as a checked declaration file, shared once per TypeScript program.
136
+ /*
137
+ MIT License
138
+
139
+ Copyright (c) 2021-present Johnson Chu
140
+
141
+ Permission is hereby granted, free of charge, to any person obtaining a copy
142
+ of this software and associated documentation files (the "Software"), to deal
143
+ in the Software without restriction, including without limitation the rights
144
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
145
+ copies of the Software, and to permit persons to whom the Software is
146
+ furnished to do so, subject to the following conditions:
147
+
148
+ The above copyright notice and this permission notice shall be included in all
149
+ copies or substantial portions of the Software.
150
+
151
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
152
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
153
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
154
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
155
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
156
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
157
+ SOFTWARE.
158
+ */
159
+ namespace $Patterns {
160
+ type Reachable<T> = [T] extends [never] ? { "Unreachable v-when": never } : true;
161
+ /**
162
+ * RFC 823 pattern types. Match narrows an arm; Subtract keeps the values left
163
+ * for later arms. Objects split by property and arrays by head/tail, so nested
164
+ * unions do not need their entire Cartesian product expanded up front.
165
+ */
166
+ type Pattern =
167
+ | ["any"]
168
+ | ["literal" | "value", unknown]
169
+ | ["or", Pattern[]]
170
+ | ["object", [PropertyKey, Pattern][]]
171
+ | ["array", Pattern[], boolean];
172
+
173
+ type IsAny<T> = 0 extends 1 & T ? true : false;
174
+
175
+ // Vue can unwrap unknown to {}. Keep that space conservative too.
176
+ type IsUnknownLike<T> = [keyof T] extends [never] ? ({} extends T ? true : false) : false;
177
+
178
+ type IsUnion<T, C = T> = T extends C ? ([C] extends [T] ? false : true) : never;
179
+
180
+ // A runtime value with a union type matches one member, so it cannot cover the whole union.
181
+ type IsSingleton<T> =
182
+ IsAny<T> extends true
183
+ ? false
184
+ : true extends IsUnion<T>
185
+ ? false
186
+ : T extends string | number | bigint | boolean | null | undefined
187
+ ? string extends T
188
+ ? false
189
+ : number extends T
190
+ ? false
191
+ : bigint extends T
192
+ ? false
193
+ : boolean extends T
194
+ ? false
195
+ : true
196
+ : false;
197
+
198
+ type Simplify<T> = { [K in keyof T]: T[K] };
199
+
200
+ // Remove optionality before substituting V. A homomorphic -? mapping would
201
+ // strip undefined from V when exactOptionalPropertyTypes is disabled.
202
+ type PresentProperty<T, K extends keyof T, V> = {
203
+ [Q in keyof Required<Pick<T, K>>]: V;
204
+ };
205
+
206
+ // Retain the original type when refinement changes nothing, including its readonly modifiers.
207
+ type ReplaceProperty<T, K extends keyof T, V> = [V] extends [never]
208
+ ? never
209
+ : {} extends Pick<T, K>
210
+ ? Simplify<Omit<T, K> & PresentProperty<T, K, V>>
211
+ : [T[K]] extends [V]
212
+ ? [V] extends [T[K]]
213
+ ? T
214
+ : Simplify<Omit<T, K> & PresentProperty<T, K, V>>
215
+ : Simplify<Omit<T, K> & PresentProperty<T, K, V>>;
216
+
217
+ // Turn the pattern descriptor emitted by vMatch.ts into a positive type constraint.
218
+ type PatternType<P> = P extends ["any"]
219
+ ? unknown
220
+ : P extends ["literal" | "value", infer V]
221
+ ? V
222
+ : P extends ["or", infer A extends unknown[]]
223
+ ? PatternType<A[number]>
224
+ : P extends ["object", infer A extends [PropertyKey, unknown][]]
225
+ ? { [Q in A[number] as Q[0]]: PatternType<Q[1]> }
226
+ : P extends ["array", infer A extends unknown[], infer R]
227
+ ? [...{ [I in keyof A]: PatternType<A[I]> }, ...(R extends true ? unknown[] : [])]
228
+ : never;
229
+
230
+ type Match<T, P extends Pattern> = MatchImpl<T, P>;
231
+ type Subtract<T, P extends Pattern> = SubtractImpl<T, P>;
232
+
233
+ // Narrow one union member at a time. Object patterns constrain only their listed properties.
234
+ type MatchImpl<T, P> = P extends ["any"]
235
+ ? T
236
+ : IsAny<T> extends true
237
+ ? PatternType<P>
238
+ : unknown extends T
239
+ ? PatternType<P>
240
+ : IsUnknownLike<T> extends true
241
+ ? T & PatternType<P>
242
+ : T extends unknown
243
+ ? P extends ["literal" | "value", infer V]
244
+ ? T & V
245
+ : P extends ["or", infer A extends unknown[]]
246
+ ? MatchImpl<T, A[number]>
247
+ : P extends ["object", infer A extends [PropertyKey, unknown][]]
248
+ ? T extends null | undefined
249
+ ? never
250
+ : MatchObject<T, A>
251
+ : P extends ["array", infer A extends unknown[], infer R]
252
+ ? T extends readonly unknown[]
253
+ ? T extends unknown[]
254
+ ? MatchArray<T, A, R>
255
+ : Readonly<MatchArray<T, A, R>>
256
+ : never
257
+ : never
258
+ : never;
259
+
260
+ // Presence does not remove undefined from an optional property value.
261
+ type RequireProperty<T, K extends keyof T> =
262
+ {} extends Pick<T, K> ? Simplify<Omit<T, K> & PresentProperty<T, K, T[K]>> : T;
263
+
264
+ type MatchObject<T, A> = A extends [infer H extends [PropertyKey, unknown], ...infer R]
265
+ ? H[0] extends keyof T
266
+ ? H[1] extends ["any"]
267
+ ? MatchObject<RequireProperty<T, H[0]>, R>
268
+ : MatchObject<ReplaceProperty<T, H[0], MatchImpl<T[H[0]], H[1]>>, R>
269
+ : MatchObject<T & { [K in H[0]]: PatternType<H[1]> }, R>
270
+ : T;
271
+
272
+ type MatchArray<T extends readonly unknown[], A extends unknown[], R> = A extends [
273
+ infer H,
274
+ ...infer Tail,
275
+ ]
276
+ ? T extends readonly []
277
+ ? never
278
+ : T extends readonly [infer V, ...infer Rest]
279
+ ? Prepend<MatchImpl<V, H>, MatchArray<Rest, Tail, R>>
280
+ : T extends readonly [(infer V)?, ...infer Rest]
281
+ ? Prepend<MatchImpl<T[0], H>, MatchArray<Rest, Tail, R>>
282
+ : never
283
+ : R extends true
284
+ ? T
285
+ : [] extends T
286
+ ? []
287
+ : never;
288
+
289
+ type Prepend<H, T> = [H] extends [never]
290
+ ? never
291
+ : T extends readonly unknown[]
292
+ ? [H, ...T]
293
+ : never;
294
+
295
+ // Only unguarded arms call this helper. Unknown and open primitive spaces stay uncovered.
296
+ type SubtractImpl<T, P> = [T] extends [never]
297
+ ? never
298
+ : P extends ["any"]
299
+ ? never
300
+ : IsAny<T> extends true
301
+ ? T
302
+ : unknown extends T
303
+ ? T
304
+ : IsUnknownLike<T> extends true
305
+ ? T
306
+ : string extends T
307
+ ? T
308
+ : number extends T
309
+ ? T
310
+ : bigint extends T
311
+ ? T
312
+ : P extends ["or", infer A extends unknown[]]
313
+ ? SubtractAlternatives<T, A>
314
+ : T extends unknown
315
+ ? P extends ["literal", infer V]
316
+ ? Exclude<T, V>
317
+ : P extends ["value", infer V]
318
+ ? IsSingleton<V> extends true
319
+ ? Exclude<T, V>
320
+ : T
321
+ : P extends ["object", infer A extends [PropertyKey, unknown][]]
322
+ ? T extends null | undefined
323
+ ? T
324
+ : SubtractObject<T, A>
325
+ : P extends ["array", infer A extends unknown[], infer R]
326
+ ? T extends readonly unknown[]
327
+ ? T extends unknown[]
328
+ ? SubtractArray<T, A, R>
329
+ : Readonly<SubtractArray<T, A, R>>
330
+ : T
331
+ : T
332
+ : never;
333
+
334
+ type SubtractAlternatives<T, A> = A extends [infer H, ...infer R]
335
+ ? SubtractAlternatives<SubtractImpl<T, H>, R>
336
+ : T;
337
+
338
+ // The remaining object space has three cases: the key is absent, its pattern fails,
339
+ // or its pattern matches and a later property fails.
340
+ type SubtractObject<T, A> = [T] extends [never]
341
+ ? never
342
+ : A extends [infer H extends [PropertyKey, unknown], ...infer R]
343
+ ? H[0] extends keyof T
344
+ ? H[1] extends ["any"]
345
+ ?
346
+ | ({} extends Pick<T, H[0]> ? Omit<T, H[0]> & { [K in H[0]]?: never } : never)
347
+ | SubtractObject<RequireProperty<T, H[0]>, R>
348
+ :
349
+ | ({} extends Pick<T, H[0]> ? Omit<T, H[0]> & { [K in H[0]]?: never } : never)
350
+ | ReplaceProperty<T, H[0], SubtractImpl<T[H[0]], H[1]>>
351
+ | SubtractObject<ReplaceProperty<T, H[0], MatchImpl<T[H[0]], H[1]>>, R>
352
+ : T
353
+ : never;
354
+
355
+ // Split a tuple or array into its head and tail. Exact-length patterns also leave longer arrays.
356
+ type SubtractArray<T extends readonly unknown[], A extends unknown[], R> = A extends [
357
+ infer H,
358
+ ...infer Tail,
359
+ ]
360
+ ? T extends readonly []
361
+ ? T
362
+ : T extends readonly [infer V, ...infer Rest]
363
+ ? Prepend<SubtractImpl<V, H>, Rest> | Prepend<MatchImpl<V, H>, SubtractArray<Rest, Tail, R>>
364
+ : T extends readonly [(infer V)?, ...infer Rest]
365
+ ?
366
+ | []
367
+ | Prepend<SubtractImpl<T[0], H>, Rest>
368
+ | Prepend<MatchImpl<T[0], H>, SubtractArray<Rest, Tail, R>>
369
+ : T
370
+ : R extends true
371
+ ? never
372
+ : T extends readonly []
373
+ ? never
374
+ : T extends readonly [unknown, ...unknown[]]
375
+ ? T
376
+ : T extends readonly [(infer V)?, ...infer Rest]
377
+ ? [T[0], ...Rest]
378
+ : never;
379
+
380
+ // Diagnostic examples must be valid pattern syntax. Fall back to _ when a literal needs escaping.
381
+ type FormatPattern<T> = T extends string
382
+ ? string extends T
383
+ ? "_"
384
+ : T extends `${string}${"'" | '"' | "\\" | "\n" | "\r"}${string}`
385
+ ? "_"
386
+ : `'${T}'`
387
+ : T extends bigint
388
+ ? bigint extends T
389
+ ? "_"
390
+ : `${T}n`
391
+ : T extends number
392
+ ? number extends T
393
+ ? "_"
394
+ : `${T}`
395
+ : T extends boolean | null | undefined
396
+ ? `${T}`
397
+ : T extends readonly unknown[]
398
+ ? `[${FormatTuple<T>}]`
399
+ : "_";
400
+
401
+ type FormatTuple<T extends readonly unknown[]> = T extends readonly []
402
+ ? ""
403
+ : T extends readonly [infer H, ...infer R]
404
+ ? `${FormatPattern<H>}${R extends [] ? "" : `, ${FormatTuple<R>}`}`
405
+ : "...";
406
+
407
+ type MissingPatternMessage<T> =
408
+ IsAny<T> extends true
409
+ ? 'Add an unguarded v-when="_" to prove coverage.'
410
+ : T extends string
411
+ ? string extends T
412
+ ? "An open string requires an unguarded catch-all."
413
+ : T extends `${string}${"'" | '"' | "\\" | "\n" | "\r"}${string}`
414
+ ? 'Add an unguarded v-when="_".'
415
+ : `Missing v-when="'${T}'".`
416
+ : T extends bigint
417
+ ? bigint extends T
418
+ ? "An open bigint requires an unguarded catch-all."
419
+ : `Missing v-when="${T}n".`
420
+ : T extends number
421
+ ? number extends T
422
+ ? "An open number requires an unguarded catch-all."
423
+ : `Missing v-when="${T}".`
424
+ : T extends boolean | null | undefined
425
+ ? `Missing v-when="${T}".`
426
+ : T extends readonly unknown[]
427
+ ? `Missing v-when="[${FormatTuple<T>}]".`
428
+ : 'Coverage cannot be proven. Add missing structural arms or an unguarded v-when="_".';
429
+
430
+ // A nonempty remaining space produces an error mapped to the v-match subject.
431
+ type Exhaustiveness<T> = [T] extends [never]
432
+ ? true
433
+ : {
434
+ "Non-exhaustive v-match": T;
435
+ } & { [K in MissingPatternMessage<T>]: never };
436
+ }
437
+ }
438
+
439
+ // Template-ref widening. Hoisted-only, deliberately absent from the per-file
440
+ // preamble: a module-scope copy is dead code (TS6196) in every component whose
441
+ // template scope emits no __U, and only generated template scopes use it.
442
+ type $IsUnion<T, __U = T> = T extends unknown ? ([__U] extends [T] ? false : true) : false;
443
+ export type $WidenTemplateRef<T> = $IsAny<T> extends true ? T : $IsUnion<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;
444
+
445
+ export type $SlotHostSlots<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;
446
+ 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;
447
+ type $NativeSlotsFactory<C> = [C] extends [new (...args: any[]) => any] ? (component: C) => (props: any) => $SlotHostSlots<C> : C extends (...args: any[]) => any ? typeof __vizeFunctionalSlots : (component: C) => (props: any) => $SlotHostSlots<C>;
448
+ export type $SlotsFactory<C> = $IsAny<C> extends true ? (component: C) => (props: any) => any : C extends { __vizeResolveSlots?: infer F } ? F extends (...args: any[]) => any ? (component: C) => F : $NativeSlotsFactory<C> : C extends { readonly __vizeComponentMarker: true } ? (component: C) => (props: any) => $SlotHostSlots<C> : $NativeSlotsFactory<C>;
449
+ type $HasSlotResolver<C> = C extends { __vizeResolveSlots?: infer F } ? F extends (...args: any[]) => any ? true : false : false;
450
+ type $DirectSlotConstructor<C> = $IsAny<C> extends true ? never : $HasSlotResolver<C> extends true ? never : C extends { readonly __vizeComponentMarker: true } ? never : C extends new (...args: any[]) => { $slots: any } ? C : never;
451
+ export type $SlotConstructor<C> = [$DirectSlotConstructor<C>] extends [never] ? new (props: any, ...args: any[]) => { $slots: never } : $DirectSlotConstructor<C>;
452
+ type $SlotConstructorArgumentLists<C> = C extends { new (...args: infer A1): any; new (...args: infer A2): any; new (...args: infer A3): any; new (...args: infer A4): any; new (...args: infer A5): any; new (...args: infer A6): any; new (...args: infer A7): any; new (...args: infer A8): any } ? A1 | A2 | A3 | A4 | A5 | A6 | A7 | A8 : C extends new (...args: infer A) => any ? A : [unknown];
453
+ type $SlotConstructorHasArguments<C> = $SlotConstructorArgumentLists<C> extends infer A ? A extends [] ? never : true : never;
454
+ export type $SlotConstructorWithoutArguments<C> = [$SlotConstructorHasArguments<C>] extends [never] ? C : new () => { $slots: never };
455
+ export type $SlotConstructorWithArguments<C> = [$SlotConstructorHasArguments<C>] extends [never] ? new (props: any, ...args: any[]) => { $slots: never } : C;
456
+ export type $SlotConstructorArgs<C> = C extends new (props: any, ...args: infer A) => any ? { [K in keyof A]: any } : [];
457
+ export type $SlotConstructorInstance<C, Z, P> = [$SlotConstructorHasArguments<C>] extends [never] ? Z : P;
458
+ export type $SlotHostSelector<C> = [$DirectSlotConstructor<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 $SilentAny = {}["__vizeSilentAny"];
462
+ type $NamedSlotPayload<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 $SlotPayload<S, N> = $IsAny<S> extends true ? $SilentAny : string extends N ? string extends keyof S ? $NamedSlotPayload<S, N> : any : $NamedSlotPayload<S, N>;
464
+
465
+ export type __EmitProps<T> = { [K in keyof __EmitOptions<T> & string as $HandlerKey<K> | `on${Capitalize<K>}`]?: __EmitOptions<T>[K] };
466
+
467
+ type $EmitRequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
468
+ type $EmitRequiredFields<T> = T extends unknown ? Pick<T, $EmitRequiredKeys<T>> : never;
469
+ type $EmitFiniteFields<T> = { [K in keyof T as {} extends Record<K, unknown> ? never : K]: T[K] };
470
+ type $EmitFallthrough<F> = $IsAny<F> extends true ? {} : [NonNullable<F>] extends [never] ? {} : NonNullable<F>;
471
+ export type $EmitOwnedKeys<C> = $ComponentOwnKeys<C extends { readonly __vizeRawProps?: infer P } ? P : {}, C extends { readonly __vizeEmitProps?: infer E } ? E : {}>;
472
+ type $EmitInput<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 } & $EmitRequiredFields<P> & $EmitRequiredFields<Omit<$EmitFiniteFields<F>, O>> : never : never;
473
+ declare function __vizeConstructorEmitProps<P, E>(component: new (props: P, ...args: any[]) => { $emit: E }): (props: P) => __EmitProps<E>;
474
+ type $ConstructorEmitPropsFactory<F, O extends PropertyKey> = <P, E>(component: new (props: P, ...args: any[]) => { $emit: E }) => <A>(props: $EmitInput<P, $EmitFallthrough<F>, O, A>) => __EmitProps<E>;
475
+ type $NativeEmitPropsFactory<C> = C extends new (...args: any[]) => { $emit: any } ? C extends { readonly __vizeComponentMarker: true } ? $ConstructorEmitPropsFactory<C extends { readonly __vizeFallthroughProps?: infer F } ? F : {}, $EmitOwnedKeys<C>> : typeof __vizeConstructorEmitProps : (component: C) => (props: any) => {};
476
+ export type $EmitPropsFactory<C> = $IsAny<C> extends true ? (component: C) => (props: any) => {} : C extends { __vizeResolveEmitProps?: infer F } ? F extends (...args: any[]) => any ? (component: C) => F : $NativeEmitPropsFactory<C> : C extends { __vizeResolveProps?: infer F } ? F extends (...args: any[]) => any ? (component: C) => F : $NativeEmitPropsFactory<C> : $NativeEmitPropsFactory<C>;
477
+
478
+ // Component usage helpers shared by every generated module in a batch project.
479
+ export type IsAny<T> = $IsAny<T>;
480
+ export type ComponentGlobalHtmlAttrs = $ComponentGlobalHtmlAttrs;
481
+ export type $ComponentNavigationProps<P> = $IsAny<P> extends true ? Record<string, unknown> : unknown extends P ? {} : P;
482
+ export type $EmitListeners<C> = C extends { __vizeEmitProps?: infer __E } ? $IsAny<__E> extends true ? {} : NonNullable<__E> : {};
483
+ export type $IsGeneratedComponent<C> = C extends { readonly __vizeComponentMarker: true } ? true : false;
484
+ export type $HasFallthroughProps<C> = $IsGeneratedComponent<C> extends true ? C extends { readonly __vizeHasFallthroughProps: true } ? true : false : false;
485
+ export type $FallthroughProps<C> = $HasFallthroughProps<C> extends true ? C extends { readonly __vizeFallthroughProps?: infer __F } ? $IsAny<__F> extends true ? {} : NonNullable<__F> : {} : {};
486
+ export type $RequiredFallthroughProps<C, __F = $FallthroughProps<C>, __K = $RequiredKeys<__F>> = [__K] extends [never] ? {} : { [K in keyof __F as K extends __K ? K : never]: __F[K] };
487
+ type $ComponentCheckProps<P, T> = { readonly [K in keyof P]: P[K] } & T;
488
+ type $PublicProps<C> = C extends abstract new (...args: any[]) => infer __I ? $IsAny<__I> extends true ? Record<string, unknown> : __I extends { $props: infer __P } ? __P : {} : C extends (props: infer __P, ...args: any[]) => any ? __P : {};
489
+ type $InstanceRawProps<C> = C extends { new (): { readonly __vizeRawProps?: infer __P } } ? $IsAny<__P> extends true ? $PublicProps<C> : __P : $PublicProps<C>;
490
+ type $StaticRawProps<C> = C extends { readonly __vizeRawProps?: infer __P } ? $IsAny<__P> extends true ? $PublicProps<C> : __P : $PublicProps<C>;
491
+ type $HasInstanceRawProps<C> = $IsGeneratedComponent<C> extends true ? C extends { new (): { readonly __vizeRawProps?: infer __P } } ? $IsAny<__P> extends true ? false : true : false : false;
492
+ type $HasStaticRawProps<C> = $IsGeneratedComponent<C> extends true ? C extends { readonly __vizeRawProps?: infer __P } ? $IsAny<__P> extends true ? false : true : false : false;
493
+ export type $ComponentRawProps<C, __P = $HasInstanceRawProps<C> extends true ? $InstanceRawProps<C> : $HasStaticRawProps<C> extends true ? $StaticRawProps<C> : $PublicProps<C>> = unknown extends __P ? Record<string, unknown> : __P;
494
+ type $HasRawProps<C> = $HasInstanceRawProps<C> extends true ? true : $HasStaticRawProps<C>;
495
+ export type $FallthroughValue<C, K extends PropertyKey> = $HasFallthroughProps<C> extends true ? C extends { readonly __vizeFallthroughProps?: infer __F } ? $IsAny<__F> extends true ? unknown : $PropValue<NonNullable<__F>, K, unknown> : unknown : unknown;
496
+ type $EventName<K extends string> = K extends `on${infer E}` ? Uncapitalize<E> | $KebabCase<Uncapitalize<E>> : never;
497
+ type $KebabEventAliases<E> = { [K in keyof E & string as $KebabCase<K> extends K ? never : $KebabCase<K>]: E[K] };
498
+ export type $ComponentEvents<C> = C extends { __vizeRawEmits?: infer __R; __vizeEventMap?: infer __E } ? [keyof NonNullable<__R>] extends [never] ? NonNullable<__E> : NonNullable<__R> & $KebabEventAliases<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 $EventName<K>]: (C extends { new (...args: any[]): { $props: infer __P } } ? __P : C extends (props: infer __P, ...args: any[]) => any ? __P : {})[K] };
499
+ export type $IsLibraryGenericExport<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 $PropChecker<C, P, T> = $IsAny<C> extends true ? (props: { readonly [K in keyof P]: P[K] } & Record<string, unknown>) => void : C extends { __vizeCheck: infer __F } ? $IsAny<__F> extends true ? (props: $ComponentCheckProps<P, T>) => void : unknown extends __F ? (props: $ComponentCheckProps<P, T>) => void : __F extends (...args: any[]) => any ? __F : (props: $ComponentCheckProps<P, T>) => void : $IsLibraryGenericExport<C> extends true ? C : (props: $ComponentCheckProps<P, T>) => void;
501
+ export type $PropValue<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 $InvalidFallthroughSpreadKeys<P, F, A> = { [K in keyof A]-?: K extends keyof P | keyof $KebabProps<P> ? never : K extends keyof F ? $IsAny<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 $FallthroughSpreadGuard<C, P, A, __K = $InvalidFallthroughSpreadKeys<P, $FallthroughProps<C>, A>> = [__K] extends [never] ? unknown : { readonly __vizeInvalidFallthroughSpreadValues: __K };
504
+ export type $FallthroughSpreadChecker<C, P> = <A>(props: A & $FallthroughSpreadGuard<C, P, NoInfer<A>>) => A;
505
+ export type $CallableProp<T> = $IsAny<T> extends true ? T : unknown extends T ? (...args: any[]) => any : T;
506
+ export type $PropsResolver<C> = C extends { __vizeResolveProps?: infer __F } ? (__F extends (...args: any[]) => any ? __F : (props: any) => {}) : $IsLibraryGenericExport<C> extends true ? C : (props: any) => {};
507
+ export type $ResolvedContextProps = <R>(resolved: R) => R extends { __ctx?: infer __X } ? NonNullable<__X> extends { props: infer __P } ? __P : R : R;
508
+ export type $PropsSelector<R> = <A extends Partial<R> & Record<string, unknown>>(props: A) => A;
509
+ type $MissingProp = { readonly __vizeMissingProp: unique symbol };
510
+ type $ResolvedPropEntry<R, K extends PropertyKey> = R extends unknown ? K extends keyof R ? { value: R[K] } : $MissingProp : never;
511
+ type $SelectedProps<R, A> = R extends unknown ? A extends Partial<R> ? R : never : never;
512
+ export type $ResolvedProp<R, A, K extends PropertyKey, F, __S = $SelectedProps<R, A>, __E = $ResolvedPropEntry<__S, K>, __A = $ResolvedPropEntry<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 $ComponentRefCallback = (ref: any, refs: Record<string, any>) => void;
514
+ export type $StructuralSlots<C> = C extends { readonly __vizeSlots?: infer __S } ? NonNullable<__S> : any;
515
+ type $EmptyVueNavigationSlots<C> = ('__isFragment' | '__isTeleport' | '__isSuspense' | 'slots') extends keyof C ? $IsAny<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 } ? $IsAny<__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 $NativeNavigationSlots<C> = C extends new (...args: any[]) => { $slots: any } ? $IsAny<InstanceType<C>> extends true ? $EmptyVueNavigationSlots<C> : $IsAny<InstanceType<C>['$slots']> extends true ? any : unknown extends InstanceType<C>['$slots'] ? any : InstanceType<C>['$slots'] : any;
517
+ export type $NavigationSlots<C> = $IsAny<C> extends true ? any : C extends { readonly __vizeSlots?: infer __S } ? $IsAny<__S> extends true ? __S : unknown extends __S ? [keyof NonNullable<__S>] extends [never] ? $NativeNavigationSlots<C> : NonNullable<__S> : NonNullable<__S> : $NativeNavigationSlots<C>;
518
+ type $RequiredSlotKeys<__S> = { [__K in keyof __S]-?: undefined extends __S[__K] ? never : __K }[keyof __S];
519
+ type $MissingRequiredSlots<__S, __P> = Exclude<$RequiredSlotKeys<__S>, keyof __P>;
520
+ export type $RequiredSlots<__S, __P> = $IsAny<__S> extends true ? {} : string extends keyof __S ? {} : [keyof __S] extends [never] ? {} : [$MissingRequiredSlots<__S, __P>] extends [never] ? {} : { readonly __vizeMissingSlots: $MissingRequiredSlots<__S, __P> };
521
+ export type $SlotChildren<__S, __K extends PropertyKey> = $IsAny<__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 $ProvidedSlotChildren<__T extends unknown[]> = __T extends [infer __Only] ? __Only | __T : __T;