export interface ArrayCombinator {
  kind: 'ArrayCombinator'
  type: TypeReference
  name?: string
}

export interface BooleanType {
  kind: 'BooleanType'
  name: 'boolean'
}

export interface BrandCombinator {
  kind: 'BrandCombinator'
  type: TypeReference
  predicate: (variableName: string) => string
  name: string
}

export interface CustomCombinator {
  kind: 'CustomCombinator'
  static: string
  runtime: string
  dependencies: Array<string>
}

export interface CustomTypeDeclaration {
  kind: 'CustomTypeDeclaration'
  name: string
  static: string
  runtime: string
  dependencies: Array<string>
}

export interface DictionaryCombinator {
  kind: 'DictionaryCombinator'
  domain: TypeReference
  codomain: TypeReference
  name?: string
}

export interface ExactCombinator {
  kind: 'ExactCombinator'
  type: TypeReference
  name?: string
}

export interface FunctionType {
  kind: 'FunctionType'
  name: 'Function'
}

export interface Identifier {
  kind: 'Identifier'
  name: string
}

export interface IntType {
  kind: 'IntType'
  name: 'Int'
}

export interface IntegerType {
  kind: 'IntegerType'
  name: 'Integer'
}

export interface InterfaceCombinator {
  kind: 'InterfaceCombinator'
  properties: Array<Property>
  name?: string
  forceType?: boolean
}

export interface IntersectionCombinator {
  kind: 'IntersectionCombinator'
  types: Array<TypeReference>
  name?: string
}

export interface KeyofCombinator {
  kind: 'KeyofCombinator'
  values: Array<string>
  name?: string
}

export interface LiteralCombinator {
  kind: 'LiteralCombinator'
  value: string | number | boolean
  name?: string
}

export interface NullType {
  kind: 'NullType'
  name: 'null'
}

export interface NumberType {
  kind: 'NumberType'
  name: 'number'
}

export interface Optional {
  isOptional: boolean
}

export interface PartialCombinator {
  kind: 'PartialCombinator'
  properties: Array<Property>
  name?: string
  forceType?: boolean
}

export interface Property extends Optional {
  kind: 'Property'
  key: string
  type: TypeReference
  description?: string
}

export interface Readonly {
  isReadonly: boolean
}

export interface ReadonlyArrayCombinator {
  kind: 'ReadonlyArrayCombinator'
  type: TypeReference
  name?: string
}

export interface ReadonlyCombinator {
  kind: 'ReadonlyCombinator'
  type: TypeReference
  name?: string
}

export interface Recursion {
  name: string
  output: boolean
}

export interface RecursiveCombinator {
  kind: 'RecursiveCombinator'
  typeParameter: Identifier
  name: string
  type: TypeReference
}

export interface StrictCombinator {
  kind: 'StrictCombinator'
  properties: Array<Property>
  name?: string
  forceType?: boolean
}

export interface StringType {
  kind: 'StringType'
  name: 'string'
}

export interface TaggedUnionCombinator {
  kind: 'TaggedUnionCombinator'
  tag: string
  types: Array<TypeReference>
  name?: string
}

export interface TupleCombinator {
  kind: 'TupleCombinator'
  types: Array<TypeReference>
  name?: string
}

export interface TypeDeclaration extends Readonly {
  kind: 'TypeDeclaration'
  name: string
  type: TypeReference
  isExported: boolean
  description?: string
}

export interface UndefinedType {
  kind: 'UndefinedType'
  name: 'undefined'
}

export interface UnionCombinator {
  kind: 'UnionCombinator'
  types: Array<TypeReference>
  name?: string
}

export interface UnknownArrayType {
  kind: 'AnyArrayType'
  name: 'UnknownArray'
}

export interface UnknownRecordType {
  kind: 'AnyDictionaryType'
  name: 'UnknownRecord'
}

export interface UnknownType {
  kind: 'UnknownType'
  name: 'unknown'
}

export type BasicType =
  | StringType
  | NumberType
  | BooleanType
  | NullType
  | UndefinedType
  // tslint:disable-next-line: deprecation
  | IntegerType
  | IntType
  | UnknownArrayType
  | UnknownRecordType
  | FunctionType
  | UnknownType

export type Combinator =
  | InterfaceCombinator
  | UnionCombinator
  | LiteralCombinator
  | IntersectionCombinator
  | KeyofCombinator
  | ArrayCombinator
  | ReadonlyArrayCombinator
  | TupleCombinator
  | RecursiveCombinator
  | DictionaryCombinator
  | PartialCombinator
  | TaggedUnionCombinator
  | CustomCombinator
  | ExactCombinator
  | StrictCombinator
  | ReadonlyCombinator
  | BrandCombinator

export type Graph = { [key: string]: Vertex }

export type Node = TypeReference | TypeDeclaration | CustomTypeDeclaration

export type TypeReference = BasicType | Combinator | Identifier

export class Vertex {
  constructor(public id: string) { ... }
  ...
}

export const booleanType: BooleanType = ...

export const dictionaryCombinator = ...

export const functionType: FunctionType = ...

export const intType: IntType = ...

export const integerType: IntegerType = ...

export const interfaceCombinator = ...

export const nullType: NullType = ...

export const numberType: NumberType = ...

export const stringType: StringType = ...

export const undefinedType: UndefinedType = ...

export const unknownArrayType: UnknownArrayType = ...

export const unknownRecordType: UnknownRecordType = ...

export const unknownType: UnknownType = ...

export function arrayCombinator(type: TypeReference, name?: string): ArrayCombinator { ... }

export function brandCombinator(
  type: TypeReference,
  predicate: (variableName: string) => string,
  name: string
): BrandCombinator { ... }

export function customCombinator(
  staticRepr: string,
  runtimeRepr: string,
  dependencies: Array<string> = []
): CustomCombinator { ... }

export function customTypeDeclaration(
  name: string,
  staticRepr: string,
  runtimeRepr: string,
  dependencies: Array<string> = []
): CustomTypeDeclaration { ... }

export function exactCombinator(type: TypeReference, name?: string): ExactCombinator { ... }

export function forceTypeCombinator<T extends InterfaceCombinator | StrictCombinator | PartialCombinator>(
  combinator: T
): T { ... }

export const getNodeDependencies = (node: Node): Array<string> => ...

export function getRecursiveTypeDeclaration(declaration: TypeDeclaration): TypeDeclaration { ... }

export function getTypeDeclarationGraph(declarations: Array<TypeDeclaration | CustomTypeDeclaration>): Graph { ... }

export function getTypeDeclarationMap(
  declarations: Array<TypeDeclaration | CustomTypeDeclaration>
): { [key: string]: TypeDeclaration | CustomTypeDeclaration } { ... }

export function identifier(name: string): Identifier { ... }

export function intersectionCombinator(types: Array<TypeReference>, name?: string): IntersectionCombinator { ... }

export function keyofCombinator(values: Array<string>, name?: string): KeyofCombinator { ... }

export function literalCombinator(value: string | boolean | number, name?: string): LiteralCombinator { ... }

export function partialCombinator(properties: Array<Property>, name?: string): PartialCombinator { ... }

export function printRuntime(node: Node, i: number = 0): string { ... }

export function printStatic(node: Node, i: number = 0, recursion?: Recursion): string { ... }

export function property(
  key: string,
  type: TypeReference,
  isOptional: boolean = false,
  description?: string
): Property { ... }

export function readonlyArrayCombinator(type: TypeReference, name?: string): ReadonlyArrayCombinator { ... }

export function readonlyCombinator(type: TypeReference, name?: string): ReadonlyCombinator { ... }

export function recordCombinator(domain: TypeReference, codomain: TypeReference, name?: string): DictionaryCombinator { ... }

export function recursiveCombinator(typeParameter: Identifier, name: string, type: TypeReference): RecursiveCombinator { ... }

export function sort(
  declarations: Array<TypeDeclaration | CustomTypeDeclaration>
): Array<TypeDeclaration | CustomTypeDeclaration> { ... }

export function strictCombinator(properties: Array<Property>, name?: string): StrictCombinator { ... }

export function taggedUnionCombinator(tag: string, types: Array<TypeReference>, name?: string): TaggedUnionCombinator { ... }

export function tsort(graph: Graph): { sorted: Array<string>; recursive: { [key: string]: true } } { ... }

export function tupleCombinator(types: Array<TypeReference>, name?: string): TupleCombinator { ... }

export function typeCombinator(properties: Array<Property>, name?: string): InterfaceCombinator { ... }

export function typeDeclaration(
  name: string,
  type: TypeReference,
  isExported: boolean = false,
  /** @deprecated */
  isReadonly: boolean = false,
  description?: string
): TypeDeclaration { ... }

export function unionCombinator(types: Array<TypeReference>, name?: string): UnionCombinator { ... }