import type { IfAny } from '@vue/shared';
import type { Prop, VNode } from 'vue';
import type { VueTypeDef, VueTypeValidableDef } from 'vue-types';
import type { InferType, VueProp, Prop as VueTypeProp } from 'vue-types/dist/types';
import { arrayOf, custom, instanceOf, objectOf, shape } from 'vue-types';
export declare type MaybeArray<T> = T | T[];
declare type PublicRequiredKeys<T> = {
    [K in keyof T]: T[K] extends {
        required: true;
    } ? K : never;
}[keyof T];
declare type PublicOptionalKeys<T> = Exclude<keyof T, PublicRequiredKeys<T>>;
declare type InnerRequiredKeys<T> = {
    [K in keyof T]: T[K] extends {
        required: true;
    } | {
        default: any;
    } ? T[K] extends {
        default: undefined;
    } ? never : K : never;
}[keyof T];
declare type InnerOptionalKeys<T> = Exclude<keyof T, InnerRequiredKeys<T>>;
declare 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 declare type ExtractPublicPropTypes<O> = {
    [K in keyof Pick<O, PublicRequiredKeys<O>>]: InferPropType<O[K]>;
} & {
    [K in keyof Pick<O, PublicOptionalKeys<O>>]?: InferPropType<O[K]>;
};
export declare type ExtractInnerPropTypes<O> = {
    [K in keyof Pick<O, InnerRequiredKeys<O>>]: InferPropType<O[K]>;
} & {
    [K in keyof Pick<O, InnerOptionalKeys<O>>]?: InferPropType<O[K]>;
};
export declare class IxPropTypes {
    static get any(): VueTypeValidableDef<any>;
    static get bool(): VueTypeValidableDef<boolean>;
    static get string(): VueTypeValidableDef<string>;
    static get number(): VueTypeValidableDef<number>;
    static get integer(): VueTypeValidableDef<number>;
    static get symbol(): VueTypeDef<symbol>;
    static custom: typeof custom;
    static instanceOf: typeof instanceOf;
    static arrayOf: typeof arrayOf;
    static objectOf: typeof objectOf;
    static shape: typeof shape;
    static object<T>(): VueTypeValidableDef<T>;
    static func<T extends (...args: any[]) => any>(): VueTypeValidableDef<T>;
    static array<T>(): VueTypeValidableDef<T[]>;
    static oneOfType<T>(arr: Array<VueProp<T> | VueTypeProp<T>>): VueTypeDef<T>;
    static oneOfType<U extends VueProp<any> | VueTypeProp<any>, V = InferType<U>>(arr: U[]): VueTypeDef<V>;
    static oneOf<T>(arr: T[]): VueTypeDef<T>;
    static oneOf<T extends readonly any[]>(arr: T): VueTypeDef<T[number]>;
    static get vNode(): VueTypeValidableDef<VNode>;
    static maxLength(max: number): VueTypeValidableDef<string>;
    static minLength(min: number): VueTypeValidableDef<string>;
    static max(max: number): VueTypeValidableDef<number>;
    static min(min: number): VueTypeValidableDef<number>;
    static range(min: number, max: number): VueTypeValidableDef<number>;
    static emit<T extends (...args: any[]) => any>(): VueTypeDef<T | T[]>;
}
export declare function callEmit<T extends (...args: any[]) => any>(funcs: T[] | T | undefined, ...args: Parameters<T>): ReturnType<T> | void;
export declare type VKey = string | number | symbol;
export declare const vKeyPropDef: VueTypeDef<string | number | symbol>;
export {};