diff --git a/package.json b/package.json
index 0e7c7ba2..8207f64a 100644
--- a/package.json
+++ b/package.json
@@ -32,7 +32,7 @@
         "jest": "^27.0.1",
         "rimraf": "^3.0.2",
         "ts-jest": "^27.0.0",
-        "typescript": "^4.2.4"
+        "typescript": "^4.3.2"
     },
     "resolutions": {
         "minimist": "1.2.5"
diff --git a/packages/app/src/Route/Route.ts b/packages/app/src/Route/Route.ts
index ffc5b5f7..42ae45bf 100644
--- a/packages/app/src/Route/Route.ts
+++ b/packages/app/src/Route/Route.ts
@@ -1,13 +1,12 @@
 import {ActionAny} from "@bunt/unit";
 import {Ctor, ILogable, isFunction, isString} from "@bunt/util";
-import {Payload} from "../Payload";
-import {IRoute, IRouteMatcher, RouteFactory, RouteMatcherFactory, RouteRuleArg} from "./interfaces";
+import {IRoute, IRouteMatcher, RouteFactory, RouteMatcherFactory, RouteRuleArg, RouteRuleVariants} from "./interfaces";
 import {RouteRule} from "./RouteRule";
 
 export class Route<A extends ActionAny> implements IRoute<A>, ILogable<{ route: string }> {
     public readonly route: string;
     public readonly action: Ctor<A>;
-    public readonly payload?: Payload<A>;
+    public readonly payload?: RouteRule<A>;
     readonly #matcher: IRouteMatcher;
 
     constructor(matcher: RouteMatcherFactory, action: Ctor<A>, rule: RouteRuleArg<A>) {
@@ -37,7 +36,7 @@ export class Route<A extends ActionAny> implements IRoute<A>, ILogable<{ route:
         return this.#matcher.match(route);
     }
 
-    private getRuleArgs(rule: string | RouteRule<A>): { route: string, payload?: Payload<A> } {
+    private getRuleArgs(rule: RouteRuleArg<A>): RouteRuleVariants<A> {
         if (isString(rule)) {
             return {route: rule, payload: undefined};
         }
diff --git a/packages/app/src/Route/interfaces.ts b/packages/app/src/Route/interfaces.ts
index a323e4d3..b6be16d8 100644
--- a/packages/app/src/Route/interfaces.ts
+++ b/packages/app/src/Route/interfaces.ts
@@ -1,4 +1,4 @@
-import {ActionAny, ActionContext, ActionCtor, ApplyContext, Context} from "@bunt/unit";
+import {ActionAny, ActionContext, ActionCtor, ActionState, ApplyContext} from "@bunt/unit";
 import {Ctor} from "@bunt/util";
 import {IRequest} from "../interfaces";
 import {Payload} from "../Payload";
@@ -19,9 +19,11 @@ export interface IRoute<A extends ActionAny> {
 
 export type RouteMatcherFactory = IRouteMatcher | ((route: string) => IRouteMatcher);
 
-export type RouteRuleArg<A extends ActionAny> = A extends ActionAny<any, infer S>
-    ? S extends null ? string : RouteRule<A>
-    : string;
+export type RouteRuleVariants<A extends ActionAny> = { route: string, payload: undefined }
+    | { route: string, payload: RouteRule<A> };
+
+export type RouteRuleArg<A extends ActionAny> = ActionState<A> extends null
+    ? string : RouteRule<A>;
 
 export type RouteFactory = <A extends ActionAny>(action: Ctor<A>, rule: RouteRuleArg<A>) => Route<A>;
 
diff --git a/packages/input/src/Assertion/AssertionListError.ts b/packages/input/src/Assertion/AssertionListError.ts
index 182d537a..3ac3cf4d 100644
--- a/packages/input/src/Assertion/AssertionListError.ts
+++ b/packages/input/src/Assertion/AssertionListError.ts
@@ -12,10 +12,7 @@ export interface IReadableListError extends IReadableTypeError {
 export class AssertionListError extends AssertionTypeError {
     readonly #fields: IReadableListField[];
 
-    constructor(message: string,
-                type: TypeAbstract<any, any>,
-                payload: unknown,
-                fields: IReadableListField[]) {
+    constructor(message: string, type: TypeAbstract<any>, payload: unknown, fields: IReadableListField[]) {
         super(message, type, payload);
         this.#fields = fields;
     }
diff --git a/packages/input/src/Assertion/AssertionObjectError.ts b/packages/input/src/Assertion/AssertionObjectError.ts
index 7afe2b9a..6497d949 100644
--- a/packages/input/src/Assertion/AssertionObjectError.ts
+++ b/packages/input/src/Assertion/AssertionObjectError.ts
@@ -9,7 +9,7 @@ export class AssertionObjectError extends AssertionTypeError {
     readonly #fields: Record<string, any>;
 
     constructor(message: string,
-                type: TypeAbstract<any, any>,
+                type: TypeAbstract<any>,
                 payload: unknown,
                 fields: Record<string, IReadableTypeError>) {
         super(message, type, payload);
diff --git a/packages/input/src/Assertion/AssertionTypeError.ts b/packages/input/src/Assertion/AssertionTypeError.ts
index 4ba6fca6..89953d4c 100644
--- a/packages/input/src/Assertion/AssertionTypeError.ts
+++ b/packages/input/src/Assertion/AssertionTypeError.ts
@@ -9,9 +9,9 @@ export interface IReadableTypeError {
 
 export class AssertionTypeError extends Error implements IReadableError, ILogable<IReadableTypeError> {
     readonly #payload: unknown;
-    readonly #type: TypeAbstract<any, any>;
+    readonly #type: TypeAbstract<any>;
 
-    constructor(message: string, type: TypeAbstract<any, any>, payload: unknown) {
+    constructor(message: string, type: TypeAbstract<any>, payload: unknown) {
         super(message);
         this.#payload = payload;
         this.#type = type;
diff --git a/packages/input/src/Assertion/assertion.ts b/packages/input/src/Assertion/assertion.ts
index 0a6264bd..e4e8b705 100644
--- a/packages/input/src/Assertion/assertion.ts
+++ b/packages/input/src/Assertion/assertion.ts
@@ -1,7 +1,7 @@
 import {TypeAbstract} from "../TypeAbstract";
 import {AssertionTypeError} from "./AssertionTypeError";
 
-export function assert(expr: unknown, type: TypeAbstract<any, any>, message: string, payload: unknown): asserts expr {
+export function assert(expr: unknown, type: TypeAbstract<any>, message: string, payload: unknown): asserts expr {
     if (!expr) {
         throw new AssertionTypeError(message, type, payload);
     }
diff --git a/packages/input/src/SuperType.ts b/packages/input/src/SuperType.ts
index a4bd86ac..9830282e 100644
--- a/packages/input/src/SuperType.ts
+++ b/packages/input/src/SuperType.ts
@@ -1,12 +1,9 @@
-import {MayInput} from "./interfaces";
 import {TypeAbstract} from "./TypeAbstract";
 
-export abstract class SuperType<TValue, SValue,
-    TInput extends MayInput,
-    SInput extends MayInput> extends TypeAbstract<TValue, TInput> {
-    protected readonly type: TypeAbstract<SValue, SInput>;
+export abstract class SuperType<TValue, SValue> extends TypeAbstract<TValue> {
+    protected readonly type: TypeAbstract<SValue>;
 
-    constructor(type: TypeAbstract<SValue, SInput>) {
+    constructor(type: TypeAbstract<SValue>) {
         super();
         this.type = type;
     }
diff --git a/packages/input/src/Type/Bool.ts b/packages/input/src/Type/Bool.ts
index 6bd54a05..685a662c 100644
--- a/packages/input/src/Type/Bool.ts
+++ b/packages/input/src/Type/Bool.ts
@@ -1,7 +1,7 @@
 import {isBoolean} from "@bunt/util";
 import {ScalarType} from "./ScalarType";
 
-export const Bool = new ScalarType<boolean, boolean>({
+export const Bool = new ScalarType<boolean>({
     name: "Bool",
     validate(payload) {
         this.assert(isBoolean(payload), `Wrong payload: ${this.name} expected`, payload);
diff --git a/packages/input/src/Type/DateTime.ts b/packages/input/src/Type/DateTime.ts
index 19a24339..8b997bc4 100644
--- a/packages/input/src/Type/DateTime.ts
+++ b/packages/input/src/Type/DateTime.ts
@@ -1,7 +1,7 @@
 import {isNumber, isString} from "@bunt/util";
 import {ScalarType} from "./ScalarType";
 
-export const DateTime = new ScalarType<Date, string | number>({
+export const DateTime = new ScalarType<Date>({
     name: "DateTime",
     validate(payload) {
         this.assert(isNumber(payload) || isString(payload), `Wrong payload: ${this.name} expected`, payload);
diff --git a/packages/input/src/Type/Enum.ts b/packages/input/src/Type/Enum.ts
index 694d5314..a652c654 100644
--- a/packages/input/src/Type/Enum.ts
+++ b/packages/input/src/Type/Enum.ts
@@ -1,5 +1,4 @@
-import {isString, MayNullable, Promisify} from "@bunt/util";
-import {MayInput} from "../interfaces";
+import {isString, Promisify} from "@bunt/util";
 import {TypeAbstract} from "../TypeAbstract";
 
 export class Enum<T extends string | number> extends TypeAbstract<T> {
@@ -10,7 +9,7 @@ export class Enum<T extends string | number> extends TypeAbstract<T> {
         this.#value = value;
     }
 
-    public validate(input: MayNullable<MayInput>): Promisify<T> {
+    public validate(input: unknown): Promisify<T> {
         this.assert(isString(input), "Wrong type", input);
         this.assert(!/^\d+$/.test(input), "Wrong value", input);
         this.assert(input in this.#value, "Wrong value", input);
diff --git a/packages/input/src/Type/Fields.ts b/packages/input/src/Type/Fields.ts
index 5ea7a24c..826fc81b 100644
--- a/packages/input/src/Type/Fields.ts
+++ b/packages/input/src/Type/Fields.ts
@@ -1,9 +1,9 @@
-import {entriesReverse, isFunction, isInstanceOf, isObject, MayNullable} from "@bunt/util";
+import {entriesReverse, isFunction, isInstanceOf, isObject} from "@bunt/util";
 import {AssertionObjectError, AssertionTypeError, IReadableTypeError} from "../Assertion";
 import {ObjectFields, ObjectTypeMerge} from "../interfaces";
 import {TypeAbstract} from "../TypeAbstract";
 
-export class Fields<TValue extends Record<string, any>> extends TypeAbstract<TValue, Record<string, any>> {
+export class Fields<TValue extends Record<string, any>> extends TypeAbstract<TValue> {
     readonly #fields: ObjectFields<TValue>;
     readonly #name: string;
 
@@ -33,7 +33,7 @@ export class Fields<TValue extends Record<string, any>> extends TypeAbstract<TVa
         );
     }
 
-    public async validate(payload: MayNullable<Record<string, any>>): Promise<TValue> {
+    public async validate(payload: unknown): Promise<TValue> {
         this.assert(isObject(payload), `Wrong payload: ${this.name} expected`, payload);
 
         const entries: [string, any][] = [];
diff --git a/packages/input/src/Type/Float.ts b/packages/input/src/Type/Float.ts
index 2eb21e53..9257826d 100644
--- a/packages/input/src/Type/Float.ts
+++ b/packages/input/src/Type/Float.ts
@@ -1,7 +1,7 @@
 import {isNumber} from "@bunt/util";
 import {ScalarType} from "./ScalarType";
 
-export const Float = new ScalarType<number, number>({
+export const Float = new ScalarType<number>({
     name: "Float",
     validate(payload) {
         this.assert(isNumber(payload), `Wrong payload: ${this.name} expected`, payload);
diff --git a/packages/input/src/Type/Int.ts b/packages/input/src/Type/Int.ts
index a7e26172..c40a6d6e 100644
--- a/packages/input/src/Type/Int.ts
+++ b/packages/input/src/Type/Int.ts
@@ -1,7 +1,7 @@
 import {isNumber} from "@bunt/util";
 import {ScalarType} from "./ScalarType";
 
-export const Int = new ScalarType<number, number>({
+export const Int = new ScalarType<number>({
     name: "Int",
     validate(payload) {
         this.assert(isNumber(payload), `Wrong payload: ${this.name} expected`, payload);
diff --git a/packages/input/src/Type/JSONString.ts b/packages/input/src/Type/JSONString.ts
index 82f7a686..6a7ca62d 100644
--- a/packages/input/src/Type/JSONString.ts
+++ b/packages/input/src/Type/JSONString.ts
@@ -1,8 +1,11 @@
+import {isString} from "@bunt/util";
 import {ScalarType} from "./ScalarType";
 
-export const JSONString = new ScalarType<any, any>({
+export const JSONString = new ScalarType<any>({
     name: "JSON",
     validate(payload) {
+        this.assert(isString(payload), "Wrong payload", payload);
+
         return JSON.parse(payload);
     },
 });
diff --git a/packages/input/src/Type/List.ts b/packages/input/src/Type/List.ts
index b183eff7..3a25865e 100644
--- a/packages/input/src/Type/List.ts
+++ b/packages/input/src/Type/List.ts
@@ -1,11 +1,9 @@
-import {isArray, isInstanceOf, MayNullable} from "@bunt/util";
+import {isArray, isInstanceOf} from "@bunt/util";
 import {AssertionListError, AssertionTypeError, IReadableListField} from "../Assertion";
-import {MayListInput} from "../interfaces";
 import {SuperType} from "../SuperType";
 
-export class List<TValue, TInput extends MayListInput = MayListInput>
-    extends SuperType<TValue[], TValue, Array<TInput>, TInput> {
-    public async validate(payload: MayNullable<TInput[]>): Promise<TValue[]> {
+export class List<TValue> extends SuperType<TValue[], TValue> {
+    public async validate(payload: unknown): Promise<TValue[]> {
         this.assert(isArray(payload), `Wrong payload: ${this.type.name}[] expected`, payload);
 
         let index = 0;
diff --git a/packages/input/src/Type/NonNull.ts b/packages/input/src/Type/NonNull.ts
index 167536e1..809787c0 100644
--- a/packages/input/src/Type/NonNull.ts
+++ b/packages/input/src/Type/NonNull.ts
@@ -1,17 +1,16 @@
-import {isFunction, isNull, isUndefined, MayNullable, Promisify} from "@bunt/util";
-import {MayInput} from "../interfaces";
+import {isFunction, isNull, isUndefined, Promisify} from "@bunt/util";
 import {SuperType} from "../SuperType";
 import {TypeAbstract} from "../TypeAbstract";
 
-export class NonNull<TValue, TInput extends MayInput> extends SuperType<TValue, TValue, TInput, TInput> {
+export class NonNull<TValue> extends SuperType<TValue, TValue> {
     readonly #defaultValue: TValue | (() => TValue);
 
-    constructor(type: TypeAbstract<TValue, TInput>, defaultValue: TValue | (() => TValue)) {
+    constructor(type: TypeAbstract<TValue>, defaultValue: TValue | (() => TValue)) {
         super(type);
         this.#defaultValue = defaultValue;
     }
 
-    public validate(payload: MayNullable<TInput>): Promisify<TValue> {
+    public validate(payload: unknown): Promisify<TValue> {
         if (isNull(payload) || isUndefined(payload)) {
             if (isFunction(this.#defaultValue)) {
                 return this.#defaultValue();
diff --git a/packages/input/src/Type/Nullable.ts b/packages/input/src/Type/Nullable.ts
index 91349cde..2d27e8b1 100644
--- a/packages/input/src/Type/Nullable.ts
+++ b/packages/input/src/Type/Nullable.ts
@@ -1,9 +1,8 @@
-import {isNull, isUndefined, MayNullable, Promisify} from "@bunt/util";
-import {MayInput} from "../interfaces";
+import {isNull, isUndefined, Promisify} from "@bunt/util";
 import {SuperType} from "../SuperType";
 
-export class Nullable<TValue, TInput extends MayInput> extends SuperType<TValue | undefined, TValue, TInput, TInput> {
-    public validate(payload: MayNullable<TInput>): Promisify<TValue | undefined> {
+export class Nullable<TValue> extends SuperType<TValue | undefined, TValue> {
+    public validate(payload: unknown): Promisify<TValue | undefined> {
         if (isNull(payload) || isUndefined(payload)) {
             return undefined;
         }
diff --git a/packages/input/src/Type/Numeric.ts b/packages/input/src/Type/Numeric.ts
index 490c54eb..e47d7efd 100644
--- a/packages/input/src/Type/Numeric.ts
+++ b/packages/input/src/Type/Numeric.ts
@@ -1,7 +1,7 @@
 import {isNumber, isString} from "@bunt/util";
 import {ScalarType} from "./ScalarType";
 
-export const Numeric = new ScalarType<number, string | number>({
+export const Numeric = new ScalarType<number>({
     name: "Numeric",
     validate(payload) {
         this.assert(isNumber(payload) || isString(payload), `Wrong payload: ${this.name} expected`, payload);
diff --git a/packages/input/src/Type/ScalarType.ts b/packages/input/src/Type/ScalarType.ts
index 979bac90..1df45e2b 100644
--- a/packages/input/src/Type/ScalarType.ts
+++ b/packages/input/src/Type/ScalarType.ts
@@ -1,16 +1,15 @@
-import {MayNullable, Promisify} from "@bunt/util";
-import {MayInput} from "../interfaces";
+import {Promisify} from "@bunt/util";
 import {TypeAbstract} from "../TypeAbstract";
 
-export interface IScalarType<TValue, TInput extends MayInput> {
+export interface IScalarType<TValue> {
     name: string;
-    validate: (this: ScalarType<TValue, TInput>, payload: MayNullable<TInput>) => Promisify<TValue>;
+    validate: (this: ScalarType<TValue>, payload: unknown) => Promisify<TValue>;
 }
 
-export class ScalarType<TValue, TInput extends MayInput> extends TypeAbstract<TValue, TInput> {
-    readonly #type: IScalarType<TValue, TInput>;
+export class ScalarType<TValue> extends TypeAbstract<TValue> {
+    readonly #type: IScalarType<TValue>;
 
-    public constructor(type: IScalarType<TValue, TInput>) {
+    public constructor(type: IScalarType<TValue>) {
         super();
         this.#type = type;
     }
@@ -19,7 +18,7 @@ export class ScalarType<TValue, TInput extends MayInput> extends TypeAbstract<TV
         return this.#type.name;
     }
 
-    public validate(payload: MayNullable<TInput>): Promisify<TValue> {
+    public validate(payload: unknown): Promisify<TValue> {
         return this.#type.validate.call(this, payload);
     }
 }
diff --git a/packages/input/src/Type/Text.ts b/packages/input/src/Type/Text.ts
index 8b353654..00a5fada 100644
--- a/packages/input/src/Type/Text.ts
+++ b/packages/input/src/Type/Text.ts
@@ -1,10 +1,11 @@
 import {isString} from "@bunt/util";
 import {ScalarType} from "./ScalarType";
 
-export const Text = new ScalarType<string, string>({
+export const Text = new ScalarType<string>({
     name: "Text",
     validate(payload) {
         this.assert(isString(payload), `Wrong payload: ${this.name} expected`, payload);
+
         return payload;
     },
 });
diff --git a/packages/input/src/Type/ToNumber.ts b/packages/input/src/Type/ToNumber.ts
index e6b11a7e..0d2b064b 100644
--- a/packages/input/src/Type/ToNumber.ts
+++ b/packages/input/src/Type/ToNumber.ts
@@ -1,9 +1,10 @@
-import {isNumber, isString, MayNullable, Promisify} from "@bunt/util";
+import {isNumber, isString, Promisify} from "@bunt/util";
 import {SuperType} from "../SuperType";
 
-export class ToNumber extends SuperType<number | string, number, number | string, number> {
-    public validate(payload: MayNullable<number | string>): Promisify<number> {
+export class ToNumber extends SuperType<number, number> {
+    public validate(payload: unknown): Promisify<number> {
         this.assert(isNumber(payload) || isString(payload), `Wrong payload type`, payload);
+
         return this.type.validate(+payload);
     }
 }
diff --git a/packages/input/src/Type/UUID.ts b/packages/input/src/Type/UUID.ts
index 6c3abd73..64447bfb 100644
--- a/packages/input/src/Type/UUID.ts
+++ b/packages/input/src/Type/UUID.ts
@@ -3,10 +3,11 @@ import {ScalarType} from "./ScalarType";
 
 const RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89AB][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
-export const UUID = new ScalarType<string, string>({
+export const UUID = new ScalarType<string>({
     name: "UUID",
     validate(payload) {
         this.assert(isString(payload) && RE.test(payload), `Wrong payload: ${this.name} expected`, payload);
+
         return payload;
     },
 });
diff --git a/packages/input/src/Type/Union.ts b/packages/input/src/Type/Union.ts
index c964c98a..bdc8c94e 100644
--- a/packages/input/src/Type/Union.ts
+++ b/packages/input/src/Type/Union.ts
@@ -1,15 +1,13 @@
-import {MayNullable, Promisify} from "@bunt/util";
-import {MayInput} from "../interfaces";
+import {Promisify} from "@bunt/util";
 import {TypeAbstract} from "../TypeAbstract";
 
-export type UnionSelector<TInput extends MayInput> =
-    (input: MayNullable<TInput>) => TypeAbstract<unknown> | undefined;
+export type UnionSelector = (input: unknown) => TypeAbstract<unknown> | undefined;
 
-export class Union<TValue, TInput extends MayInput = MayInput> extends TypeAbstract<TValue, TInput> {
-    readonly #selector: UnionSelector<TInput>;
+export class Union<TValue> extends TypeAbstract<TValue> {
+    readonly #selector: UnionSelector;
     readonly #name: string;
 
-    constructor(selector: UnionSelector<TInput>, name = "Union") {
+    constructor(selector: UnionSelector, name = "Union") {
         super();
         this.#selector = selector;
         this.#name = name;
@@ -19,9 +17,10 @@ export class Union<TValue, TInput extends MayInput = MayInput> extends TypeAbstr
         return this.#name;
     }
 
-    public validate(input: MayNullable<TInput>): Promisify<TValue> {
+    public validate(input: unknown): Promisify<TValue> {
         const type = this.#selector(input);
         this.assert(!!type, `${this.name} detection was failed`, input);
+
         return type.validate(input) as Promisify<TValue>;
     }
 }
diff --git a/packages/input/src/Type/Varchar.ts b/packages/input/src/Type/Varchar.ts
index 818f7814..9d685c01 100644
--- a/packages/input/src/Type/Varchar.ts
+++ b/packages/input/src/Type/Varchar.ts
@@ -6,7 +6,7 @@ interface IVarchar {
     readonly max?: number;
 }
 
-export class Varchar extends TypeAbstract<string, string> {
+export class Varchar extends TypeAbstract<string> {
     readonly #options: IVarchar;
 
     constructor(options: IVarchar = {}) {
diff --git a/packages/input/src/Type/index.ts b/packages/input/src/Type/index.ts
index 1a08f578..fc619198 100644
--- a/packages/input/src/Type/index.ts
+++ b/packages/input/src/Type/index.ts
@@ -3,7 +3,6 @@ export * from "./Float";
 export * from "./Int";
 export * from "./ToNumber";
 export * from "./List";
-export * from "./NonNull";
 export * from "./Nullable";
 export * from "./NonNull";
 export * from "./Fields";
diff --git a/packages/input/src/TypeAbstract.ts b/packages/input/src/TypeAbstract.ts
index 426b37d2..adf0ecee 100644
--- a/packages/input/src/TypeAbstract.ts
+++ b/packages/input/src/TypeAbstract.ts
@@ -1,13 +1,12 @@
-import {MayNullable, Promisify} from "@bunt/util";
+import {Promisify} from "@bunt/util";
 import {assert} from "./Assertion";
-import {MayInput} from "./interfaces";
 
-export abstract class TypeAbstract<TValue, TInput extends MayInput = MayInput> {
+export abstract class TypeAbstract<TValue> {
     public get name(): string {
         return this.constructor.name;
     }
 
-    public abstract validate(input: MayNullable<TInput>): Promisify<TValue>;
+    public abstract validate(input: unknown): Promisify<TValue>;
 
     public assert(expr: unknown, message: string, payload: unknown): asserts expr {
         assert(expr, this, message, payload);
diff --git a/packages/input/src/functions.ts b/packages/input/src/functions.ts
index e2af5a86..b70dada4 100644
--- a/packages/input/src/functions.ts
+++ b/packages/input/src/functions.ts
@@ -1,11 +1,11 @@
 import {isFunction} from "@bunt/util";
-import {FieldSelectType, MayInput} from "./interfaces";
+import {FieldSelectType} from "./interfaces";
 import {TypeAbstract} from "./TypeAbstract";
 
 export async function validate<T>(type: FieldSelectType<T>, value: unknown): Promise<T> {
     if (isFunction(type)) {
-        return type().validate(value as MayInput);
+        return type().validate(value);
     }
 
-    return (type as TypeAbstract<T>).validate(value as MayInput);
+    return (type as TypeAbstract<T>).validate(value);
 }
diff --git a/packages/input/src/interfaces.ts b/packages/input/src/interfaces.ts
index 9d2659ac..eb5c6030 100644
--- a/packages/input/src/interfaces.ts
+++ b/packages/input/src/interfaces.ts
@@ -1,37 +1,23 @@
-import {MaybeArray, MayNullable} from "@bunt/util";
 import {Fields, List, Union} from "./Type";
 import {TypeAbstract} from "./TypeAbstract";
 
-export type Scalars = string | number | boolean;
-
-export interface Compound {
-    [key: string]: MaybeArray<Scalars | Compound>;
-}
-
-export type MayInput = MayNullable<MaybeArray<MayNullable<Scalars | Compound>>>;
-export type MayListInput = MayNullable<Scalars | Compound>;
-
 export type FieldFn<T> = () => T;
 export type FieldType<T> = T | FieldFn<T>;
 
 export type FieldsSchema<T> = {
     [K in keyof T]-?: T[K] extends Array<infer S>
-        ? FieldType<List<S, any>>
+        ? FieldType<List<S>>
         : T[K] extends Date
-            ? FieldType<TypeAbstract<T[K], any>>
+            ? FieldType<TypeAbstract<T[K]>>
             : T[K] extends Record<any, any>
                 ? FieldType<Fields<T[K]> | Union<T[K]>>
-                : FieldType<TypeAbstract<T[K], any>>;
+                : FieldType<TypeAbstract<T[K]>>;
 };
 
 export type ObjectFields<T> = T extends Promise<infer A>
     ? FieldsSchema<Exclude<A, undefined | null>>
     : FieldsSchema<Exclude<T, undefined | null>>;
 
-export type FieldSelectType<T> = T extends Record<string, any>
-    ? FieldType<Fields<T>>
-    : T extends Array<infer I>
-        ? FieldType<List<I, any>>
-        : FieldType<TypeAbstract<T, any>>;
+export type FieldSelectType<T> = FieldType<TypeAbstract<T>>;
 
 export type ObjectTypeMerge<T extends Record<string, any>> = Fields<T> | ObjectFields<T>;
diff --git a/packages/input/test/src/Main.test.ts b/packages/input/test/src/Main.test.ts
index e876140a..ff795232 100644
--- a/packages/input/test/src/Main.test.ts
+++ b/packages/input/test/src/Main.test.ts
@@ -22,7 +22,7 @@ import {TestEnum, TestEnumType} from "./Type/TestEnum";
 
 describe("Test Input", () => {
     const rand = Math.random();
-    const union = new Union<Date | boolean, string | number | boolean>(
+    const union = new Union<Date | boolean>(
         (input) => {
             switch (typeof input) {
                 case "string":
@@ -34,7 +34,7 @@ describe("Test Input", () => {
         },
     );
 
-    const samples: [any, any, TypeAbstract<any, any>][] = [
+    const samples: [any, any, TypeAbstract<any>][] = [
         [1, 1, Int],
         ["1", 1, new ToNumber(Int)],
         [false, false, Bool],
@@ -82,7 +82,7 @@ describe("Test Input", () => {
             name: Text,
             children: () => new NonNull(new List(human), []),
             parent: () => new Nullable(human),
-            links: () => new List(Text),
+            links: new List(Text),
             hobby: new Nullable(Hobby),
         }, "Human");
 
diff --git a/yarn.lock b/yarn.lock
index 842566ba..85c241d6 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -7103,10 +7103,10 @@ typedarray@^0.0.6:
   resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
   integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
 
-typescript@^4.2.4:
-  version "4.2.4"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.2.4.tgz#8610b59747de028fda898a8aef0e103f156d0961"
-  integrity sha512-V+evlYHZnQkaz8TRBuxTA92yZBPotr5H+WhQ7bD3hZUndx5tGOa1fuCgeSjxAzM1RiN5IzvadIXTVefuuwZCRg==
+typescript@^4.3.2:
+  version "4.3.2"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.3.2.tgz#399ab18aac45802d6f2498de5054fcbbe716a805"
+  integrity sha512-zZ4hShnmnoVnAHpVHWpTcxdv7dWP60S2FsydQLV8V5PbS3FifjWFFRiHSWpDJahly88PRyV5teTSLoq4eG7mKw==
 
 uglify-js@^3.1.4:
   version "3.13.5"