ts-simple-type/lib/index.cjs.d.ts

Relationship type checker functions for Typescript types.

export declare enum SimpleTypeKind {
    STRING_LITERAL = "STRING_LITERAL",
    NUMBER_LITERAL = "NUMBER_LITERAL",
    BOOLEAN_LITERAL = "BOOLEAN_LITERAL",
    BIG_INT_LITERAL = "BIG_INT_LITERAL",
    STRING = "STRING",
    NUMBER = "NUMBER",
    BOOLEAN = "BOOLEAN",
    BIG_INT = "BIG_INT",
    NULL = "NULL",
    UNDEFINED = "UNDEFINED",
    ANY = "ANY",
    UNKNOWN = "UNKNOWN",
    VOID = "VOID",
    UNION = "UNION",
    ENUM = "ENUM",
    ENUM_MEMBER = "ENUM_MEMBER",
    INTERSECTION = "INTERSECTION",
    TUPLE = "TUPLE",
    INTERFACE = "INTERFACE",
    OBJECT = "OBJECT",
    FUNCTION = "FUNCTION",
    METHOD = "METHOD",
    CLASS = "CLASS",
    CIRCULAR_TYPE_REF = "CIRCULAR_TYPE_REF",
    GENERIC_ARGUMENTS = "GENERIC_ARGUMENTS",
    GENERIC_PARAMETER = "GENERIC_PARAMETER",
    ALIAS = "ALIAS",
    DATE = "DATE",
    ARRAY = "ARRAY",
    PROMISE = "PROMISE"
}
export declare enum SimpleTypeModifierKind {
    EXPORT = "EXPORT",
    AMBIENT = "AMBIENT",
    PUBLIC = "PUBLIC",
    PRIVATE = "PRIVATE",
    PROTECTED = "PROTECTED",
    STATIC = "STATIC",
    READONLY = "READONLY",
    ABSTRACT = "ABSTRACT",
    ASYNC = "ASYNC",
    DEFAULT = "DEFAULT"
}
export interface SimpleTypeBase {
    kind: SimpleTypeKind;
    name?: string;
}
export interface SimpleTypeMember {
    optional: boolean;
    type: SimpleType;
}
export interface SimpleTypeMemberNamed extends SimpleTypeMember {
    name: string;
}
export interface SimpleTypeClassMember extends SimpleTypeMemberNamed {
    modifiers: SimpleTypeModifierKind[];
}
export interface SimpleTypeAlias extends SimpleTypeBase {
    kind: SimpleTypeKind.ALIAS;
    name: string;
    target: SimpleType;
    typeParameters?: SimpleTypeGenericParameter[];
}
export interface SimpleTypeDate extends SimpleTypeBase {
    kind: SimpleTypeKind.DATE;
}
export interface SimpleTypeClass extends SimpleTypeBase {
    kind: SimpleTypeKind.CLASS;
    ctor?: SimpleTypeFunction;
    typeParameters?: SimpleTypeGenericParameter[];
    properties: SimpleTypeClassMember[];
    methods: SimpleTypeClassMember[];
}
export interface SimpleTypeFunctionArgument {
    name: string;
    type: SimpleType;
    optional: boolean;
    spread: boolean;
    initializer: boolean;
}
export interface SimpleTypeFunction extends SimpleTypeBase {
    kind: SimpleTypeKind.FUNCTION;
    argTypes: SimpleTypeFunctionArgument[];
    typeParameters?: SimpleTypeGenericParameter[];
    returnType: SimpleType;
}
export interface SimpleTypeMethod extends SimpleTypeBase {
    kind: SimpleTypeKind.METHOD;
    argTypes: SimpleTypeFunctionArgument[];
    typeParameters?: SimpleTypeGenericParameter[];
    returnType: SimpleType;
}
export interface SimpleTypeInterface extends SimpleTypeBase {
    kind: SimpleTypeKind.INTERFACE;
    members?: SimpleTypeMemberNamed[];
}
export interface SimpleTypeGenericArguments extends SimpleTypeBase {
    kind: SimpleTypeKind.GENERIC_ARGUMENTS;
    name?: undefined;
    target: SimpleType;
    typeArguments: SimpleType[];
}
export interface SimpleTypeGenericParameter extends SimpleTypeBase {
    name: string;
    kind: SimpleTypeKind.GENERIC_PARAMETER;
    default?: SimpleType;
}
export interface SimpleTypeObject extends SimpleTypeBase {
    kind: SimpleTypeKind.OBJECT;
    members?: SimpleTypeMemberNamed[];
}
export interface SimpleTypeTuple extends SimpleTypeBase {
    kind: SimpleTypeKind.TUPLE;
    members: SimpleTypeMember[];
}
export interface SimpleTypeArray extends SimpleTypeBase {
    kind: SimpleTypeKind.ARRAY;
    type: SimpleType;
}
export interface SimpleTypePromise extends SimpleTypeBase {
    kind: SimpleTypeKind.PROMISE;
    type: SimpleType;
}
export interface SimpleTypeEnumMember extends SimpleTypeBase {
    kind: SimpleTypeKind.ENUM_MEMBER;
    fullName: string;
    name: string;
    type: SimpleTypePrimitive;
}
export interface SimpleTypeEnum extends SimpleTypeBase {
    name: string;
    kind: SimpleTypeKind.ENUM;
    types: SimpleTypeEnumMember[];
}
export interface SimpleTypeUnion extends SimpleTypeBase {
    kind: SimpleTypeKind.UNION;
    types: SimpleType[];
}
export interface SimpleTypeIntersection extends SimpleTypeBase {
    kind: SimpleTypeKind.INTERSECTION;
    types: SimpleType[];
}
export interface SimpleTypeBigIntLiteral extends SimpleTypeBase {
    kind: SimpleTypeKind.BIG_INT_LITERAL;
    value: bigint;
}
export interface SimpleTypeStringLiteral extends SimpleTypeBase {
    kind: SimpleTypeKind.STRING_LITERAL;
    value: string;
}
export interface SimpleTypeNumberLiteral extends SimpleTypeBase {
    kind: SimpleTypeKind.NUMBER_LITERAL;
    value: number;
}
export interface SimpleTypeBooleanLiteral extends SimpleTypeBase {
    kind: SimpleTypeKind.BOOLEAN_LITERAL;
    value: boolean;
}
export interface SimpleTypeString extends SimpleTypeBase {
    kind: SimpleTypeKind.STRING;
}
export interface SimpleTypeNumber extends SimpleTypeBase {
    kind: SimpleTypeKind.NUMBER;
}
export interface SimpleTypeBoolean extends SimpleTypeBase {
    kind: SimpleTypeKind.BOOLEAN;
}
export interface SimpleTypeBigInt extends SimpleTypeBase {
    kind: SimpleTypeKind.BIG_INT;
}
export interface SimpleTypeNull extends SimpleTypeBase {
    kind: SimpleTypeKind.NULL;
}
export interface SimpleTypeUndefined extends SimpleTypeBase {
    kind: SimpleTypeKind.UNDEFINED;
}
export interface SimpleTypeAny extends SimpleTypeBase {
    kind: SimpleTypeKind.ANY;
}
export interface SimpleTypeUnknown extends SimpleTypeBase {
    kind: SimpleTypeKind.UNKNOWN;
}
export interface SimpleTypeVoid extends SimpleTypeBase {
    kind: SimpleTypeKind.VOID;
}
export interface SimpleTyoeCircularRef extends SimpleTypeBase {
    kind: SimpleTypeKind.CIRCULAR_TYPE_REF;
    ref: SimpleType;
}
export declare type SimpleType = SimpleTypeBigIntLiteral | SimpleTypeEnumMember | SimpleTypeEnum | SimpleTyoeCircularRef | SimpleTypeClass | SimpleTypeFunction | SimpleTypeObject | SimpleTypeInterface | SimpleTypeTuple | SimpleTypeArray | SimpleTypeUnion | SimpleTypeIntersection | SimpleTypeStringLiteral | SimpleTypeNumberLiteral | SimpleTypeBooleanLiteral | SimpleTypeString | SimpleTypeNumber | SimpleTypeBoolean | SimpleTypeBigInt | SimpleTypeNull | SimpleTypeUndefined | SimpleTypeAny | SimpleTypeMethod | SimpleTypeVoid | SimpleTypePromise | SimpleTypeUnknown | SimpleTypeAlias | SimpleTypeDate | SimpleTypeGenericArguments | SimpleTypeGenericParameter;
export declare function isSimpleType(type: any): type is SimpleType;
export declare type SimpleTypeLiteral = SimpleTypeBigIntLiteral | SimpleTypeBooleanLiteral | SimpleTypeStringLiteral | SimpleTypeNumberLiteral;
export declare const LITERAL_TYPE_KINDS: SimpleTypeKind[];
export declare function isSimpleTypeLiteral(type: SimpleType): type is SimpleTypeLiteral;
export declare type SimpleTypePrimitive = SimpleTypeLiteral | SimpleTypeString | SimpleTypeNumber | SimpleTypeBoolean | SimpleTypeBigInt | SimpleTypeNull | SimpleTypeUndefined;
export declare const PRIMITIVE_TYPE_KINDS: SimpleTypeKind[];
export declare function isSimpleTypePrimitive(type: SimpleType): type is SimpleTypePrimitive;
export declare const PRIMITIVE_TYPE_TO_LITERAL_MAP: Record<SimpleTypeKind, SimpleTypeKind | undefined>;
export declare const IMPLICIT_GENERIC: SimpleTypeKind[];
export declare function isImplicitGenericType(type: SimpleType): type is SimpleTypeArray | SimpleTypeTuple | SimpleTypePromise;
export declare function setTypescriptModule(newModule: typeof import("typescript")): void;
import { BigIntLiteralType, Declaration, GenericType, LiteralType, Node, ObjectType, Symbol, TupleType, Type, TypeReference, UniqueESSymbolType } from "typescript";
import { TypeChecker } from "typescript";
/**
 * Converts a Typescript type to a "SimpleType"
 * @param type The type to convert.
 * @param checker
 * @param cache
 */
export declare function toSimpleType(type: Node, checker: TypeChecker, cache?: WeakMap<Type, SimpleType>): SimpleType;
export declare function toSimpleType(type: Type, checker: TypeChecker, cache?: WeakMap<Type, SimpleType>): SimpleType;
export interface ToSimpleTypeOptions {
    circularCache: WeakMap<Type, SimpleType>;
    cache: WeakMap<Type, SimpleType>;
    checker: TypeChecker;
}
export interface AssignableToSimpleTypeKindOptions {
    op?: "and" | "or";
    matchAny?: boolean;
}
/**
 * Checks if a simple type kind is assignable to a type.
 * @param type The type to check
 * @param kind The simple type kind to check
 * @param kind The simple type kind to check
 * @param checker TypeCHecker if type is a typescript type
 * @param options Options
 */
export declare function isAssignableToSimpleTypeKind(type: SimpleType, kind: SimpleTypeKind | SimpleTypeKind[], options?: AssignableToSimpleTypeKindOptions): boolean;
export declare function isAssignableToSimpleTypeKind(type: Type, kind: SimpleTypeKind | SimpleTypeKind[], checker: TypeChecker, options?: AssignableToSimpleTypeKindOptions): boolean;
export declare function isAssignableToSimpleTypeKind(type: Type | SimpleType, kind: SimpleTypeKind | SimpleTypeKind[], checker: TypeChecker, options?: AssignableToSimpleTypeKindOptions): boolean;
/**
 * Tests a type is assignable to a primitive type.
 * @param type The type to test.
 * @param checker TypeChecker if type is a typescript type.
 */
export declare function isAssignableToPrimitiveType(type: SimpleType): boolean;
export declare function isAssignableToPrimitiveType(type: Type, checker: TypeChecker): boolean;
export declare function isAssignableToPrimitiveType(type: Type | SimpleType, checker: TypeChecker): boolean;
/**
 * Test if typeB is assignable to type B.
 * Tests if "typeA = typeB" in strict mode.
 * @param typeA Type A
 * @param typeB Type B
 * @param checker TypeChecker
 */
export declare function isAssignableToType(typeA: SimpleType, typeB: SimpleType): boolean;
export declare function isAssignableToType(typeA: SimpleType | Type | Node, typeB: SimpleType, checker: TypeChecker): boolean;
export declare function isAssignableToType(typeA: SimpleType, typeB: SimpleType | Type | Node, checker: TypeChecker): boolean;
export declare function isAssignableToType(typeA: Type | Node, typeB: Type | Node, checker: TypeChecker): boolean;
export declare function isAssignableToType(typeA: Type | Node | SimpleType, typeB: Type | Node | SimpleType, checker: TypeChecker): boolean;
/**
 * Tests if a type is assignable to a value.
 * Tests "type = value" in strict mode.
 * @param type The type to test.
 * @param value The value to test.
 */
export declare function isAssignableToValue(type: SimpleType, value: any): boolean;
export declare function isAssignableToValue(type: Type, value: any, checker: TypeChecker): boolean;
export declare function isAssignableToValue(type: SimpleType | Type, value: any, checker: TypeChecker): boolean;
export interface SimpleTypeToStringOptions {
}
/**
 * Converts a simple type to a string.
 * @param type Simple Type
 */
export declare function simpleTypeToString(type: SimpleType): string;
/**
 * Returns a string representation of a given type.
 * @param simpleType
 */
export declare function toTypeString(simpleType: SimpleType): string;
export declare function toTypeString(type: SimpleType | Type, checker: TypeChecker): string;

//# sourceMappingURL=index.cjs.d.ts.map