yuyeon 0.3.1-rc.4 → 0.3.1-rc.5

package/types/globals.d.ts

@@ -1,21 +1,21 @@
 import { VNode } from 'vue';
-
-
-declare global {
-  namespace JSX {
-    interface Element extends VNode {}
-
-    interface IntrinsicAttributes {
-      [name: string]: any
-    }
-  }
-}
-
-declare module '@vue/runtime-core' {
-  export interface ComponentCustomProperties {
-  }
-
-  export interface ComponentInternalInstance {
-    provides: Record<string, unknown>
-  }
-}
+
+
+declare global {
+  namespace JSX {
+    interface Element extends VNode {}
+
+    interface IntrinsicAttributes {
+      [name: string]: any
+    }
+  }
+}
+
+declare module '@vue/runtime-core' {
+  export interface ComponentCustomProperties {
+  }
+
+  export interface ComponentInternalInstance {
+    provides: Record<string, unknown>
+  }
+}

package/types/shims.d.ts

@@ -1,56 +1,56 @@
 import { YAlert, YApp, YBadge, YButton, YCard, YCardBody, YCardFooter, YCardHeader, YCheckbox, YChip, YDataTable, YDataTableServer, YDateCalendar, YDatePicker, YDialog, YDividePanel, YDivider, YDropdown, YExpandHTransition, YExpandVTransition, YFieldInput, YForm, YHover, YIcon, YInput, YInputCheckbox, YIpv4Field, YLayer, YList, YListItem, YMenu, YMonthPicker, YPagination, YProgressBar, YSelect, YSnackbar, YSpinnerRing, YSwitch, YTab, YTable, YTabs, YTextHighlighter, YTextarea, YTi, YTooltip, YTreeView, YTreeViewNode, YProgressRing } from 'yuyeon/components';
-
-
-declare module '@vue/runtime-core' {
-  export interface GlobalComponents {
-    // @define-components
-    YApp: typeof YApp;
-    YButton: typeof YButton;
-    YChip: typeof YChip;
-    YInput: typeof YInput;
-    YFieldInput: typeof YFieldInput;
-    YTextarea: typeof YTextarea;
-    YForm: typeof YForm;
-    YCard: typeof YCard;
-    YCardBody: typeof YCardBody;
-    YCardHeader: typeof YCardHeader;
-    YCardFooter: typeof YCardFooter;
-    YDialog: typeof YDialog;
-    YLayer: typeof YLayer;
-    YSnackbar: typeof YSnackbar;
-    YProgressBar: typeof YProgressBar;
-    YSpinnerRing: typeof YSpinnerRing;
-    YTooltip: typeof YTooltip;
-    YExpandVTransition: typeof YExpandVTransition;
-    YExpandHTransition: typeof YExpandHTransition;
-    YDividePanel: typeof YDividePanel;
-    YList: typeof YList;
-    YListItem: typeof YListItem;
-    YTreeView: typeof YTreeView;
-    YTreeViewNode: typeof YTreeViewNode;
-    YDataTable: typeof YDataTable;
-    YTable: typeof YTable;
-    YDataTableServer: typeof YDataTableServer;
-    YMenu: typeof YMenu;
-    YPagination: typeof YPagination;
-    YInputCheckbox: typeof YInputCheckbox;
-    YCheckbox: typeof YCheckbox;
-    YSwitch: typeof YSwitch;
-    YDropdown: typeof YDropdown;
-    YSelect: typeof YSelect;
-    YAlert: typeof YAlert;
-    YTabs: typeof YTabs;
-    YTab: typeof YTab;
-    YDivider: typeof YDivider;
-    YDateCalendar: typeof YDateCalendar;
-    YIcon: typeof YIcon;
-    YDatePicker: typeof YDatePicker;
-    YMonthPicker: typeof YMonthPicker;
-    YBadge: typeof YBadge;
-    YIpv4Field: typeof YIpv4Field;
-    YHover: typeof YHover;
-    YTi: typeof YTi;
-    YTextHighlighter: typeof YTextHighlighter;
-    YProgressRing: typeof YProgressRing;
-  }
-}
+
+
+declare module '@vue/runtime-core' {
+  export interface GlobalComponents {
+    // @define-components
+    YApp: typeof YApp;
+    YButton: typeof YButton;
+    YChip: typeof YChip;
+    YInput: typeof YInput;
+    YFieldInput: typeof YFieldInput;
+    YTextarea: typeof YTextarea;
+    YForm: typeof YForm;
+    YCard: typeof YCard;
+    YCardBody: typeof YCardBody;
+    YCardHeader: typeof YCardHeader;
+    YCardFooter: typeof YCardFooter;
+    YDialog: typeof YDialog;
+    YLayer: typeof YLayer;
+    YSnackbar: typeof YSnackbar;
+    YProgressBar: typeof YProgressBar;
+    YSpinnerRing: typeof YSpinnerRing;
+    YTooltip: typeof YTooltip;
+    YExpandVTransition: typeof YExpandVTransition;
+    YExpandHTransition: typeof YExpandHTransition;
+    YDividePanel: typeof YDividePanel;
+    YList: typeof YList;
+    YListItem: typeof YListItem;
+    YTreeView: typeof YTreeView;
+    YTreeViewNode: typeof YTreeViewNode;
+    YDataTable: typeof YDataTable;
+    YTable: typeof YTable;
+    YDataTableServer: typeof YDataTableServer;
+    YMenu: typeof YMenu;
+    YPagination: typeof YPagination;
+    YInputCheckbox: typeof YInputCheckbox;
+    YCheckbox: typeof YCheckbox;
+    YSwitch: typeof YSwitch;
+    YDropdown: typeof YDropdown;
+    YSelect: typeof YSelect;
+    YAlert: typeof YAlert;
+    YTabs: typeof YTabs;
+    YTab: typeof YTab;
+    YDivider: typeof YDivider;
+    YDateCalendar: typeof YDateCalendar;
+    YIcon: typeof YIcon;
+    YDatePicker: typeof YDatePicker;
+    YMonthPicker: typeof YMonthPicker;
+    YBadge: typeof YBadge;
+    YIpv4Field: typeof YIpv4Field;
+    YHover: typeof YHover;
+    YTi: typeof YTi;
+    YTextHighlighter: typeof YTextHighlighter;
+    YProgressRing: typeof YProgressRing;
+  }
+}

package/types/util/color/hct/hct_solver.d.ts

@@ -0,0 +1,146 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Cam16 } from './cam16';
+/**
+ * A class that solves the HCT equation.
+ */
+export declare class HctSolver {
+    static SCALED_DISCOUNT_FROM_LINRGB: number[][];
+    static LINRGB_FROM_SCALED_DISCOUNT: number[][];
+    static Y_FROM_LINRGB: number[];
+    static CRITICAL_PLANES: number[];
+    /**
+     * Sanitizes a small enough angle in radians.
+     *
+     * @param angle An angle in radians; must not deviate too much
+     * from 0.
+     * @return A coterminal angle between 0 and 2pi.
+     */
+    private static sanitizeRadians;
+    /**
+     * Delinearizes an RGB component, returning a floating-point
+     * number.
+     *
+     * @param rgbComponent 0.0 <= rgb_component <= 100.0, represents
+     * linear R/G/B channel
+     * @return 0.0 <= output <= 255.0, color channel converted to
+     * regular RGB space
+     */
+    private static trueDelinearized;
+    private static chromaticAdaptation;
+    /**
+     * Returns the hue of a linear RGB color in CAM16.
+     *
+     * @param linrgb The linear RGB coordinates of a color.
+     * @return The hue of the color in CAM16, in radians.
+     */
+    private static hueOf;
+    private static areInCyclicOrder;
+    /**
+     * Solves the lerp equation.
+     *
+     * @param source The starting number.
+     * @param mid The number in the middle.
+     * @param target The ending number.
+     * @return A number t such that lerp(source, target, t) = mid.
+     */
+    private static intercept;
+    private static lerpPoint;
+    /**
+     * Intersects a segment with a plane.
+     *
+     * @param source The coordinates of point A.
+     * @param coordinate The R-, G-, or B-coordinate of the plane.
+     * @param target The coordinates of point B.
+     * @param axis The axis the plane is perpendicular with. (0: R, 1:
+     * G, 2: B)
+     * @return The intersection point of the segment AB with the plane
+     * R=coordinate, G=coordinate, or B=coordinate
+     */
+    private static setCoordinate;
+    private static isBounded;
+    /**
+     * Returns the nth possible vertex of the polygonal intersection.
+     *
+     * @param y The Y value of the plane.
+     * @param n The zero-based index of the point. 0 <= n <= 11.
+     * @return The nth possible vertex of the polygonal intersection
+     * of the y plane and the RGB cube, in linear RGB coordinates, if
+     * it exists. If this possible vertex lies outside of the cube,
+     * [-1.0, -1.0, -1.0] is returned.
+     */
+    private static nthVertex;
+    /**
+     * Finds the segment containing the desired color.
+     *
+     * @param y The Y value of the color.
+     * @param targetHue The hue of the color.
+     * @return A list of two sets of linear RGB coordinates, each
+     * corresponding to an endpoint of the segment containing the
+     * desired color.
+     */
+    private static bisectToSegment;
+    private static midpoint;
+    private static criticalPlaneBelow;
+    private static criticalPlaneAbove;
+    /**
+     * Finds a color with the given Y and hue on the boundary of the
+     * cube.
+     *
+     * @param y The Y value of the color.
+     * @param targetHue The hue of the color.
+     * @return The desired color, in linear RGB coordinates.
+     */
+    private static bisectToLimit;
+    private static inverseChromaticAdaptation;
+    /**
+     * Finds a color with the given hue, chroma, and Y.
+     *
+     * @param hueRadians The desired hue in radians.
+     * @param chroma The desired chroma.
+     * @param y The desired Y.
+     * @return The desired color as a hexadecimal integer, if found; 0
+     * otherwise.
+     */
+    private static findResultByJ;
+    /**
+     * Finds an sRGB color with the given hue, chroma, and L*, if
+     * possible.
+     *
+     * @param hueDegrees The desired hue, in degrees.
+     * @param chroma The desired chroma.
+     * @param lstar The desired L*.
+     * @return A hexadecimal representing the sRGB color. The color
+     * has sufficiently close hue, chroma, and L* to the desired
+     * values, if possible; otherwise, the hue and L* will be
+     * sufficiently close, and chroma will be maximized.
+     */
+    static solveToInt(hueDegrees: number, chroma: number, lstar: number): number;
+    /**
+     * Finds an sRGB color with the given hue, chroma, and L*, if
+     * possible.
+     *
+     * @param hueDegrees The desired hue, in degrees.
+     * @param chroma The desired chroma.
+     * @param lstar The desired L*.
+     * @return An CAM16 object representing the sRGB color. The color
+     * has sufficiently close hue, chroma, and L* to the desired
+     * values, if possible; otherwise, the hue and L* will be
+     * sufficiently close, and chroma will be maximized.
+     */
+    static solveToCam(hueDegrees: number, chroma: number, lstar: number): Cam16;
+}

package/types/util/color/hct/viewing_conditions.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * In traditional color spaces, a color can be identified solely by the
+ * observer's measurement of the color. Color appearance models such as CAM16
+ * also use information about the environment where the color was
+ * observed, known as the viewing conditions.
+ *
+ * For example, white under the traditional assumption of a midday sun white
+ * point is accurately measured as a slightly chromatic blue by CAM16. (roughly,
+ * hue 203, chroma 3, lightness 100)
+ *
+ * This class caches intermediate values of the CAM16 conversion process that
+ * depend only on viewing conditions, enabling speed ups.
+ */
+export declare class ViewingConditions {
+    n: number;
+    aw: number;
+    nbb: number;
+    ncb: number;
+    c: number;
+    nc: number;
+    rgbD: number[];
+    fl: number;
+    fLRoot: number;
+    z: number;
+    /** sRGB-like viewing conditions.  */
+    static DEFAULT: ViewingConditions;
+    /**
+     * Create ViewingConditions from a simple, physically relevant, set of
+     * parameters.
+     *
+     * @param whitePoint White point, measured in the XYZ color space.
+     *     default = D65, or sunny day afternoon
+     * @param adaptingLuminance The luminance of the adapting field. Informally,
+     *     how bright it is in the room where the color is viewed. Can be
+     *     calculated from lux by multiplying lux by 0.0586. default = 11.72,
+     *     or 200 lux.
+     * @param backgroundLstar The lightness of the area surrounding the color.
+     *     measured by L* in L*a*b*. default = 50.0
+     * @param surround A general description of the lighting surrounding the
+     *     color. 0 is pitch dark, like watching a movie in a theater. 1.0 is a
+     *     dimly light room, like watching TV at home at night. 2.0 means there
+     *     is no difference between the lighting on the color and around it.
+     *     default = 2.0
+     * @param discountingIlluminant Whether the eye accounts for the tint of the
+     *     ambient lighting, such as knowing an apple is still red in green light.
+     *     default = false, the eye does not perform this process on
+     *       self-luminous objects like displays.
+     */
+    static make(whitePoint?: number[], adaptingLuminance?: number, backgroundLstar?: number, surround?: number, discountingIlluminant?: boolean): ViewingConditions;
+    /**
+     * Parameters are intermediate values of the CAM16 conversion process. Their
+     * names are shorthand for technical color science terminology, this class
+     * would not benefit from documenting them individually. A brief overview
+     * is available in the CAM16 specification, and a complete overview requires
+     * a color science textbook, such as Fairchild's Color Appearance Models.
+     */
+    private constructor();
+}

package/types/util/color/palettes/tonal_palette.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Hct } from '../hct/hct';
+/**
+ *  A convenience class for retrieving colors that are constant in hue and
+ *  chroma, but vary in tone.
+ */
+export declare class TonalPalette {
+    readonly hue: number;
+    readonly chroma: number;
+    readonly keyColor: Hct;
+    private readonly cache;
+    /**
+     * @param argb ARGB representation of a color
+     * @return Tones matching that color's hue and chroma.
+     */
+    static fromInt(argb: number): TonalPalette;
+    /**
+     * @param hct Hct
+     * @return Tones matching that color's hue and chroma.
+     */
+    static fromHct(hct: Hct): TonalPalette;
+    /**
+     * @param hue HCT hue
+     * @param chroma HCT chroma
+     * @return Tones matching hue and chroma.
+     */
+    static fromHueAndChroma(hue: number, chroma: number): TonalPalette;
+    private constructor();
+    private static createKeyColor;
+    /**
+     * @param tone HCT tone, measured from 0 to 100.
+     * @return ARGB representation of a color with that tone.
+     */
+    tone(tone: number): number;
+    /**
+     * @param tone HCT tone.
+     * @return HCT representation of a color with that tone.
+     */
+    getHct(tone: number): Hct;
+}

package/types/util/color/utils/math_utils.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Utility methods for mathematical operations.
+ */
+/**
+ * The signum function.
+ *
+ * @return 1 if num > 0, -1 if num < 0, and 0 if num = 0
+ */
+export declare function signum(num: number): number;
+/**
+ * The linear interpolation function.
+ *
+ * @return start if amount = 0 and stop if amount = 1
+ */
+export declare function lerp(start: number, stop: number, amount: number): number;
+/**
+ * Clamps an integer between two integers.
+ *
+ * @return input when min <= input <= max, and either min or max
+ * otherwise.
+ */
+export declare function clampInt(min: number, max: number, input: number): number;
+/**
+ * Clamps an integer between two floating-point numbers.
+ *
+ * @return input when min <= input <= max, and either min or max
+ * otherwise.
+ */
+export declare function clampDouble(min: number, max: number, input: number): number;
+/**
+ * Sanitizes a degree measure as an integer.
+ *
+ * @return a degree measure between 0 (inclusive) and 360
+ * (exclusive).
+ */
+export declare function sanitizeDegreesInt(degrees: number): number;
+/**
+ * Sanitizes a degree measure as a floating-point number.
+ *
+ * @return a degree measure between 0.0 (inclusive) and 360.0
+ * (exclusive).
+ */
+export declare function sanitizeDegreesDouble(degrees: number): number;
+/**
+ * Sign of direction change needed to travel from one angle to
+ * another.
+ *
+ * For angles that are 180 degrees apart from each other, both
+ * directions have the same travel distance, so either direction is
+ * shortest. The value 1.0 is returned in this case.
+ *
+ * @param from The angle travel starts from, in degrees.
+ * @param to The angle travel ends at, in degrees.
+ * @return -1 if decreasing from leads to the shortest travel
+ * distance, 1 if increasing from leads to the shortest travel
+ * distance.
+ */
+export declare function rotationDirection(from: number, to: number): number;
+/**
+ * Distance of two points on a circle, represented using degrees.
+ */
+export declare function differenceDegrees(a: number, b: number): number;
+/**
+ * Multiplies a 1x3 row vector with a 3x3 matrix.
+ */
+export declare function matrixMultiply(row: number[], matrix: number[][]): number[];

package/types/util/parser.d.ts

@@ -0,0 +1,4 @@
+export declare function simpleBraceParse(input: string): {
+    type: string;
+    content: string;
+}[];

package/types/util/vue-component/index.d.ts

@@ -0,0 +1,10 @@
+import { ComponentInternalInstance } from '@vue/runtime-core';
+import { ComponentPublicInstance, InjectionKey, VNode, VNodeChild } from 'vue';
+
+export { type EventProp } from './types';
+export * from './props';
+export declare function getSlot(vm: ComponentPublicInstance | any, name?: string, data?: any | (() => any), optional?: boolean): VNode[] | undefined;
+export declare function getUid(): number | undefined;
+export declare function bindClasses(classes: string | string[] | Record<string, any> | undefined): Record<string, boolean>;
+export declare function getHtmlElement<N extends object | undefined>(node: N): Exclude<N, ComponentPublicInstance> | HTMLElement;
+export declare function findChildrenWithProvide(key: InjectionKey<any> | symbol, vnode?: VNodeChild): ComponentInternalInstance[];

package/types/util/vue-component/props.d.ts

@@ -0,0 +1,31 @@
+import { IfAny } from '@vue/shared';
+import { ComponentObjectPropsOptions, ExtractPropTypes, Prop, PropType } from 'vue';
+
+export declare function propsFactory<PropsOptions extends ComponentObjectPropsOptions>(props: PropsOptions, source: string): <Defaults extends PartialKeys<PropsOptions> = {}>(defaults?: Defaults) => OverwrittenPropOptions<PropsOptions, Defaults>;
+export declare function chooseProps<PropsOptions extends ComponentObjectPropsOptions>(props: any, target: PropsOptions): ExtractPropTypes<PropsOptions>;
+export declare function hasEventProp(props: Record<string, any>, type: string): boolean;
+type OverwrittenPropOptions<T extends ComponentObjectPropsOptions, D extends PartialKeys<T>> = {
+    [P in keyof T]-?: unknown extends D[P] ? T[P] : T[P] extends Record<string, unknown> ? Omit<T[P], 'type' | 'default'> & {
+        type: PropType<MergeDefault<T[P], D[P]>>;
+        default: MergeDefault<T[P], D[P]>;
+    } : {
+        type: PropType<MergeDefault<T[P], D[P]>>;
+        default: MergeDefault<T[P], D[P]>;
+    };
+};
+type MergeDefault<T, D> = unknown extends D ? InferPropType<T> : NonNullable<InferPropType<T>> | D;
+type PartialKeys<T> = {
+    [P in keyof T]?: unknown;
+};
+type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
+    type: null | true;
+}] ? any : [T] extends [ObjectConstructor | {
+    type: ObjectConstructor;
+}] ? Record<string, any> : [T] extends [BooleanConstructor | {
+    type: BooleanConstructor;
+}] ? boolean : [T] extends [DateConstructor | {
+    type: DateConstructor;
+}] ? Date : [T] extends [(infer U)[] | {
+    type: (infer U)[];
+}] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? IfAny<V, V, D> : V : T;
+export {};

package/types/util/vue-component/types.d.ts

@@ -0,0 +1,4 @@
+import { PropType } from 'vue';
+
+export type EventProp<T extends any[] = any[], F = (...args: T) => any> = F | F[];
+export declare const EventPropOption: <T extends any[] = any[]>() => PropType<EventProp<T, (...args: T) => any>>;

package/types/util/vue-component.d.ts

@@ -0,0 +1,39 @@
+import { ComponentInternalInstance } from '@vue/runtime-core';
+import { IfAny } from '@vue/shared';
+import { ComponentObjectPropsOptions, ComponentPublicInstance, ExtractPropTypes, InjectionKey, Prop, PropType, VNode, VNodeChild } from 'vue';
+
+export declare function getSlot(vm: ComponentPublicInstance | any, name?: string, data?: any | (() => any), optional?: boolean): VNode[] | undefined;
+export declare function getUid(): number | undefined;
+export declare function chooseProps<PropsOptions extends ComponentObjectPropsOptions>(props: any, target: PropsOptions): ExtractPropTypes<PropsOptions>;
+export declare function bindClasses(classes: string | string[] | Record<string, any> | undefined): Record<string, boolean>;
+export declare function getHtmlElement<N extends object | undefined>(node: N): Exclude<N, ComponentPublicInstance> | HTMLElement;
+export declare function findChildrenWithProvide(key: InjectionKey<any> | symbol, vnode?: VNodeChild): ComponentInternalInstance[];
+export declare function propsFactory<PropsOptions extends ComponentObjectPropsOptions>(props: PropsOptions, source: string): <Defaults extends PartialKeys<PropsOptions> = {}>(defaults?: Defaults) => OverwrittenPropOptions<PropsOptions, Defaults>;
+export declare function hasEventProp(props: Record<string, any>, type: string): boolean;
+type OverwrittenPropOptions<T extends ComponentObjectPropsOptions, D extends PartialKeys<T>> = {
+    [P in keyof T]-?: unknown extends D[P] ? T[P] : T[P] extends Record<string, unknown> ? Omit<T[P], 'type' | 'default'> & {
+        type: PropType<MergeDefault<T[P], D[P]>>;
+        default: MergeDefault<T[P], D[P]>;
+    } : {
+        type: PropType<MergeDefault<T[P], D[P]>>;
+        default: MergeDefault<T[P], D[P]>;
+    };
+};
+type MergeDefault<T, D> = unknown extends D ? InferPropType<T> : NonNullable<InferPropType<T>> | D;
+type PartialKeys<T> = {
+    [P in keyof T]?: unknown;
+};
+type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
+    type: null | true;
+}] ? any : [T] extends [ObjectConstructor | {
+    type: ObjectConstructor;
+}] ? Record<string, any> : [T] extends [BooleanConstructor | {
+    type: BooleanConstructor;
+}] ? boolean : [T] extends [DateConstructor | {
+    type: DateConstructor;
+}] ? Date : [T] extends [(infer U)[] | {
+    type: (infer U)[];
+}] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? IfAny<V, V, D> : V : T;
+export type EventProp<T extends any[] = any[], F = (...args: T) => any> = F | F[];
+export declare const EventPropOption: <T extends any[] = any[]>() => PropType<EventProp<T, (...args: T) => any>>;
+export {};