type Direction = 'get' | 'set';

type ConstructorFor<T> = abstract new (...args: any[]) => T;

declare const error: unique symbol;
type TypeError<M extends string> = {
    [error]: M;
};
type MatchWithDirection<T extends MatcherPayload> = CheckGetSet<T, CheckSet<T, CheckGet<T, never>>>;
type MatcherPayload = {
    slot: unknown;
    value: unknown;
    dir: Direction;
    slotName: string;
    valueName: string;
};
type CheckSet<T extends MatcherPayload, Else> = "set" extends T["dir"] ? T["value"] extends T["slot"] ? Else : TypeError<`Type of ${T["valueName"]} is not assignable to type of ${T["slotName"]}.`> : Else;
type CheckGet<T extends MatcherPayload, Else> = "get" extends T["dir"] ? T["slot"] extends T["value"] ? Else : TypeError<`Type of ${T["slotName"]} is not assignable to type of ${T["valueName"]}.`> : Else;
type CheckGetSet<T extends MatcherPayload, Else> = "get" | "set" extends T["dir"] ? T["slot"] extends T["value"] ? T["value"] extends T["slot"] ? Else : TypeError<`Type of ${T["slotName"]} is not equal to type of ${T["valueName"]}.`> : TypeError<`Type of ${T["slotName"]} is not equal to type of ${T["valueName"]}.`> : Else;

type TypedClassDecorator<T, D extends Direction> = <TConstructor>(target: TConstructor) => TConstructor | void | MatchWithDirection<{
    slot: TConstructor;
    value: T;
    dir: D;
    slotName: "constructor";
    valueName: "decorator";
}>;

type TypedClassInstanceDecorator<T, D extends Direction> = <TConstructor>(target: TConstructor) => TConstructor | void | MatchWithDirection<{
    slot: UnsafeInstanceType<TConstructor>;
    value: T;
    dir: D;
    slotName: "instance";
    valueName: "decorator";
}>;
type UnsafeInstanceType<T> = T extends abstract new (...args: any[]) => infer I ? I : any;

type TypedMethodDecorator<T, D extends Direction> = <TTarget, TKey, TMethod>(target: TTarget, propertyKey: TKey, descriptor: TypedPropertyDescriptor<TMethod>) => TypedPropertyDescriptor<TMethod> | void | MatchWithDirection<{
    // @ts-ignore
    slot: TTarget[TKey];
    value: T;
    dir: D;
    slotName: "method";
    valueName: "decorator";
}>;

type TypedParameterDecorator<T, D extends Direction> = <TTarget, TKey extends DecoratorPropertyKey, TIndex extends number>(target: TTarget, prop: TKey, index: TIndex) => void | MatchWithDirection<{
    slot: GetParameterType<TTarget, TKey, TIndex>;
    value: T;
    dir: D;
    slotName: "parameter";
    valueName: "decorator";
}>;
// @ts-ignore
type GetParameterType<TTarget, TKey extends DecoratorPropertyKey, TIndex extends number> = TKey extends undefined ? ConstructorParameters<TTarget>[TIndex] : Parameters<TTarget[TKey]>[TIndex];
type DecoratorPropertyKey = string | symbol | undefined;

type TypedPropertyDecorator<T, D extends Direction> = <TTarget, TKey>(target: TTarget, propertyKey: TKey) => void | MatchWithDirection<{
    // @ts-ignore
    slot: TTarget[TKey];
    value: T;
    dir: D;
    slotName: "property";
    valueName: "decorator";
}>;

export { ConstructorFor, DecoratorPropertyKey, Direction, GetParameterType, TypedClassDecorator, TypedClassInstanceDecorator, TypedMethodDecorator, TypedParameterDecorator, TypedPropertyDecorator };