import {
  AllowedComponentProps,
  ComponentCustomProps,
  ObjectEmitsOptions,
  VNode,
  VNodeProps,
} from 'vue';

declare type PublicProps = VNodeProps &
  AllowedComponentProps &
  ComponentCustomProps;

declare type UnionToIntersection<U> = (
  U extends any ? (k: U) => void : never
) extends (k: infer I) => void
  ? I
  : never;

declare type EmitFn<
  Options = ObjectEmitsOptions,
  Event extends keyof Options = keyof Options,
> =
  Options extends Array<infer V>
    ? (event: V, ...args: any[]) => void
    : object extends Options
      ? (event: string, ...args: any[]) => void
      : UnionToIntersection<
          {
            [key in Event]: Options[key] extends (...args: infer Args) => any
              ? (event: key, ...args: Args) => void
              : (event: key, ...args: any[]) => void;
          }[Event]
        >;

export class ClassComponent<Props, Slots, Emits> {
  $props: Props & PublicProps;
  $slots: Slots;
  $emit: EmitFn<Emits>;
}

export type GlobalComponentConstructor<T> = {
  new (): T;
};

/**
 * Custom types
 */
export declare type Booleanish = boolean | 'true' | 'false';

export declare type Numberish = number | string;

export declare type Nullable<T = void> = T | null | undefined;

export declare type PassThrough<T = void> = T | object | undefined;
export declare type Preset<T = void> = T | object | undefined;

export declare type DefaultPassThrough<T = void> =
  | T
  | ((instance?: VNode) => T | undefined)
  | undefined;

export declare type HintedString<T extends string> = (string & {}) | T;

export declare type PresetAttributes = {
  class?: any;
  style?: any;
  [key: string]: any;
};

export declare type PresetMethodOptions = {
  instance: any;
  props: any;
  state: any;
  context: any;
  attrs: any;
  parent: any;
  global: object | undefined;
};

export declare type PresetOptionMethodType<Opt = PresetMethodOptions> = (
  options: Partial<Opt>,
) => PresetAttributes;

export type StringKeyOf<T> = Extract<keyof T, string>;

declare const TypeException: unique symbol;

export type TypeError<T extends string> = {
  [TypeException]: T;
};