@trapi/metadata/dist/resolver/type.d.ts

Generate REST-API metadata scheme from TypeScript Decorators.

import type { Validator } from '../utils';
import { TypeName } from './constants';
import type { Extension } from './extension';
export type Type = PrimitiveType | ObjectType | EnumType | ArrayType | FileType | DateTimeType | DateType | BinaryType | BufferType | ByteType | AnyType | UndefinedType | RefEnumType | RefObjectType | RefAliasType | NestedObjectLiteralType | UnionType | IntersectionType | VoidType;
export interface BaseType {
    typeName: `${TypeName}`;
}
export interface AnyType extends BaseType {
    typeName: `${TypeName.ANY}`;
}
export declare function isAnyType(param: BaseType): param is AnyType;
export interface UndefinedType extends BaseType {
    typeName: `${TypeName.UNDEFINED}`;
}
export declare function isUndefinedType(param: BaseType): param is UndefinedType;
export interface StringType extends BaseType {
    typeName: `${TypeName.STRING}`;
}
export declare function isStringType(param: BaseType): param is StringType;
export interface BooleanType extends BaseType {
    typeName: `${TypeName.BOOLEAN}`;
}
export declare function isBooleanType(param: BaseType): param is BooleanType;
export interface DoubleType extends BaseType {
    typeName: `${TypeName.DOUBLE}`;
}
export declare function isDoubleType(param: BaseType): param is DoubleType;
export interface FloatType extends BaseType {
    typeName: `${TypeName.FLOAT}`;
}
export declare function isFloatType(param: BaseType): param is FloatType;
export interface IntegerType extends BaseType {
    typeName: `${TypeName.INTEGER}`;
}
export declare function isIntegerType(param: BaseType): param is IntegerType;
export interface LongType extends BaseType {
    typeName: `${TypeName.LONG}`;
}
export declare function isLongType(param: BaseType): param is LongType;
export interface VoidType extends BaseType {
    typeName: `${TypeName.VOID}`;
}
export declare function isVoidType(param: BaseType): param is VoidType;
export interface DateType extends BaseType {
    typeName: `${TypeName.DATE}`;
}
export declare function isDateType(param: BaseType): param is DateType;
export interface FileType extends BaseType {
    typeName: `${TypeName.FILE}`;
}
export declare function isFileType(param: BaseType): param is FileType;
export interface DateTimeType extends BaseType {
    typeName: `${TypeName.DATETIME}`;
}
export declare function isDateTimeType(param: BaseType): param is DateTimeType;
export interface BinaryType extends BaseType {
    typeName: `${TypeName.BINARY}`;
}
export declare function isBinaryType(param: BaseType): param is BinaryType;
export interface BufferType extends BaseType {
    typeName: `${TypeName.BUFFER}`;
}
export declare function isBufferType(param: BaseType): param is BufferType;
export interface ByteType extends BaseType {
    typeName: `${TypeName.BYTE}`;
}
export declare function isByteType(param: BaseType): param is ByteType;
export interface ObjectType extends BaseType {
    typeName: `${TypeName.OBJECT}`;
}
export declare function isObjectType(param: BaseType): param is ObjectType;
export interface EnumType extends BaseType {
    members: Array<string | number | boolean | null>;
    typeName: `${TypeName.ENUM}`;
}
export declare function isEnumType(param: BaseType): param is EnumType;
export interface ArrayType extends BaseType {
    elementType: Type;
    typeName: `${TypeName.ARRAY}`;
}
export declare function isArrayType(param: BaseType): param is ArrayType;
export interface NestedObjectLiteralType extends BaseType {
    typeName: `${TypeName.NESTED_OBJECT_LITERAL}`;
    properties: ResolverProperty[];
    additionalProperties?: Type;
}
export declare function isNestedObjectLiteralType(param: BaseType): param is NestedObjectLiteralType;
export interface IntersectionType extends BaseType {
    typeName: `${TypeName.INTERSECTION}`;
    members: Type[];
}
export declare function isIntersectionType(param: BaseType): param is IntersectionType;
export interface UnionType extends BaseType {
    typeName: `${TypeName.UNION}`;
    members: Type[];
}
export declare function isUnionType(param: BaseType): param is UnionType;
export type ReferenceType = RefEnumType | RefObjectType | RefAliasType;
export type ReferenceTypes = Record<string, ReferenceType>;
export type DependencyResolver = (referenceTypes: ReferenceTypes) => void;
export interface ReferenceTypeBase extends BaseType {
    description?: string;
    typeName: `${TypeName.REF_ALIAS}` | `${TypeName.REF_ENUM}` | `${TypeName.REF_OBJECT}`;
    refName: string;
    example?: unknown;
    deprecated: boolean;
}
export interface RefEnumType extends ReferenceTypeBase {
    typeName: `${TypeName.REF_ENUM}`;
    members: Array<string | number | boolean>;
    memberNames?: string[];
}
export declare function isRefEnumType(param: BaseType): param is RefEnumType;
export interface RefObjectType extends ReferenceTypeBase {
    typeName: `${TypeName.REF_OBJECT}`;
    properties: ResolverProperty[];
    additionalProperties?: Type;
}
export declare function isRefObjectType(param: BaseType): param is RefObjectType;
export interface RefAliasType extends Omit<ResolverProperty, 'name' | 'required'>, ReferenceTypeBase {
    typeName: `${TypeName.REF_ALIAS}`;
}
export declare function isRefAliasType(param: BaseType): param is RefAliasType;
export declare function isReferenceType(param: BaseType): param is ReferenceType;
export type PrimitiveType = AnyType | BinaryType | BooleanType | BufferType | ByteType | DateType | DateTimeType | DoubleType | FloatType | FileType | IntegerType | LongType | ObjectType | StringType;
export declare function isPrimitiveType(type: BaseType): type is PrimitiveType;
export interface ResolverProperty {
    default?: any;
    format?: string;
    example?: unknown;
    validators?: Record<string, Validator>;
    description?: string;
    name: string;
    type: Type;
    required: boolean;
    deprecated: boolean;
    extensions?: Extension[];
}
//# sourceMappingURL=type.d.ts.map