sern-community/typings/docs.ts

export interface Docs {
	id: number;
	name: string;
	kind: number;
	kindString: string;
	flags: GetSignatureFlags;
	originalName: string;
	children: DocsChild[];
	groups: Group[];
	sources: Source[];
}

export interface DocsChild {
	id: number;
	name: string;
	kind: number;
	kindString: TentacledKindString;
	flags: GetSignatureFlags;
	children?: PurpleChild[];
	groups?: Group[];
	sources: Source[];
	comment?: PurpleComment;
	extendedTypes?: ExtendedType[];
	type?: FriskyType;
	typeParameters?: ChildTypeParameter[];
	signatures?: DeclarationElement[];
}

export interface PurpleChild {
	id: number;
	name: string;
	kind: number;
	kindString: PurpleKindString;
	flags: PurpleFlags;
	sources: Source[];
	target?: number;
	comment?: GetSignatureComment;
	type?: AmbitiousType;
	defaultValue?: string;
	signatures?: PurpleSignature[];
	getSignature?: GetSignature;
	inheritedFrom?: InheritedFrom;
	overwrites?: InheritedFrom;
}

export interface GetSignatureComment {
	summary: ContentElement[];
}

export interface ContentElement {
	kind: Kind;
	text: string;
}

export enum Kind {
	Code = "code",
	InlineTag = "inline-tag",
	Text = "text",
}

export interface PurpleFlags {
	isConst?: boolean;
	isPrivate?: boolean;
	isPublic?: boolean;
	isStatic?: boolean;
	isExternal?: boolean;
	isReadonly?: boolean;
	isOptional?: boolean;
}

export interface GetSignature {
	id: number;
	name: string;
	kind: number;
	kindString: GetSignatureKindString;
	flags: GetSignatureFlags;
	type: ExtendedType;
	comment?: GetSignatureComment;
}

export interface GetSignatureFlags {}

export enum GetSignatureKindString {
	GetSignature = "Get signature",
}

export interface ExtendedType {
	type: TypeEnum;
	id?: number;
	typeArguments?: ExtendedTypeTypeArgument[];
	name: string;
	qualifiedName?: string;
	package?: Package;
}

export enum Package {
	DiscordAPITypes = "discord-api-types",
	DiscordJS = "discord.js",
	TsResults = "ts-results",
	TypesNode = "@types/node",
	Typescript = "typescript",
}

export enum TypeEnum {
	Array = "array",
	IndexedAccess = "indexedAccess",
	Inferred = "inferred",
	Intersection = "intersection",
	Intrinsic = "intrinsic",
	Literal = "literal",
	Mapped = "mapped",
	Query = "query",
	Reference = "reference",
	Reflection = "reflection",
	Tuple = "tuple",
	TypeOperator = "typeOperator",
	Union = "union",
}

export interface ExtendedTypeTypeArgument {
	type: TypeEnum;
	name?: string;
	qualifiedName?: string;
	package?: Package;
	types?: ExtendsType[];
	typeArguments?: InheritedFrom[];
	id?: number;
}

export interface InheritedFrom {
	type: TypeEnum;
	name: string;
}

export interface ExtendsType {
	type: TypeEnum;
	name?: string;
	qualifiedName?: string;
	package?: Package;
	types?: ExtendsTypeTypeClass[];
	typeArguments?: QueryTypeTypeArgument[];
	value?: string;
	id?: number;
}

export interface QueryTypeTypeArgument {
	type: TypeEnum;
	name?: string;
	qualifiedName?: QualifiedName;
	package?: Package;
	value?: string;
	id?: number;
	typeArguments?: InheritedFrom[];
	types?: InheritedFrom[];
}

export enum QualifiedName {
	CacheType = "CacheType",
	InteractionReplyOptions = "InteractionReplyOptions",
	Result = "Result",
}

export interface ExtendsTypeTypeClass {
	type: TypeEnum;
	name: string;
	qualifiedName?: string;
	package?: Package;
}

export enum PurpleKindString {
	Accessor = "Accessor",
	Constructor = "Constructor",
	EnumerationMember = "Enumeration Member",
	Function = "Function",
	Method = "Method",
	Property = "Property",
	Reference = "Reference",
	Variable = "Variable",
}

export interface PurpleSignature {
	id: number;
	name: string;
	kind: number;
	kindString: FluffyKindString;
	flags: FluffyFlags;
	comment?: PurpleComment;
	typeParameter?: SignatureTypeParameter[];
	parameters?: PurpleParameter[];
	type: HilariousType;
	inheritedFrom?: InheritedFrom;
	overwrites?: InheritedFrom;
}

export interface PurpleComment {
	summary: PurpleSummary[];
	blockTags?: BlockTag[];
}

export interface BlockTag {
	tag: Tag;
	content: ContentElement[];
}

export enum Tag {
	Deprecated = "@deprecated",
	Example = "@example",
	Returns = "@returns",
	Since = "@since",
}

export interface PurpleSummary {
	kind: Kind;
	text: string;
	tag?: string;
	target?: number;
}

export interface FluffyFlags {
	isExternal?: boolean;
}

export enum FluffyKindString {
	CallSignature = "Call signature",
	ConstructorSignature = "Constructor signature",
}

export interface PurpleParameter {
	id: number;
	name: string;
	kind: number;
	kindString: ParameterKindString;
	flags: TentacledFlags;
	comment?: GetSignatureComment;
	type: PurpleType;
	defaultValue?: string;
}

export interface TentacledFlags {
	isExternal?: boolean;
	isOptional?: boolean;
	isRest?: boolean;
}

export enum ParameterKindString {
	Parameter = "Parameter",
}

export interface PurpleType {
	type: TypeEnum;
	id?: number;
	name?: string;
	typeArguments?: ExtendsType[];
	qualifiedName?: string;
	package?: Package;
	types?: ExtendsType[];
	declaration?: PurpleDeclaration;
	indexType?: CheckTypeElement;
	objectType?: CheckTypeElement;
	elementType?: TentacledElementType;
}

export interface PurpleDeclaration {
	id: number;
	name: DeclarationName;
	kind: number;
	kindString: DeclarationKindString;
	flags: FluffyFlags;
	sources: Source[];
	signatures: FluffySignature[];
}

export enum DeclarationKindString {
	CallSignature = "Call signature",
	Property = "Property",
	TypeLiteral = "Type literal",
}

export enum DeclarationName {
	Type = "__type",
}

export interface FluffySignature {
	id: number;
	name: DeclarationName;
	kind: number;
	kindString: FluffyKindString;
	flags: FluffyFlags;
	parameters: FluffyParameter[];
	type: InheritedFrom;
}

export interface FluffyParameter {
	id: number;
	name: string;
	kind: number;
	kindString: ParameterKindString;
	flags: StickyFlags;
	type: FluffyType;
}

export interface StickyFlags {
	isExternal?: boolean;
	isRest: boolean;
}

export interface FluffyType {
	type: TypeEnum;
	elementType: PurpleElementType;
}

export interface PurpleElementType {
	type: TypeEnum;
	name?: string;
	indexType?: CheckTypeElement;
	objectType?: CheckTypeElement;
}

export interface TypeClass {
	type: TypeEnum;
	indexType?: InheritedFrom;
	objectType?: CheckTypeElement;
	name?: string;
	declaration?: DeclarationElement;
}

export interface CheckTypeTypeArgument {
	type: TypeEnum;
	indexType?: ObjectTypeClass;
	objectType?: ObjectTypeClass;
	types?: IndexTypeElement[];
	name?: string;
	id?: number;
	operator?: Operator;
	target?: TypeClass;
}

export interface DeclarationType {
	type: TypeEnum;
	declaration?: DeclarationElement;
	name?: string;
	id?: number;
	elements?: CheckTypeElement[];
	typeArguments?: PurpleTypeArgument[];
	types?: ExtendsType[];
}

export interface FluffyElementType {
	type: TypeEnum;
	declaration: DeclarationElement;
}

export interface IndecentType {
	type: TypeEnum;
	typeArguments?: TentacledTypeArgument[];
	name?: PurpleName;
	qualifiedName?: PurpleName;
	package?: Package;
	elementType?: FluffyElementType;
}

export interface IndigoType {
	type: TypeEnum;
	id?: number;
	name?: string;
	declaration?: DeclarationElement;
	typeArguments?: FluffyTypeArgument[];
	qualifiedName?: string;
	package?: Package;
	indexType?: CheckTypeElement;
	objectType?: ExtendedType;
	elementType?: InheritedFrom;
	elements?: TypeElement[];
}

export interface TentacledParameter {
	id: number;
	name: string;
	kind: number;
	kindString: ParameterKindString;
	flags: IndecentFlags;
	type: IndigoType;
}

export interface SignatureSignature {
	id: number;
	name: DeclarationName;
	kind: number;
	kindString: FluffyKindString;
	flags: GetSignatureFlags;
	type: IndecentType;
	parameters?: TentacledParameter[];
}

export interface PurpleTypeArgument {
	type: TypeEnum;
	indexType?: CheckTypeElement;
	objectType?: InheritedFrom;
	types?: IndexTypeElement[];
}

export interface TentacledType {
	type: TypeEnum;
	name?: string;
	declaration?: DeclarationElement;
	id?: number;
	typeArguments?: PurpleTypeArgument[];
	elementType?: CheckTypeElement;
	value?: boolean;
	types?: ExtendsType[];
	qualifiedName?: string;
	package?: Package;
}

export interface SignatureChild {
	id: number;
	name: string;
	kind: number;
	kindString: PurpleKindString;
	flags: IndigoFlags;
	sources: Source[];
	type: TentacledType;
}

export interface DeclarationElement {
	id: number;
	name: string;
	kind: number;
	kindString: DeclarationKindString;
	flags: GetSignatureFlags;
	sources?: Source[];
	type?: DeclarationType;
	defaultValue?: string;
	signatures?: SignatureSignature[];
	children?: SignatureChild[];
	groups?: Group[];
	comment?: GetSignatureComment;
	parameters?: DeclarationParameter[];
}

export interface CheckTypeElement {
	type: TypeEnum;
	id?: number;
	name?: string;
	elements?: CheckTypeElement[];
	types?: CheckTypeTypeClass[];
	declaration?: DeclarationElement;
	typeArguments?: CheckTypeTypeArgument[];
}

export interface ObjectTypeClass {
	type: TypeEnum;
	id?: number;
	name: string;
}

export enum Operator {
	Keyof = "keyof",
}

export interface IndexTypeElement {
	type: TypeEnum;
	value: string;
}

export enum PurpleName {
	Awaitable = "Awaitable",
	ErrImpl = "ErrImpl",
	OkImpl = "OkImpl",
	Unknown = "unknown",
}

export interface TentacledTypeArgument {
	type: TypeEnum;
	name?: TypeArgumentName;
	typeArguments?: InheritedFrom[];
	qualifiedName?: QualifiedName;
	package?: Package;
	types?: InheritedFrom[];
}

export enum TypeArgumentName {
	Result = "Result",
	Void = "void",
}

export interface TypeElement {
	type: TypeEnum;
	value?: string;
	id?: number;
	name?: string;
	elementType?: InheritedFrom;
}

export interface FluffyTypeArgument {
	type: TypeEnum;
	indexType?: IndexTypeElement;
	objectType?: TypeArgument;
	name?: string;
	types?: IndexTypeElement[];
}

export interface TypeArgument {
	type: TypeEnum;
	indexType?: InheritedFrom;
	objectType?: InheritedFrom;
	types?: IndexTypeElement[];
}

export interface IndecentFlags {
	isRest?: boolean;
}

export interface IndigoFlags {
	isOptional?: boolean;
}

export interface Source {
	fileName: FileName;
	line: number;
	character: number;
	url?: string;
}

export enum FileName {
	NodeModulesDiscordJSTypingsIndexDTs = "node_modules/discord.js/typings/index.d.ts",
	NodeModulesTypesNodeEventsDTs = "node_modules/@types/node/events.d.ts",
	SrcHandlerPluginsPluginTs = "src/handler/plugins/plugin.ts",
	SrcHandlerSernEmitterTs = "src/handler/sernEmitter.ts",
	SrcHandlerSernTs = "src/handler/sern.ts",
	SrcHandlerStructuresContextTs = "src/handler/structures/context.ts",
	SrcHandlerStructuresEnumsTs = "src/handler/structures/enums.ts",
	SrcHandlerStructuresModuleTs = "src/handler/structures/module.ts",
	SrcHandlerStructuresWrapperTs = "src/handler/structures/wrapper.ts",
	SrcIndexTs = "src/index.ts",
	SrcTypesHandlerTs = "src/types/handler.ts",
}

export interface Group {
	title: string;
	children: number[];
}

export interface DeclarationParameter {
	id: number;
	name: string;
	kind: number;
	kindString: ParameterKindString;
	flags: IndecentFlags;
	type: StickyType;
}

export interface StickyType {
	type: TypeEnum;
	id?: number;
	name?: string;
	indexType?: InheritedFrom;
	objectType?: ExtendsType;
}

export interface CheckTypeTypeClass {
	type: TypeEnum;
	name: string;
	qualifiedName?: string;
	package?: Package;
	id?: number;
	typeArguments?: InheritedFrom[];
}

export interface TentacledElementType {
	type: TypeEnum;
	types: ExtendsType[];
}

export interface HilariousType {
	type: TypeEnum;
	name?: string;
	id?: number;
	typeArguments?: StickyTypeArgument[];
	qualifiedName?: string;
	package?: Package;
	elementType?: ExtendsType;
}

export interface StickyTypeArgument {
	type: TypeEnum;
	typeArguments?: InheritedFrom[];
	name?: string;
	qualifiedName?: string;
	package?: Package;
	indexType?: ExtendedType;
	objectType?: ExtendedType;
	elementType?: InheritedFrom;
}

export interface SignatureTypeParameter {
	id: number;
	name: string;
	kind: number;
	kindString: TypeParameterKindString;
	flags: FluffyFlags;
	type: Default;
}

export enum TypeParameterKindString {
	TypeParameter = "Type parameter",
}

export interface Default {
	type: TypeEnum;
	name?: string;
	qualifiedName?: string;
	package?: Package;
	operator?: Operator;
	target?: ExtendedType;
	id?: number;
	declaration?: DeclarationElement;
}

export interface AmbitiousType {
	type: TypeEnum;
	declaration?: FluffyDeclaration;
	value?: number | string;
	queryType?: ExtendsType;
	name?: string;
	typeArguments?: InheritedFrom[];
	qualifiedName?: string;
	package?: Package;
	types?: MagentaType[];
	id?: number;
}

export interface FluffyDeclaration {
	id: number;
	name: DeclarationName;
	kind: number;
	kindString: DeclarationKindString;
	flags: GetSignatureFlags;
	children?: DeclarationElement[];
	groups?: Group[];
	sources: Source[];
	signatures?: TentacledSignature[];
}

export interface TentacledSignature {
	id: number;
	name: DeclarationName;
	kind: number;
	kindString: FluffyKindString;
	flags: GetSignatureFlags;
	type: CunningType;
}

export interface CunningType {
	type: TypeEnum;
	typeArguments: InheritedFrom[];
	name: string;
	qualifiedName: string;
	package: Package;
}

export interface MagentaType {
	type: TypeEnum;
	name?: string;
	elementType?: FluffyElementType;
	declaration?: DeclarationElement;
}

export enum TentacledKindString {
	Class = "Class",
	Enumeration = "Enumeration",
	Function = "Function",
	Interface = "Interface",
	Namespace = "Namespace",
	TypeAlias = "Type alias",
}

export interface FriskyType {
	type: string;
	id?: number;
	typeArguments?: IndecentTypeArgument[];
	name?: TemplateTypeName;
	types?: MischievousType[];
	parameter?: string;
	parameterType?: IndexType;
	templateType?: PurpleTemplateType;
	indexType?: IndexType;
	objectType?: TypeObjectType;
	declaration?: TentacledDeclaration;
	optionalModifier?: string;
	checkType?: CheckTypeElement;
	extendsType?: ExtendsType;
	trueType?: CheckTypeElement;
	falseType?: FalseType;
	qualifiedName?: TemplateTypeName;
	package?: Package;
}

export interface TentacledDeclaration {
	id: number;
	name: DeclarationName;
	kind: number;
	kindString: DeclarationKindString;
	flags: GetSignatureFlags;
	children?: DeclarationElement[];
	groups?: Group[];
	sources: Source[];
	signatures?: DeclarationElement[];
}

export interface FalseType {
	type: string;
	id?: number;
	name?: string;
	checkType?: CheckTypeElement;
	extendsType?: ExtendedType;
	trueType?: CheckTypeElement;
	falseType?: CheckTypeElement;
}

export interface IndexType {
	type: TypeEnum;
	id?: number;
	name?: string;
	operator?: Operator;
	target?: CheckTypeElement;
}

export enum TemplateTypeName {
	DefinitelyDefined = "DefinitelyDefined",
	Omit = "Omit",
	Override = "Override",
	ParseType = "ParseType",
}

export interface TypeObjectType {
	type: TypeEnum;
	parameter: string;
	parameterType: IndexType;
	templateType: ObjectTypeTemplateType;
}

export interface ObjectTypeTemplateType {
	type: string;
	id?: number;
	typeArguments?: IndigoTypeArgument[];
	name?: TemplateTypeName;
	types?: TypeClass[];
	checkType?: TypeClass;
	extendsType?: InheritedFrom;
	trueType?: TrueType;
	falseType?: InheritedFrom;
}

export interface TrueType {
	type: TypeEnum;
	elements: TrueTypeElement[];
}

export interface TrueTypeElement {
	type: string;
	name: string;
	isOptional: boolean;
	element: TypeClass;
}

export interface IndigoTypeArgument {
	type: TypeEnum;
	name?: string;
	declaration?: DeclarationElement;
}

export interface PurpleTemplateType {
	type: string;
	typeArguments?: TypeArgument[];
	name?: TemplateTypeName;
	qualifiedName?: TemplateTypeName;
	package?: Package;
	checkType?: TypeClass;
	extendsType?: ExtendsTypeClass;
	trueType?: EType;
	falseType?: EType;
}

export interface ExtendsTypeClass {
	type: TypeEnum;
	indexType: InheritedFrom;
	objectType: ExtendsTypeObjectType;
}

export interface ExtendsTypeObjectType {
	type: TypeEnum;
	typeArguments: CheckTypeElement[];
	name: string;
	qualifiedName: string;
	package: Package;
}

export interface EType {
	type: TypeEnum;
	value: boolean;
}

export interface IndecentTypeArgument {
	type: TypeEnum;
	declaration?: DeclarationElement;
	name?: string;
	types?: IndexTypeElement[];
	id?: number;
	qualifiedName?: string;
	package?: Package;
	typeArguments?: ExtendsType[];
}

export interface MischievousType {
	type: TypeEnum;
	name?: string;
	qualifiedName?: string;
	package?: Package;
	id?: number;
	typeArguments?: IndexType[];
	parameter?: string;
	parameterType?: CheckTypeElement;
	templateType?: FluffyTemplateType;
	optionalModifier?: string;
	elementType?: FluffyElementType;
	declaration?: DeclarationElement;
	indexType?: CheckTypeElement;
	objectType?: CheckTypeElement;
	value?: null;
}

export interface FluffyTemplateType {
	type: string;
	checkType: TypeClass;
	extendsType: ExtendsType;
	trueType: CheckTypeElement;
	falseType: ExtendsTypeClass;
}

export interface ChildTypeParameter {
	id: number;
	name: string;
	kind: number;
	kindString: TypeParameterKindString;
	flags: GetSignatureFlags;
	type?: Default;
	default?: Default;
}