@vue/runtime-vapor 3.6.0-alpha.5 → 3.6.0-alpha.7

package/dist/runtime-vapor.d.ts

@@ -1,6 +1,6 @@
-import { VNode, TransitionHooks, TransitionState, TransitionProps, Plugin, SchedulerJob, GenericComponentInstance, GenericAppContext, EffectScope as EffectScope$1, EmitFn, SuspenseBoundary, LifecycleHook, NormalizedPropsOptions, ObjectEmitsOptions, ComponentInternalOptions, AsyncComponentInternalOptions, ComponentPropsOptions, EmitsOptions, CreateAppFunction, AsyncComponentLoader, AsyncComponentOptions, DirectiveModifiers, VueElementBase, CustomElementOptions } from '@vue/runtime-dom';
-import { Ref, EffectScope, ReactiveEffect, ShallowRef } from '@vue/reactivity';
-import { Namespace, NormalizedStyle } from '@vue/shared';
+import { VNode, GenericComponentInstance, TransitionHooks, TransitionState, TransitionProps, Plugin, SchedulerJob, EmitsOptions, ComponentObjectPropsOptions, ExtractPropTypes, ReservedProps, AllowedComponentProps, ComponentCustomProps, EmitsToProps, ExtractDefaultPropTypes, EmitFn, ComponentTypeEmits, TypeEmitsToOptions, GenericAppContext, EffectScope as EffectScope$1, ShallowUnwrapRef, SuspenseBoundary, LifecycleHook, NormalizedPropsOptions, ObjectEmitsOptions, ComponentInternalOptions, AsyncComponentInternalOptions, ComponentPropsOptions, CreateAppFunction, AsyncComponentLoader, AsyncComponentOptions, DirectiveModifiers, CustomElementOptions, VueElementBase } from '@vue/runtime-dom';
+import { Ref, EffectScope, ReactiveEffect, ComputedRef, ShallowRef } from '@vue/reactivity';
+import { Prettify, IsKeyValues, Namespace, NormalizedStyle } from '@vue/shared';
 
 type NodeRef = string | Ref | ((ref: Element | VaporComponentInstance, refs: Record<string, any>) => void);
 type RefEl = Element | VaporComponentInstance;
@@ -13,12 +13,13 @@ export declare class VaporFragment<T extends Block = Block> implements Transitio
     nodes: T;
     vnode?: VNode | null;
     anchor?: Node;
+    parentComponent?: GenericComponentInstance | null;
     fallback?: BlockFn;
     insert?: (parent: ParentNode, anchor: Node | null, transitionHooks?: TransitionHooks) => void;
     remove?: (parent?: ParentNode, transitionHooks?: TransitionHooks) => void;
     hydrate?: (...args: any[]) => void;
     setRef?: (instance: VaporComponentInstance, ref: NodeRef, refFor: boolean, refKey: string | undefined) => void;
-    updated?: ((nodes?: Block) => void)[];
+    onUpdated?: ((nodes?: Block) => void)[];
     constructor(nodes: T);
 }
 declare class ForFragment extends VaporFragment<Block[]> {
@@ -30,28 +31,30 @@ declare class DynamicFragment extends VaporFragment {
     current?: BlockFn;
     fallback?: BlockFn;
     anchorLabel?: string;
+    attrs?: Record<string, any>;
+    setAsyncRef?: (instance: VaporComponentInstance) => void;
     getScope?: (key: any) => EffectScope | undefined;
-    beforeTeardown?: ((oldKey: any, nodes: Block, scope: EffectScope) => boolean)[];
-    beforeMount?: ((newKey: any, nodes: Block, scope: EffectScope) => void)[];
+    onBeforeTeardown?: ((oldKey: any, nodes: Block, scope: EffectScope) => boolean)[];
+    onBeforeMount?: ((newKey: any, nodes: Block, scope: EffectScope) => void)[];
+    slotOwner: VaporComponentInstance | null;
     constructor(anchorLabel?: string);
     update(render?: BlockFn, key?: any): void;
-    private render;
+    renderBranch(render: BlockFn | undefined, transition: VaporTransitionHooks | undefined, parent: ParentNode | null, instance: GenericComponentInstance | null): void;
     hydrate: (isEmpty?: boolean) => void;
 }
 export declare function isFragment(val: NonNullable<unknown>): val is VaporFragment;
 
-interface VaporTransitionHooks extends TransitionHooks {
+export interface VaporTransitionHooks extends TransitionHooks {
     state: TransitionState;
     props: TransitionProps;
     instance: VaporComponentInstance;
     disabled?: boolean;
-    group?: boolean;
 }
 interface TransitionOptions {
     $key?: any;
     $transition?: VaporTransitionHooks;
 }
-type Block = Node | VaporFragment | DynamicFragment | VaporComponentInstance | Block[];
+export type Block = Node | VaporFragment | DynamicFragment | VaporComponentInstance | Block[];
 type BlockFn = (...args: any[]) => Block;
 export declare function insert(block: Block, parent: ParentNode & {
     $fc?: Node | null;
@@ -85,20 +88,24 @@ type RawSlots = Record<string, VaporSlot> & {
     $?: DynamicSlotSource[];
 };
 type StaticSlots = Record<string, VaporSlot>;
-type VaporSlot = BlockFn;
+export type VaporSlot = BlockFn;
 type DynamicSlot = {
     name: string;
     fn: VaporSlot;
 };
-type DynamicSlotFn = () => DynamicSlot | DynamicSlot[];
+type DynamicSlotFn = (() => DynamicSlot | DynamicSlot[]) & {
+    _cache?: ComputedRef<DynamicSlot | DynamicSlot[]>;
+};
 type DynamicSlotSource = StaticSlots | DynamicSlotFn;
 /**
- * Wrap a slot function to memoize currentInstance
- * 1. ensure correct currentInstance in forwarded slots
- * 2. elements created in the slot inherit the slot owner's scopeId
+ * Wrap a slot function to track the slot owner.
+ *
+ * This ensures:
+ * 1. createSlot gets rawSlots from the correct component (slot owner)
+ * 2. Elements inherit the slot owner's scopeId
  */
 export declare function withVaporCtx(fn: Function): BlockFn;
-export declare function createSlot(name: string | (() => string), rawProps?: LooseRawProps | null, fallback?: VaporSlot, noSlotted?: boolean): Block;
+export declare function createSlot(name: string | (() => string), rawProps?: LooseRawProps | null, fallback?: VaporSlot, noSlotted?: boolean, once?: boolean): Block;
 
 export declare const VaporTeleportImpl: {
     name: string;
@@ -118,32 +125,89 @@ declare class TeleportFragment extends VaporFragment {
     placeholder?: Node;
     mountContainer?: ParentNode | null;
     mountAnchor?: Node | null;
-    parentComponent: GenericComponentInstance;
     constructor(props: LooseRawProps, slots: LooseRawSlots);
     get parent(): ParentNode | null;
     private initChildren;
     private handleChildrenUpdate;
+    private mount;
+    private mountToTarget;
     private handlePropsUpdate;
     insert: (container: ParentNode, anchor: Node | null) => void;
     remove: (parent?: ParentNode | undefined) => void;
     private hydrateDisabledTeleport;
-    private mount;
+    private mountChildren;
     hydrate: () => void;
 }
 
-type VaporComponent = FunctionalVaporComponent | ObjectVaporComponent;
-type VaporSetupFn = (props: any, ctx: Pick<VaporComponentInstance, 'slots' | 'attrs' | 'emit' | 'expose'>) => Block | Record<string, any> | undefined;
-type FunctionalVaporComponent = VaporSetupFn & Omit<ObjectVaporComponent, 'setup'> & {
+export type VaporPublicProps = ReservedProps & AllowedComponentProps & ComponentCustomProps;
+export type VaporRenderResult<T = Block> = VNode | T | VaporRenderResult<T>[];
+type VaporComponentInstanceConstructor<T extends VaporComponentInstance> = {
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+    new (props?: T['props']): T;
+};
+export type DefineVaporComponent<RuntimePropsOptions = {}, RuntimePropsKeys extends string = string, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, TypeRefs extends Record<string, unknown> = {}, MakeDefaultsOptional extends boolean = true, InferredProps = string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : {
+    [key in RuntimePropsKeys]?: any;
+}, PublicProps = VaporPublicProps, ResolvedProps = InferredProps & EmitsToProps<Emits>, Defaults = ExtractDefaultPropTypes<RuntimePropsOptions>> = VaporComponentInstanceConstructor<VaporComponentInstance<MakeDefaultsOptional extends true ? keyof Defaults extends never ? Prettify<ResolvedProps> & PublicProps : Partial<Defaults> & Omit<Prettify<ResolvedProps> & PublicProps, keyof Defaults> : Prettify<ResolvedProps> & PublicProps, Emits, Slots, Exposed, TypeBlock, TypeRefs>> & ObjectVaporComponent<RuntimePropsOptions | RuntimePropsKeys[], Emits, RuntimeEmitsKeys, Slots, Exposed>;
+type DefineVaporSetupFnComponent<Props extends Record<string, any> = {}, Emits extends EmitsOptions = {}, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, ResolvedProps extends Record<string, any> = Props & EmitsToProps<Emits> & VaporPublicProps> = new (props?: ResolvedProps) => VaporComponentInstance<ResolvedProps, Emits, Slots, Exposed, TypeBlock>;
+export declare function defineVaporComponent<Props extends Record<string, any>, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block>(setup: (props: Props, ctx: {
+    emit: EmitFn<Emits>;
+    slots: Slots;
+    attrs: Record<string, any>;
+    expose: (exposed: Exposed) => void;
+}) => VaporRenderResult<TypeBlock> | void, extraOptions?: ObjectVaporComponent<(keyof Props)[], Emits, RuntimeEmitsKeys, Slots, Exposed> & ThisType<void>): DefineVaporSetupFnComponent<Props, Emits, Slots, Exposed, TypeBlock>;
+export declare function defineVaporComponent<Props extends Record<string, any>, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block>(setup: (props: Props, ctx: {
+    emit: EmitFn<Emits>;
+    slots: Slots;
+    attrs: Record<string, any>;
+    expose: (exposed: Exposed) => void;
+}) => VaporRenderResult<TypeBlock> | void, extraOptions?: ObjectVaporComponent<ComponentObjectPropsOptions<Props>, Emits, RuntimeEmitsKeys, Slots, Exposed> & ThisType<void>): DefineVaporSetupFnComponent<Props, Emits, Slots, Exposed, TypeBlock>;
+export declare function defineVaporComponent<TypeProps, RuntimePropsOptions extends ComponentObjectPropsOptions = ComponentObjectPropsOptions, RuntimePropsKeys extends string = string, TypeEmits extends ComponentTypeEmits = {}, RuntimeEmitsOptions extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, ResolvedEmits extends EmitsOptions = {} extends RuntimeEmitsOptions ? TypeEmitsToOptions<TypeEmits> : RuntimeEmitsOptions, InferredProps = IsKeyValues<TypeProps> extends true ? TypeProps : string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : {
+    [key in RuntimePropsKeys]?: any;
+}, TypeRefs extends Record<string, unknown> = {}, TypeBlock extends Block = Block>(options: ObjectVaporComponent<RuntimePropsOptions | RuntimePropsKeys[], ResolvedEmits, RuntimeEmitsKeys, Slots, Exposed, TypeBlock, InferredProps> & {
+    /**
+     * @private for language-tools use only
+     */
+    __typeProps?: TypeProps;
+    /**
+     * @private for language-tools use only
+     */
+    __typeEmits?: TypeEmits;
+    /**
+     * @private for language-tools use only
+     */
+    __typeRefs?: TypeRefs;
+    /**
+     * @private for language-tools use only
+     */
+    __typeEl?: TypeBlock;
+} & ThisType<void>): DefineVaporComponent<RuntimePropsOptions, RuntimePropsKeys, ResolvedEmits, RuntimeEmitsKeys, Slots, Exposed extends Block ? Record<string, any> : Exposed, TypeBlock, TypeRefs, unknown extends TypeProps ? true : false, InferredProps>;
+
+export type VaporComponent = FunctionalVaporComponent | ObjectVaporComponent | DefineVaporComponent;
+export type FunctionalVaporComponent<Props = {}, Emits extends EmitsOptions = {}, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>> = ((props: Readonly<Props & EmitsToProps<Emits>>, ctx: {
+    emit: EmitFn<Emits>;
+    slots: Slots;
+    attrs: Record<string, any>;
+    expose: <T extends Record<string, any> = Exposed>(exposed: T) => void;
+}) => VaporRenderResult) & Omit<ObjectVaporComponent<ComponentPropsOptions<Props>, Emits, string, Slots>, 'setup'> & {
     displayName?: string;
 } & SharedInternalOptions;
-interface ObjectVaporComponent extends ComponentInternalOptions, AsyncComponentInternalOptions<ObjectVaporComponent, VaporComponentInstance>, SharedInternalOptions {
-    setup?: VaporSetupFn;
+interface ObjectVaporComponent<Props = {}, Emits extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, InferredProps = ComponentObjectPropsOptions extends Props ? {} : ExtractPropTypes<Props>> extends ComponentInternalOptions, AsyncComponentInternalOptions<ObjectVaporComponent, VaporComponentInstance>, SharedInternalOptions {
     inheritAttrs?: boolean;
-    props?: ComponentPropsOptions;
-    emits?: EmitsOptions;
-    render?(ctx: any, props?: any, emit?: EmitFn, attrs?: any, slots?: Record<string, VaporSlot>): Block;
+    props?: Props;
+    emits?: Emits | RuntimeEmitsKeys[];
+    slots?: Slots;
+    setup?: (props: Readonly<InferredProps>, ctx: {
+        emit: EmitFn<Emits>;
+        slots: Slots;
+        attrs: Record<string, any>;
+        expose: <T extends Record<string, any> = Exposed>(exposed: T) => void;
+    }) => TypeBlock | Exposed | Promise<Exposed> | void;
+    render?(ctx: Exposed extends Block ? undefined : ShallowUnwrapRef<Exposed>, props: Readonly<InferredProps>, emit: EmitFn<Emits>, attrs: any, slots: Slots): VaporRenderResult<TypeBlock> | void;
     name?: string;
     vapor?: boolean;
+    components?: Record<string, VaporComponent>;
 }
 interface SharedInternalOptions {
     /**
@@ -168,33 +232,36 @@ type LooseRawSlots = Record<string, VaporSlot | DynamicSlotSource[]> & {
     $?: DynamicSlotSource[];
 };
 export declare function createComponent(component: VaporComponent, rawProps?: LooseRawProps | null, rawSlots?: LooseRawSlots | null, isSingleRoot?: boolean, once?: boolean, appContext?: GenericAppContext): VaporComponentInstance;
-declare class VaporComponentInstance implements GenericComponentInstance {
+export declare class VaporComponentInstance<Props extends Record<string, any> = {}, Emits extends EmitsOptions = {}, Slots extends StaticSlots = StaticSlots, Exposed extends Record<string, any> = Record<string, any>, TypeBlock extends Block = Block, TypeRefs extends Record<string, any> = Record<string, any>> implements GenericComponentInstance {
     vapor: true;
     uid: number;
     type: VaporComponent;
     root: GenericComponentInstance | null;
     parent: GenericComponentInstance | null;
     appContext: GenericAppContext;
-    block: Block;
+    block: TypeBlock;
     scope: EffectScope$1;
     rawProps: RawProps;
     rawSlots: RawSlots;
-    props: Record<string, any>;
+    props: Readonly<Props>;
     attrs: Record<string, any>;
     propsDefaults: Record<string, any> | null;
-    slots: StaticSlots;
+    slots: Slots;
     scopeId?: string | null;
     rawPropsRef?: ShallowRef<any>;
     rawSlotsRef?: ShallowRef<any>;
-    emit: EmitFn;
+    emit: EmitFn<Emits>;
     emitted: Record<string, boolean> | null;
-    expose: (exposed: Record<string, any>) => void;
-    exposed: Record<string, any> | null;
-    exposeProxy: Record<string, any> | null;
-    refs: Record<string, any>;
+    expose: (<T extends Record<string, any> = Exposed>(exposed: T) => void) & string[];
+    exposed: Exposed | null;
+    exposeProxy: Prettify<ShallowUnwrapRef<Exposed>> | null;
+    refs: TypeRefs;
     provides: Record<string, any>;
     ids: [string, number, number];
     suspense: SuspenseBoundary | null;
+    suspenseId: number;
+    asyncDep: Promise<any> | null;
+    asyncResolved: boolean;
     renderEffects?: RenderEffect[];
     hasFallthrough: boolean;
     shapeFlag?: number;
@@ -216,7 +283,7 @@ declare class VaporComponentInstance implements GenericComponentInstance {
     rtc?: LifecycleHook;
     ec?: LifecycleHook;
     sp?: LifecycleHook<() => Promise<unknown>>;
-    setupState?: Record<string, any>;
+    setupState?: Exposed extends Block ? undefined : ShallowUnwrapRef<Exposed>;
     devtoolsRawSetupState?: any;
     hmrRerender?: () => void;
     hmrReload?: (newComp: VaporComponent) => void;
@@ -224,7 +291,13 @@ declare class VaporComponentInstance implements GenericComponentInstance {
     propsOptions?: NormalizedPropsOptions;
     emitsOptions?: ObjectEmitsOptions | null;
     isSingleRoot?: boolean;
-    constructor(comp: VaporComponent, rawProps?: RawProps | null, rawSlots?: RawSlots | null, appContext?: GenericAppContext, once?: boolean, parent?: GenericComponentInstance | null);
+    /**
+     * dev only flag to track whether $attrs was used during render.
+     * If $attrs was used during render then the warning for failed attrs
+     * fallthrough can be suppressed.
+     */
+    accessedAttrs: boolean;
+    constructor(comp: VaporComponent, rawProps?: RawProps | null, rawSlots?: RawSlots | null, appContext?: GenericAppContext, once?: boolean);
     /**
      * Expose `getKeysFromRawProps` on the instance so it can be used in code
      * paths where it's needed, e.g. `useModel`
@@ -243,9 +316,6 @@ export declare function createPlainElement(comp: string, rawProps?: LooseRawProp
 export declare const createVaporApp: CreateAppFunction<ParentNode, VaporComponent>;
 export declare const createVaporSSRApp: CreateAppFunction<ParentNode, VaporComponent>;
 
-/*! #__NO_SIDE_EFFECTS__ */
-export declare function defineVaporComponent(comp: VaporComponent, extraOptions?: Omit<ObjectVaporComponent, 'setup'>): VaporComponent;
-
 export declare function defineVaporAsyncComponent<T extends VaporComponent>(source: AsyncComponentLoader<T> | AsyncComponentOptions<T>): T;
 
 export type VaporDirective = (node: Element | VaporComponentInstance, value?: () => any, argument?: string, modifiers?: DirectiveModifiers) => (() => void) | void;
@@ -259,17 +329,42 @@ export declare function withVaporDirectives(node: Element | VaporComponentInstan
 
 export declare const VaporKeepAliveImpl: ObjectVaporComponent;
 
-type VaporElementConstructor<P = {}> = {
+export type VaporElementConstructor<P = {}> = {
     new (initialProps?: Record<string, any>): VaporElement & P;
 };
-export declare function defineVaporCustomElement(options: any, extraOptions?: Omit<ObjectVaporComponent, 'setup'>, 
-/**
- * @internal
- */
-_createApp?: CreateAppFunction<ParentNode, VaporComponent>): VaporElementConstructor;
+export declare function defineVaporCustomElement<Props, RawBindings = object>(setup: (props: Props, ctx: {
+    attrs: Record<string, any>;
+    slots: StaticSlots;
+    emit: EmitFn;
+    expose: (exposed: Record<string, any>) => void;
+}) => RawBindings | VaporRenderResult, options?: Pick<ObjectVaporComponent, 'name' | 'inheritAttrs' | 'emits'> & CustomElementOptions & {
+    props?: (keyof Props)[];
+}): VaporElementConstructor<Props>;
+export declare function defineVaporCustomElement<Props, RawBindings = object>(setup: (props: Props, ctx: {
+    attrs: Record<string, any>;
+    slots: StaticSlots;
+    emit: EmitFn;
+    expose: (exposed: Record<string, any>) => void;
+}) => RawBindings | VaporRenderResult, options?: Pick<ObjectVaporComponent, 'name' | 'inheritAttrs' | 'emits'> & CustomElementOptions & {
+    props?: ComponentObjectPropsOptions<Props>;
+}): VaporElementConstructor<Props>;
+export declare function defineVaporCustomElement<RuntimePropsOptions extends ComponentObjectPropsOptions = ComponentObjectPropsOptions, RuntimePropsKeys extends string = string, RuntimeEmitsOptions extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Slots extends StaticSlots = StaticSlots, InferredProps = string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : {
+    [key in RuntimePropsKeys]?: any;
+}, ResolvedProps = InferredProps & EmitsToProps<RuntimeEmitsOptions>>(options: CustomElementOptions & {
+    props?: (RuntimePropsOptions & ThisType<void>) | RuntimePropsKeys[];
+    emits?: RuntimeEmitsOptions | RuntimeEmitsKeys[];
+    slots?: Slots;
+    setup?: (props: Readonly<InferredProps>, ctx: {
+        attrs: Record<string, any>;
+        slots: Slots;
+        emit: EmitFn<RuntimeEmitsOptions>;
+        expose: (exposed: Record<string, any>) => void;
+    }) => any;
+} & ThisType<void>, extraOptions?: CustomElementOptions): VaporElementConstructor<ResolvedProps>;
+export declare function defineVaporCustomElement<T extends DefineVaporComponent<any, any, any, any, any, any, any, any, any, any> | DefineVaporSetupFnComponent<any, any, any, any, any>>(options: T, extraOptions?: CustomElementOptions): VaporElementConstructor<T extends DefineVaporComponent<infer RuntimePropsOptions, any, any, any, any, any, any, any, any, any> ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : T extends DefineVaporSetupFnComponent<infer P extends Record<string, any>, any, any, any, any> ? P : unknown>;
 export declare const defineVaporSSRCustomElement: typeof defineVaporCustomElement;
 type VaporInnerComponentDef = VaporComponent & CustomElementOptions;
-declare class VaporElement extends VueElementBase<ParentNode, VaporComponent, VaporInnerComponentDef> {
+export declare class VaporElement extends VueElementBase<ParentNode, VaporComponent, VaporInnerComponentDef> {
     constructor(def: VaporInnerComponentDef, props?: Record<string, any> | undefined, createAppFn?: CreateAppFunction<ParentNode, VaporComponent>);
     protected _needsHydration(): boolean;
     protected _mount(def: VaporInnerComponentDef): void;
@@ -353,7 +448,7 @@ export declare function setBlockHtml(block: Block & {
 }, value: any): void;
 export declare function setDynamicProps(el: any, args: any[], isSVG?: boolean): void;
 
-export declare function on(el: Element, event: string, handler: (e: Event) => any, options?: AddEventListenerOptions & {
+export declare function on(el: Element, event: string, handler: (e: Event) => any | ((e: Event) => any)[], options?: AddEventListenerOptions & {
     effect?: boolean;
 }): void;
 export declare function delegate(el: any, event: string, handler: (e: Event) => any): void;
@@ -388,7 +483,7 @@ export declare const applyRadioModel: VaporModelDirective<HTMLInputElement>;
 export declare const applySelectModel: VaporModelDirective<HTMLSelectElement, 'number'>;
 export declare const applyDynamicModel: VaporModelDirective;
 
-export declare const VaporTransition: FunctionalVaporComponent;
+export declare const VaporTransition: FunctionalVaporComponent<TransitionProps>;
 
 export declare const VaporTransitionGroup: ObjectVaporComponent;