Ts__min.res

@@warning("-27")

type never

module Never = {
  type t = never
  exception Never
  let absurd : t => 'a = x => raise(Never)
}

@unboxed type rec any = Any('a): any
external any : 'a => any = "%identity"

module Any = {
  type t = any
  external unsafeCast : t => 'a = "%identity"
}

type unknown

module Unknown = {
  type t = unknown
  external unsafeCast : t => 'a = "%identity"
}

type untyped_object = Js.Types.obj_val
type untyped_function = Js.Types.function_val
type symbol = Js.Types.symbol
type regexp = Js.Re.t
type bigint
type \"true" = private bool
type \"false" = private bool
type intrinsic<'a> = private 'a

type null<+'a> = Js.null<'a>
type null' = null<never>
type undefined<+'a> = Js.undefined<'a>
type nullable<+'a> = Js.nullable<'a>

module Union = {
  type container<+'cases>

  external return1 : 't1 => container<[> #U1('t1)]> = "%identity"
  external return2 : 't2 => container<[> #U2('t2)]> = "%identity"
  external return3 : 't3 => container<[> #U3('t3)]> = "%identity"
  external return4 : 't4 => container<[> #U4('t4)]> = "%identity"
  external return5 : 't5 => container<[> #U5('t5)]> = "%identity"
  external return6 : 't6 => container<[> #U6('t6)]> = "%identity"
  external return7 : 't7 => container<[> #U7('t7)]> = "%identity"
  external return8 : 't8 => container<[> #U8('t8)]> = "%identity"

  external getUnsafe1 : container<[> #U1('t1)]> => 't1 = "%identity"
  external getUnsafe2 : container<[> #U2('t2)]> => 't2 = "%identity"
  external getUnsafe3 : container<[> #U3('t3)]> => 't3 = "%identity"
  external getUnsafe4 : container<[> #U4('t4)]> => 't4 = "%identity"
  external getUnsafe5 : container<[> #U5('t5)]> => 't5 = "%identity"
  external getUnsafe6 : container<[> #U6('t6)]> => 't6 = "%identity"
  external getUnsafe7 : container<[> #U7('t7)]> => 't7 = "%identity"
  external getUnsafe8 : container<[> #U8('t8)]> => 't8 = "%identity"

  type t2<'t1, 't2> = container<[ #U1('t1) | #U2('t2) ]>
  type t3<'t1, 't2, 't3> = container<[ #U1('t1) | #U2('t2) | #U3('t3) ]>
  type t4<'t1, 't2, 't3, 't4> = container<[ #U1('t1) | #U2('t2) | #U3('t3) | #U4('t4) ]>
  type t5<'t1, 't2, 't3, 't4, 't5> = container<[ #U1('t1) | #U2('t2) | #U3('t3) | #U4('t4) | #U5('t5) ]>
  type t6<'t1, 't2, 't3, 't4, 't5, 't6> = container<[ #U1('t1) | #U2('t2) | #U3('t3) | #U4('t4) | #U5('t5) | #U6('t6) ]>
  type t7<'t1, 't2, 't3, 't4, 't5, 't6, 't7> = container<[ #U1('t1) | #U2('t2) | #U3('t3) | #U4('t4) | #U5('t5) | #U6('t6) | #U7('t7) ]>
  type t8<'t1, 't2, 't3, 't4, 't5, 't6, 't7, 't8> = container<[ #U1('t1) | #U2('t2) | #U3('t3) | #U4('t4) | #U5('t5) | #U6('t6) | #U7('t7) | #U8('t8) ]>
}

module Intersection = {
  type container<-'cases>

  external get1 : container<[> #I1('t1)]> => 't1 = "%identity"
  external get2 : container<[> #I2('t2)]> => 't2 = "%identity"
  external get3 : container<[> #I3('t3)]> => 't3 = "%identity"
  external get4 : container<[> #I4('t4)]> => 't4 = "%identity"
  external get5 : container<[> #I5('t5)]> => 't5 = "%identity"
  external get6 : container<[> #I6('t6)]> => 't6 = "%identity"
  external get7 : container<[> #I7('t7)]> => 't7 = "%identity"
  external get8 : container<[> #I8('t8)]> => 't8 = "%identity"

  type t2<'t1, 't2> = container<[ #I1('t1) | #I2('t2) ]>
  type t3<'t1, 't2, 't3> = container<[ #I1('t1) | #I2('t2) | #I3('t3) ]>
  type t4<'t1, 't2, 't3, 't4> = container<[ #I1('t1) | #I2('t2) | #I3('t3) | #I4('t4) ]>
  type t5<'t1, 't2, 't3, 't4, 't5> = container<[ #I1('t1) | #I2('t2) | #I3('t3) | #I4('t4) | #I5('t5) ]>
  type t6<'t1, 't2, 't3, 't4, 't5, 't6> = container<[ #I1('t1) | #I2('t2) | #I3('t3) | #I4('t4) | #I5('t5) | #I6('t6) ]>
  type t7<'t1, 't2, 't3, 't4, 't5, 't6, 't7> = container<[ #I1('t1) | #I2('t2) | #I3('t3) | #I4('t4) | #I5('t5) | #I6('t6) | #I7('t7) ]>
  type t8<'t1, 't2, 't3, 't4, 't5, 't6, 't7, 't8> = container<[ #I1('t1) | #I2('t2) | #I3('t3) | #I4('t4) | #I5('t5) | #I6('t6) | #I7('t7) | #I8('t8) ]>
}

module Interface = {
  @unboxed type t<-'tags, 'base> = { value: 'base }

  let value = (x: t<_, _>) => x.value
}
type intf<-'tags, 'base> = Interface.t<'tags, 'base>
type intf'<-'tags> = intf<'tags, any>

module Primitive = {
  type cases<'other> = [ #Null | #Undefined | #String(string) | #Number(float) | #Boolean(bool) | #Symbol(symbol) | #BigInt(bigint) | #Other('other) ]
  type t<+'cases>

  let return: ([< cases<'other>] as 'cases) => t<'cases> = x =>
    %raw(`(function (x) {
    switch (x) {
      case 'null' | 'Null': return null;
      case 'undefined' | 'Undefined': return;
      default: return x.VAL;
    }
  })(x)`)

  external fromNull: null<'a> => t<[> #Null | #Other('a) ]> = "%identity"
  external toNull: t<[< #Null | #Other('a) ]> => null<'a> = "%identity"

  external fromUndefined: undefined<'a> => t<[> #Undefined | #Other('a) ]> = "%identity"
  external toUndefined: t<[< #Undefined | #Other('a) ]> => undefined<'a> = "%identity"

  external fromNullable: nullable<'a> => t<[> #Null | #Undefined | #Other('a) ]> = "%identity"
  external toNullable: t<[< #Null | #Undefined | #Other('a) ]> => nullable<'a> = "%identity"

  let classify: t<[< cases<'other>] as 'cases> => 'cases = x =>
    switch (Js.typeof(x)) {
      | "string" => Obj.magic(#String(Obj.magic(x)))
      | "number" => Obj.magic(#Number(Obj.magic(x)))
      | "boolean" => Obj.magic(#Boolean(Obj.magic(x)))
      | "symbol" => Obj.magic(#Symbol(Obj.magic(x)))
      | "bigint" => Obj.magic(#BigInt(Obj.magic(x)))
      | "undefined" => Obj.magic(#Undefined)
      | _ =>
        if (Js.testAny(x)) { Obj.magic(#Null) }
        else { Obj.magic(#Other(x)) }
    }
}

module Interop = {
  let apply0 = (it: 'Function) => %raw(`it()`)
  let apply1 = (it: 'Function, arg0) => %raw(`it(arg0)`)
  let apply2 = (it: 'Function, arg0, arg1) => %raw(`it(arg0, arg1)`)
  let apply3 = (it: 'Function, arg0, arg1, arg2) => %raw(`it(arg0, arg1, arg2)`)
  let apply4 = (it: 'Function, arg0, arg1, arg2, arg3) => %raw(`it(arg0, arg1, arg2, arg3)`)
  let apply5 = (it: 'Function, arg0, arg1, arg2, arg3, arg4) => %raw(`it(arg0, arg1, arg2, arg3, arg4)`)
  let apply6 = (it: 'Function, arg0, arg1, arg2, arg3, arg4, arg5) => %raw(`it(arg0, arg1, arg2, arg3, arg4, arg5)`)
  let apply7 = (it: 'Function, arg0, arg1, arg2, arg3, arg4, arg5, arg6) => %raw(`it(arg0, arg1, arg2, arg3, arg4, arg5, arg6)`)
  let applyN = (it: 'Function, args: 'args) => %raw(`it(...args)`)

  let applyNewable0 = (it: 'Newable) => %raw(`new it()`)
  let applyNewable1 = (it: 'Newable, arg0) => %raw(`new it(arg0)`)
  let applyNewable2 = (it: 'Newable, arg0, arg1) => %raw(`new it(arg0, arg1)`)
  let applyNewable3 = (it: 'Newable, arg0, arg1, arg2) => %raw(`new it(arg0, arg1, arg2)`)
  let applyNewable4 = (it: 'Newable, arg0, arg1, arg2, arg3) => %raw(`new it(arg0, arg1, arg2, arg3)`)
  let applyNewable5 = (it: 'Newable, arg0, arg1, arg2, arg3, arg4) => %raw(`new it(arg0, arg1, arg2, arg3, arg4)`)
  let applyNewable6 = (it: 'Newable, arg0, arg1, arg2, arg3, arg4, arg5) => %raw(`new it(arg0, arg1, arg2, arg3, arg4, arg5)`)
  let applyNewable7 = (it: 'Newable, arg0, arg1, arg2, arg3, arg4, arg5, arg6) => %raw(`new it(arg0, arg1, arg2, arg3, arg4, arg5, arg6)`)
  let applyNewableN = (it: 'Newable, args: 'args) => %raw(`new it(...args)`)

  module PolyVariant = {
    let name  = (it: 'PolyVariant) : 'name => %raw(`it.NAME`)
    let value = (it: 'PolyVariant) : 'value => %raw(`it.VAL`)
    let make  = (name: 'name, value: 'value) : 'PolyVariant => %raw(`{ NAME: name, VAL: value }`)
  }
}

module Newable = {
  type t0<'t>
  type t1<'arg1, 't>

  @ocaml.doc(`\`'args\` must be a tuple type.`)
  type tn<'args, 't>

  let apply0 = (f0: t0<'t>) : 't => %raw(`new f0()`)
  let apply1 = (f1: t1<'arg1, 't>, arg1: 'arg1) : 't => %raw(`new f1(arg1)`)
  let applyN = (fn: tn<'args, 't>, args: 'args) : 't => %raw(`new fn(...args)`)
}

module Variadic = {
  @ocaml.doc(`\`'variadic\` is expected to be array or some other iterable type.`)
  type t0<'variadic, 't>

  @ocaml.doc(`\`'variadic\` is expected to be array or some other iterable type.`)
  type t1<'arg1, 'variadic, 't>

  @ocaml.doc(`\`'args\` must be a tuple type. \`'variadic\` is expected to be array or some other iterable type.`)
  type tn<'args, 'variadic, 't>

  @ocaml.doc(`\`'variadic\` is expected to be array or some other iterable type.`)
  let make0 : ('variadic => 't) => t0<'variadic, 't> = f => %raw(`(function(...args) { return f(args); })`)

  @ocaml.doc(`\`'variadic\` is expected to be array or some other iterable type.`)
  let make1 : (('arg1, 'variadic) => 't) => t1<'arg1, 'variadic, 't> = f => %raw(`(function(arg1, ...args) { return f(arg1, args); })`)

  @ocaml.doc(`\`'variadic\` is expected to be array or some other iterable type.`)
  let make2 : (('arg1, 'arg2, 'variadic) => 't) => tn<('arg1, 'arg2), 'variadic, 't> = f => %raw(`(function(arg1, arg2, ...args) { return f(arg1, arg2, args); })`)

  @ocaml.doc(`\`'variadic\` is expected to be array or some other iterable type.`)
  let make3 : (('arg1, 'arg2, 'arg3, 'variadic) => 't) => tn<('arg1, 'arg2, 'arg3), 'variadic, 't> = f => %raw(`(function(arg1, arg2, arg3, ...args) { return f(arg1, arg2, arg3, args); })`)

  @ocaml.doc(`\`'variadic\` is expected to be array or some other iterable type.`)
  let make4 : (('arg1, 'arg2, 'arg3, 'arg4, 'variadic) => 't) => tn<('arg1, 'arg2, 'arg3, 'arg4), 'variadic, 't> = f => %raw(`(function(arg1, arg2, arg3, arg4, ...args) { return f(arg1, arg2, arg3, arg4, args); })`)

  @ocaml.doc(`\`'variadic\` is expected to be array or some other iterable type.`)
  let make5 : (('arg1, 'arg2, 'arg3, 'arg4, 'arg5, 'variadic) => 't) => tn<('arg1, 'arg2, 'arg3, 'arg4, 'arg5), 'variadic, 't> = f => %raw(`(function(arg1, arg2, arg3, arg4, arg5, ...args) { return f(arg1, arg2, arg3, arg4, arg5, args); })`)

  @ocaml.doc(`\`'variadic\` is expected to be array or some other iterable type.`)
  let make6 : (('arg1, 'arg2, 'arg3, 'arg4, 'arg5, 'arg6, 'variadic) => 't) => tn<('arg1, 'arg2, 'arg3, 'arg4, 'arg5, 'arg6), 'variadic, 't> = f => %raw(`(function(arg1, arg2, arg3, arg4, arg5, arg6, ...args) { return f(arg1, arg2, arg3, arg4, arg5, arg6, args); })`)

  @ocaml.doc(`\`'variadic\` is expected to be array or some other iterable type.`)
  let make7 : (('arg1, 'arg2, 'arg3, 'arg4, 'arg5, 'arg6, 'arg7, 'variadic) => 't) => tn<('arg1, 'arg2, 'arg3, 'arg4, 'arg5, 'arg6, 'arg7), 'variadic, 't> = f => %raw(`(function(arg1, arg2, arg3, arg4, arg5, arg6, arg7, ...args) { return f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, args); })`)

  @ocaml.doc(`\`'args\` must be a tuple type. \`'variadic\` is expected to be array or some other iterable type.`)
  let makeN : (('args, 'variadic) => 't, int) => tn<'args, 'variadic, 't> = (f, n) => %raw(`(function(...args) { return f(args.slice(0, n), args.slice(n)); })`)

  let apply0 = (f0: t0<'variadic, 't>, variadic: 'variadic) : 't => %raw(`f0(...variadic)`)
  let apply1 = (f1: t1<'arg1, 'variadic, 't>, arg1: 'arg1, variadic: 'variadic) : 't => %raw(`f1(arg1, ...variadic)`)
  let applyN = (fn: tn<'args, 'variadic, 't>, args: 'args, variadic: 'variadic) : 't => %raw(`fn(...args, ...variadic)`)
}

module NewableVariadic = {
  @ocaml.doc(`\`'variadic\` is expected to be array or some other iterable type.`)
  type t0<'variadic, 't>

  @ocaml.doc(`\`'variadic\` is expected to be array or some other iterable type.`)
  type t1<'arg1, 'variadic, 't>

  @ocaml.doc(`\`'args\` must be a tuple type. \`'variadic\` is expected to be array or some other iterable type.`)
  type tn<'args, 'variadic, 't>

  let apply0 = (f0: t0<'variadic, 't>, variadic: 'variadic) : 't => %raw(`new f0(...variadic)`)
  let apply1 = (f1: t1<'arg1, 'variadic, 't>, arg1: 'arg1, variadic: 'variadic) : 't => %raw(`new f1(arg1, ...variadic)`)
  let applyN = (fn: tn<'args, 'variadic, 't>, args: 'args, variadic: 'variadic) : 't => %raw(`new fn(...args, ...variadic)`)
}

typescript.res

@@warning("-27-33-44")
open Ts__min
module rec Types : {
  module Ts : {
    module Server : {
      module TypesRegistryRequest : { type t = intf'<[#Ts_server_TypesRegistryRequest]> }
      module TypingInstallerResponse : { type t = intf'<[#Ts_server_TypingInstallerResponse]> }
      module ProjectResponse : {
        type t = intf'<[#Ts_server_ProjectResponse | #Ts_server_TypingInstallerResponse]>
      }
      module SetTypings : {
        type t = intf'<[#Ts_server_ProjectResponse | #Ts_server_SetTypings | #Ts_server_TypingInstallerResponse]>
      }
      module PackageInstalledResponse : {
        type t = intf'<[#Ts_server_PackageInstalledResponse | #Ts_server_ProjectResponse | #Ts_server_TypingInstallerResponse]>
      }
      module InvalidateCachedTypings : {
        type t = intf'<[#Ts_server_InvalidateCachedTypings | #Ts_server_ProjectResponse | #Ts_server_TypingInstallerResponse]>
      }
      module TypingInstallerRequestWithProjectName : { type t = intf'<[#Ts_server_TypingInstallerRequestWithProjectName]> }
      module InstallPackageRequest : {
        type t = intf'<[#Ts_server_InstallPackageRequest | #Ts_server_TypingInstallerRequestWithProjectName]>
      }
      module InitializationFailedResponse : {
        type t = intf'<[#Ts_server_InitializationFailedResponse | #Ts_server_TypingInstallerResponse]>
      }
      module EventTypesRegistry : { type t = [#"event::typesRegistry"] }
      module EventInitializationFailed : { type t = [#"event::initializationFailed"] }
      module EventEndInstallTypes : { type t = [#"event::endInstallTypes"] }
      module EventBeginInstallTypes : { type t = [#"event::beginInstallTypes"] }
      module InstallTypes : {
        type t = intf'<[#Ts_server_InstallTypes | #Ts_server_ProjectResponse | #Ts_server_TypingInstallerResponse]>
      }
      module EndInstallTypes : {
        type t = intf'<[#Ts_server_EndInstallTypes | #Ts_server_InstallTypes | #Ts_server_ProjectResponse | #Ts_server_TypingInstallerResponse]>
      }
      module DiscoverTypings : {
        type t = intf'<[#Ts_server_DiscoverTypings | #Ts_server_TypingInstallerRequestWithProjectName]>
      }
      module CloseProject : {
        type t = intf'<[#Ts_server_CloseProject | #Ts_server_TypingInstallerRequestWithProjectName]>
      }
      module BeginInstallTypes : {
        type t = intf'<[#Ts_server_BeginInstallTypes | #Ts_server_InstallTypes | #Ts_server_ProjectResponse | #Ts_server_TypingInstallerResponse]>
      }
      module ActionSet : { type t = [#"action::set"] }
      module ActionPackageInstalled : { type t = [#"action::packageInstalled"] }
      module ActionInvalidate : { type t = [#"action::invalidate"] }
    }
    module FactoryStatic : { module AnonymousInterface14 : { type t = private any } }
    module ReadonlyTextRange : { type t = intf'<[#Ts_ReadonlyTextRange]> }
    module Node : { type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange]> }
    module Expression : { type t = intf'<[#Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module YieldExpression : {
      type t = intf'<[#Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_YieldExpression]>
    }
    module Declaration : { type t = intf'<[#Ts_Declaration | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module SourceFile : {
      type t = intf'<[#Ts_Declaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SourceFile]>
    }
    module WriteFileCallback : {
      type t = (~fileName:string, ~data:string, ~writeByteOrderMark:bool, ~onError:(string => unit)=?, ~sourceFiles:array<SourceFile.t>=?, unit) => unit
    }
    module WithMetadata : {
      module AnonymousInterface19 : { type t = private any }
      type t<'T> = Intersection.t2<'T, AnonymousInterface19.t>
    }
    module DiagnosticRelatedInformation : { type t = intf'<[#Ts_DiagnosticRelatedInformation]> }
    module Diagnostic : { type t = intf'<[#Ts_Diagnostic | #Ts_DiagnosticRelatedInformation]> }
    module CompilerOptions : { type t = intf'<[#Ts_CompilerOptions]> }
    module WatchStatusReporter : {
      type t = (~diagnostic:Diagnostic.t, ~newLine:string, ~options:CompilerOptions.t, ~errorCount:float=?, unit) => unit
    }
    module WatchOptions : { type t = intf'<[#Ts_WatchOptions]> }
    module Watch : { type t<'T> = intf'<[#Ts_Watch('T)]> }
    module WatchOfFilesAndCompilerOptions : { type t<'T> = intf'<[#Ts_Watch('T) | #Ts_WatchOfFilesAndCompilerOptions('T)]> }
    module WatchOfConfigFile : { type t<'T> = intf'<[#Ts_Watch('T) | #Ts_WatchOfConfigFile('T)]> }
    module WatchFileKind : {
      type t =   | FixedPollingInterval
        | PriorityPollingInterval
        | DynamicPriorityPolling
        | FixedChunkSizePolling
        | UseFsEvents
        | UseFsEventsOnParentDirectory
      module FixedPollingInterval : { type t = private t }
      module PriorityPollingInterval : { type t = private t }
      module DynamicPriorityPolling : { type t = private t }
      module FixedChunkSizePolling : { type t = private t }
      module UseFsEvents : { type t = private t }
      module UseFsEventsOnParentDirectory : { type t = private t }
    }
    module WatchDirectoryKind : {
      type t = UseFsEvents | FixedPollingInterval | DynamicPriorityPolling | FixedChunkSizePolling
      module UseFsEvents : { type t = private t }
      module FixedPollingInterval : { type t = private t }
      module DynamicPriorityPolling : { type t = private t }
      module FixedChunkSizePolling : { type t = private t }
    }
    module WatchDirectoryFlags : {
      type t = None | Recursive
      module None : { type t = private t }
      module Recursive : { type t = private t }
    }
    module WatchHost : { type t = intf'<[#Ts_WatchHost]> }
    module ProgramHost : { type t<'T> = intf'<[#Ts_ProgramHost('T)]> }
    module WatchCompilerHost : {
      type t<'T> = intf'<[#Ts_ProgramHost('T) | #Ts_WatchCompilerHost('T) | #Ts_WatchHost]>
    }
    module WatchCompilerHostOfFilesAndCompilerOptions : {
      type t<'T> = intf'<[#Ts_ProgramHost('T) | #Ts_WatchCompilerHost('T) | #Ts_WatchCompilerHostOfFilesAndCompilerOptions('T) | #Ts_WatchHost]>
    }
    module ConfigFileDiagnosticsReporter : { type t = intf'<[#Ts_ConfigFileDiagnosticsReporter]> }
    module WatchCompilerHostOfConfigFile : {
      type t<'T> = intf'<[#Ts_ProgramHost('T) | #Ts_WatchCompilerHost('T) | #Ts_WatchCompilerHostOfConfigFile('T) | #Ts_ConfigFileDiagnosticsReporter | #Ts_WatchHost]>
    }
    module UnaryExpression : {
      type t = intf'<[#Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression]>
    }
    module VoidExpression : {
      type t = intf'<[#Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_VoidExpression]>
    }
    module VisitResult : { type t<'T> = undefined<Union.t2<'T, array<'T>>> }
    module Visitor : { type t = Dom.node => VisitResult.t<Dom.node> }
    module JSDocTag : { type t = intf'<[#Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module JSDocPropertyLikeTag : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocPropertyLikeTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocPropertyTag : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocPropertyLikeTag | #Ts_JSDocPropertyTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocParameterTag : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocParameterTag | #Ts_JSDocPropertyLikeTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module NamedDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module ObjectLiteralElement : {
      type t = intf'<[#Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange]>
    }
    module JsxAttribute : {
      type t = intf'<[#Ts_Declaration | #Ts_JsxAttribute | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange]>
    }
    module TypeElement : {
      type t = intf'<[#Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeElement]>
    }
    module JSDocContainer : { type t = intf'<[#Ts_JSDocContainer]> }
    module PropertySignature : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertySignature | #Ts_ReadonlyTextRange | #Ts_TypeElement]>
    }
    module ClassElement : {
      type t = intf'<[#Ts_ClassElement | #Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module PropertyDeclaration : {
      type t = intf'<[#Ts_ClassElement | #Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyDeclaration | #Ts_ReadonlyTextRange]>
    }
    module EnumMember : {
      type t = intf'<[#Ts_Declaration | #Ts_EnumMember | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module VariableDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_VariableDeclaration]>
    }
    module ParameterDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ParameterDeclaration | #Ts_ReadonlyTextRange]>
    }
    module ShorthandPropertyAssignment : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange | #Ts_ShorthandPropertyAssignment]>
    }
    module PropertyAssignment : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_PropertyAssignment | #Ts_ReadonlyTextRange]>
    }
    module BindingElement : {
      type t = intf'<[#Ts_BindingElement | #Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module VariableLikeDeclaration : {
      type t = Union.t8<VariableDeclaration.t, ParameterDeclaration.t, BindingElement.t, PropertyDeclaration.t, PropertyAssignment.t, PropertySignature.t, JsxAttribute.t, Union.t4<ShorthandPropertyAssignment.t, EnumMember.t, JSDocPropertyTag.t, JSDocParameterTag.t>>
    }
    module UnparsedSource : { type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnparsedSource]> }
    module UnparsedSection : { type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnparsedSection]> }
    module UnparsedSyntheticReference : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnparsedSection | #Ts_UnparsedSyntheticReference]>
    }
    module UnparsedTextLike : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnparsedSection | #Ts_UnparsedTextLike]>
    }
    module UnparsedPrepend : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnparsedPrepend | #Ts_UnparsedSection]>
    }
    module UnparsedSourceText : { type t = Union.t2<UnparsedPrepend.t, UnparsedTextLike.t> }
    module UnparsedPrologue : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnparsedPrologue | #Ts_UnparsedSection]>
    }
    module UnparsedNode : {
      type t = Union.t3<UnparsedPrologue.t, UnparsedSourceText.t, UnparsedSyntheticReference.t>
    }
    module Type : { type t = intf'<[#Ts_Type]> }
    module UniqueESSymbolType : { type t = intf'<[#Ts_Type | #Ts_UniqueESSymbolType]> }
    module TypeNode : { type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]> }
    module UnionTypeNode : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode | #Ts_UnionTypeNode]>
    }
    module IntersectionTypeNode : {
      type t = intf'<[#Ts_IntersectionTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module UnionOrIntersectionTypeNode : { type t = Union.t2<UnionTypeNode.t, IntersectionTypeNode.t> }
    module NodeWithTypeArguments : {
      type t = intf'<[#Ts_Node | #Ts_NodeWithTypeArguments | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module TypeReferenceNode : {
      type t = intf'<[#Ts_Node | #Ts_NodeWithTypeArguments | #Ts_ReadonlyTextRange | #Ts_TypeNode | #Ts_TypeReferenceNode]>
    }
    module ExpressionWithTypeArguments : {
      type t = intf'<[#Ts_ExpressionWithTypeArguments | #Ts_Node | #Ts_NodeWithTypeArguments | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module TypeReferenceType : { type t = Union.t2<TypeReferenceNode.t, ExpressionWithTypeArguments.t> }
    module ResolvedTypeReferenceDirectiveWithFailedLookupLocations : { type t = intf'<[#Ts_ResolvedTypeReferenceDirectiveWithFailedLookupLocations]> }
    module PerDirectoryResolutionCache : { type t<'T> = intf'<[#Ts_PerDirectoryResolutionCache('T)]> }
    module PackageJsonInfoCache : { type t = intf'<[#Ts_PackageJsonInfoCache]> }
    module TypeReferenceDirectiveResolutionCache : {
      type t = intf'<[#Ts_PerDirectoryResolutionCache(ResolvedTypeReferenceDirectiveWithFailedLookupLocations.t) | #Ts_PackageJsonInfoCache | #Ts_TypeReferenceDirectiveResolutionCache]>
    }
    module TypeQueryNode : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode | #Ts_TypeQueryNode]>
    }
    module TypePredicateKind : {
      type t = This | Identifier | AssertsThis | AssertsIdentifier
      module This : { type t = private t }
      module Identifier : { type t = private t }
      module AssertsThis : { type t = private t }
      module AssertsIdentifier : { type t = private t }
    }
    module TypePredicateBase : { type t = intf'<[#Ts_TypePredicateBase]> }
    module ThisTypePredicate : { type t = intf'<[#Ts_ThisTypePredicate | #Ts_TypePredicateBase]> }
    module IdentifierTypePredicate : { type t = intf'<[#Ts_IdentifierTypePredicate | #Ts_TypePredicateBase]> }
    module AssertsThisTypePredicate : { type t = intf'<[#Ts_AssertsThisTypePredicate | #Ts_TypePredicateBase]> }
    module AssertsIdentifierTypePredicate : { type t = intf'<[#Ts_AssertsIdentifierTypePredicate | #Ts_TypePredicateBase]> }
    module TypePredicate : {
      type t = Union.t4<ThisTypePredicate.t, IdentifierTypePredicate.t, AssertsThisTypePredicate.t, AssertsIdentifierTypePredicate.t>
    }
    module TypeParameterDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeParameterDeclaration]>
    }
    module NamespaceImport : {
      type t = intf'<[#Ts_Declaration | #Ts_NamedDeclaration | #Ts_NamespaceImport | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module ImportSpecifier : {
      type t = intf'<[#Ts_Declaration | #Ts_ImportSpecifier | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module ExportSpecifier : {
      type t = intf'<[#Ts_Declaration | #Ts_ExportSpecifier | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module ImportOrExportSpecifier : { type t = Union.t2<ImportSpecifier.t, ExportSpecifier.t> }
    module ImportClause : {
      type t = intf'<[#Ts_Declaration | #Ts_ImportClause | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module Statement : {
      type t = intf'<[#Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module DeclarationStatement : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module ImportEqualsDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_ImportEqualsDeclaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module TypeOnlyCompatibleAliasDeclaration : {
      type t = Union.t4<ImportClause.t, ImportEqualsDeclaration.t, NamespaceImport.t, ImportOrExportSpecifier.t>
    }
    module NamedImports : { type t = intf'<[#Ts_NamedImports | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module NamedExports : { type t = intf'<[#Ts_NamedExports | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module ExportDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_ExportDeclaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module UpdateExpression : {
      type t = intf'<[#Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module LeftHandSideExpression : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module MemberExpression : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module PrimaryExpression : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module Identifier : {
      type t = intf'<[#Ts_Declaration | #Ts_Expression | #Ts_Identifier | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module TypeOnlyAliasDeclaration : {
      module AnonymousInterface29 : {
        module rec AnonymousInterface17 : { type t = private any }
        and AnonymousInterface27 : { module AnonymousInterface17 : { type t = private any }; type t = private any }
        type t = private any
      }
      module AnonymousInterface28 : {
        module rec AnonymousInterface17 : { type t = private any }
        and AnonymousInterface24 : { module AnonymousInterface17 : { type t = private any }; type t = private any }
        type t = private any
      }
      module AnonymousInterface27 : { module AnonymousInterface17 : { type t = private any }; type t = private any }
      module AnonymousInterface24 : { module AnonymousInterface17 : { type t = private any }; type t = private any }
      module AnonymousInterface18 : { type t = private any }
      module AnonymousInterface17 : { type t = private any }
      type t = Union.t5<Intersection.t2<ImportClause.t, AnonymousInterface18.t>, Intersection.t2<ImportEqualsDeclaration.t, AnonymousInterface17.t>, Intersection.t2<NamespaceImport.t, AnonymousInterface27.t>, Intersection.t2<ImportSpecifier.t, Union.t2<AnonymousInterface17.t, AnonymousInterface29.t>>, Intersection.t2<ExportSpecifier.t, Union.t2<AnonymousInterface17.t, AnonymousInterface28.t>>>
    }
    module TypeOfTag : {
      type t = Union.t8<[#undefined], [#number], [#bigint], [#boolean], [#string], [#symbol], [#object], [#function]>
    }
    module TypeOfExpression : {
      type t = intf'<[#Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeOfExpression | #Ts_UnaryExpression]>
    }
    module TypeFormatFlags : {
      type t = [#0 | #1 | #2 | #8 | #32 | #64 | #256 | #1024 | #2048 | #4096 | #8192 | #16384 | #268435456 | #536870912 | #1048576 | #131072 | #262144 | #524288 | #2097152 | #4194304 | #8388608 | #814775659]
      module None : { type t = [#0] }
      module NoTruncation : { type t = [#1] }
      module WriteArrayAsGenericType : { type t = [#2] }
      module UseStructuralFallback : { type t = [#8] }
      module WriteTypeArgumentsOfSignature : { type t = [#32] }
      module UseFullyQualifiedType : { type t = [#64] }
      module SuppressAnyReturnType : { type t = [#256] }
      module MultilineObjectLiterals : { type t = [#1024] }
      module WriteClassExpressionAsTypeLiteral : { type t = [#2048] }
      module UseTypeOfFunction : { type t = [#4096] }
      module OmitParameterModifiers : { type t = [#8192] }
      module UseAliasDefinedOutsideCurrentScope : { type t = [#16384] }
      module UseSingleQuotesForStringLiteralType : { type t = [#268435456] }
      module NoTypeReduction : { type t = [#536870912] }
      module AllowUniqueESSymbolType : { type t = [#1048576] }
      module AddUndefined : { type t = [#131072] }
      module WriteArrowStyleSignature : { type t = [#262144] }
      module InArrayType : { type t = [#524288] }
      module InElementType : { type t = [#2097152] }
      module InFirstTypeArgument : { type t = [#4194304] }
      module InTypeAlias : { type t = [#8388608] }
      module WriteOwnNameForAnyLike : { type t = [#0] }
      module NodeBuilderFlagsMask : { type t = [#814775659] }
    }
    module TypeFlags : {
      type t = [#1 | #2 | #4 | #8 | #16 | #32 | #64 | #128 | #256 | #512 | #1024 | #2048 | #4096 | #8192 | #16384 | #32768 | #65536 | #131072 | #262144 | #524288 | #1048576 | #2097152 | #4194304 | #8388608 | #16777216 | #33554432 | #67108864 | #134217728 | #268435456 | #2944 | #109440 | #384 | #117724 | #402653316 | #296 | #2112 | #528 | #1056 | #12288 | #49152 | #3145728 | #3670016 | #8650752 | #58982400 | #406847488 | #465829888 | #469499904 | #536624127]
      module Any : { type t = [#1] }
      module Unknown : { type t = [#2] }
      module String : { type t = [#4] }
      module Number : { type t = [#8] }
      module Boolean : { type t = [#16] }
      module Enum : { type t = [#32] }
      module BigInt : { type t = [#64] }
      module StringLiteral : { type t = [#128] }
      module NumberLiteral : { type t = [#256] }
      module BooleanLiteral : { type t = [#512] }
      module EnumLiteral : { type t = [#1024] }
      module BigIntLiteral : { type t = [#2048] }
      module ESSymbol : { type t = [#4096] }
      module UniqueESSymbol : { type t = [#8192] }
      module Void : { type t = [#16384] }
      module Undefined : { type t = [#32768] }
      module Null : { type t = [#65536] }
      module Never : { type t = [#131072] }
      module TypeParameter : { type t = [#262144] }
      module Object : { type t = [#524288] }
      module Union : { type t = [#1048576] }
      module Intersection : { type t = [#2097152] }
      module Index : { type t = [#4194304] }
      module IndexedAccess : { type t = [#8388608] }
      module Conditional : { type t = [#16777216] }
      module Substitution : { type t = [#33554432] }
      module NonPrimitive : { type t = [#67108864] }
      module TemplateLiteral : { type t = [#134217728] }
      module StringMapping : { type t = [#268435456] }
      module Literal : { type t = [#2944] }
      module Unit : { type t = [#109440] }
      module StringOrNumberLiteral : { type t = [#384] }
      module PossiblyFalsy : { type t = [#117724] }
      module StringLike : { type t = [#402653316] }
      module NumberLike : { type t = [#296] }
      module BigIntLike : { type t = [#2112] }
      module BooleanLike : { type t = [#528] }
      module EnumLike : { type t = [#1056] }
      module ESSymbolLike : { type t = [#12288] }
      module VoidLike : { type t = [#49152] }
      module UnionOrIntersection : { type t = [#3145728] }
      module StructuredType : { type t = [#3670016] }
      module TypeVariable : { type t = [#8650752] }
      module InstantiableNonPrimitive : { type t = [#58982400] }
      module InstantiablePrimitive : { type t = [#406847488] }
      module Instantiable : { type t = [#465829888] }
      module StructuredOrInstantiable : { type t = [#469499904] }
      module Narrowable : { type t = [#536624127] }
    }
    module TypeChecker : {
      module AnonymousInterface30 : { type t = private any }
      type t = intf'<[#Ts_TypeChecker]>
    }
    module TypeAcquisition : { type t = intf'<[#Ts_TypeAcquisition]> }
    module ObjectType : { type t = intf'<[#Ts_ObjectType | #Ts_Type]> }
    module TypeReference : { type t = intf'<[#Ts_ObjectType | #Ts_Type | #Ts_TypeReference]> }
    module TupleTypeReference : {
      type t = intf'<[#Ts_ObjectType | #Ts_TupleTypeReference | #Ts_Type | #Ts_TypeReference]>
    }
    module TupleTypeNode : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_TupleTypeNode | #Ts_TypeNode]>
    }
    module InterfaceType : { type t = intf'<[#Ts_InterfaceType | #Ts_ObjectType | #Ts_Type]> }
    module GenericType : {
      type t = intf'<[#Ts_GenericType | #Ts_InterfaceType | #Ts_ObjectType | #Ts_Type | #Ts_TypeReference]>
    }
    module TupleType : {
      type t = intf'<[#Ts_GenericType | #Ts_InterfaceType | #Ts_ObjectType | #Ts_TupleType | #Ts_Type | #Ts_TypeReference]>
    }
    module JsonSourceFile : {
      type t = intf'<[#Ts_Declaration | #Ts_JsonSourceFile | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SourceFile]>
    }
    module TsConfigSourceFile : {
      type t = intf'<[#Ts_Declaration | #Ts_JsonSourceFile | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SourceFile | #Ts_TsConfigSourceFile]>
    }
    module TranspileOutput : { type t = intf'<[#Ts_TranspileOutput]> }
    module TranspileOptions : { type t = intf'<[#Ts_TranspileOptions]> }
    module TransientIdentifier : {
      type t = intf'<[#Ts_Declaration | #Ts_Expression | #Ts_Identifier | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_TransientIdentifier | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module Transformer : { type t<'T> = 'T => 'T }
    module CoreTransformationContext : { type t = intf'<[#Ts_CoreTransformationContext]> }
    module TransformationContext : { type t = intf'<[#Ts_CoreTransformationContext | #Ts_TransformationContext]> }
    module TransformerFactory : { type t<'T> = TransformationContext.t => Transformer.t<'T> }
    module TransformationResult : { type t<'T> = intf'<[#Ts_TransformationResult('T)]> }
    module SyntaxKind : {
      type t =   | Unknown_FirstToken
        | EndOfFileToken
        | SingleLineCommentTrivia_FirstTriviaToken
        | MultiLineCommentTrivia
        | NewLineTrivia
        | WhitespaceTrivia
        | ShebangTrivia
        | ConflictMarkerTrivia_LastTriviaToken
        | NumericLiteral_FirstLiteralToken
        | BigIntLiteral
        | StringLiteral
        | JsxText
        | JsxTextAllWhiteSpaces
        | RegularExpressionLiteral
        | NoSubstitutionTemplateLiteral_LastLiteralToken_FirstTemplateToken
        | TemplateHead
        | TemplateMiddle
        | TemplateTail_LastTemplateToken
        | OpenBraceToken_FirstPunctuation
        | CloseBraceToken
        | OpenParenToken
        | CloseParenToken
        | OpenBracketToken
        | CloseBracketToken
        | DotToken
        | DotDotDotToken
        | SemicolonToken
        | CommaToken
        | QuestionDotToken
        | LessThanToken_FirstBinaryOperator
        | LessThanSlashToken
        | GreaterThanToken
        | LessThanEqualsToken
        | GreaterThanEqualsToken
        | EqualsEqualsToken
        | ExclamationEqualsToken
        | EqualsEqualsEqualsToken
        | ExclamationEqualsEqualsToken
        | EqualsGreaterThanToken
        | PlusToken
        | MinusToken
        | AsteriskToken
        | AsteriskAsteriskToken
        | SlashToken
        | PercentToken
        | PlusPlusToken
        | MinusMinusToken
        | LessThanLessThanToken
        | GreaterThanGreaterThanToken
        | GreaterThanGreaterThanGreaterThanToken
        | AmpersandToken
        | BarToken
        | CaretToken
        | ExclamationToken
        | TildeToken
        | AmpersandAmpersandToken
        | BarBarToken
        | QuestionToken
        | ColonToken
        | AtToken
        | QuestionQuestionToken
        | BacktickToken
        | HashToken
        | EqualsToken_FirstAssignment
        | PlusEqualsToken_FirstCompoundAssignment
        | MinusEqualsToken
        | AsteriskEqualsToken
        | AsteriskAsteriskEqualsToken
        | SlashEqualsToken
        | PercentEqualsToken
        | LessThanLessThanEqualsToken
        | GreaterThanGreaterThanEqualsToken
        | GreaterThanGreaterThanGreaterThanEqualsToken
        | AmpersandEqualsToken
        | BarEqualsToken
        | BarBarEqualsToken
        | AmpersandAmpersandEqualsToken
        | QuestionQuestionEqualsToken
        | CaretEqualsToken_LastAssignment_LastCompoundAssignment_LastPunctuation_LastBinaryOperator
        | Identifier
        | PrivateIdentifier
        | BreakKeyword_FirstReservedWord_FirstKeyword
        | CaseKeyword
        | CatchKeyword
        | ClassKeyword
        | ConstKeyword
        | ContinueKeyword
        | DebuggerKeyword
        | DefaultKeyword
        | DeleteKeyword
        | DoKeyword
        | ElseKeyword
        | EnumKeyword
        | ExportKeyword
        | ExtendsKeyword
        | FalseKeyword
        | FinallyKeyword
        | ForKeyword
        | FunctionKeyword
        | IfKeyword
        | ImportKeyword
        | InKeyword
        | InstanceOfKeyword
        | NewKeyword
        | NullKeyword
        | ReturnKeyword
        | SuperKeyword
        | SwitchKeyword
        | ThisKeyword
        | ThrowKeyword
        | TrueKeyword
        | TryKeyword
        | TypeOfKeyword
        | VarKeyword
        | VoidKeyword
        | WhileKeyword
        | WithKeyword_LastReservedWord
        | ImplementsKeyword_FirstFutureReservedWord
        | InterfaceKeyword
        | LetKeyword
        | PackageKeyword
        | PrivateKeyword
        | ProtectedKeyword
        | PublicKeyword
        | StaticKeyword
        | YieldKeyword_LastFutureReservedWord
        | AbstractKeyword
        | AsKeyword
        | AssertsKeyword
        | AssertKeyword
        | AnyKeyword
        | AsyncKeyword
        | AwaitKeyword
        | BooleanKeyword
        | ConstructorKeyword
        | DeclareKeyword
        | GetKeyword
        | InferKeyword
        | IntrinsicKeyword
        | IsKeyword
        | KeyOfKeyword
        | ModuleKeyword
        | NamespaceKeyword
        | NeverKeyword
        | ReadonlyKeyword
        | RequireKeyword
        | NumberKeyword
        | ObjectKeyword
        | SetKeyword
        | StringKeyword
        | SymbolKeyword
        | TypeKeyword
        | UndefinedKeyword
        | UniqueKeyword
        | UnknownKeyword
        | FromKeyword
        | GlobalKeyword
        | BigIntKeyword
        | OverrideKeyword
        | OfKeyword_LastKeyword_LastToken
        | QualifiedName_FirstNode
        | ComputedPropertyName
        | TypeParameter
        | Parameter
        | Decorator
        | PropertySignature
        | PropertyDeclaration
        | MethodSignature
        | MethodDeclaration
        | ClassStaticBlockDeclaration
        | Constructor
        | GetAccessor
        | SetAccessor
        | CallSignature
        | ConstructSignature
        | IndexSignature
        | TypePredicate_FirstTypeNode
        | TypeReference
        | FunctionType
        | ConstructorType
        | TypeQuery
        | TypeLiteral
        | ArrayType
        | TupleType
        | OptionalType
        | RestType
        | UnionType
        | IntersectionType
        | ConditionalType
        | InferType
        | ParenthesizedType
        | ThisType
        | TypeOperator
        | IndexedAccessType
        | MappedType
        | LiteralType
        | NamedTupleMember
        | TemplateLiteralType
        | TemplateLiteralTypeSpan
        | ImportType_LastTypeNode
        | ObjectBindingPattern
        | ArrayBindingPattern
        | BindingElement
        | ArrayLiteralExpression
        | ObjectLiteralExpression
        | PropertyAccessExpression
        | ElementAccessExpression
        | CallExpression
        | NewExpression
        | TaggedTemplateExpression
        | TypeAssertionExpression
        | ParenthesizedExpression
        | FunctionExpression
        | ArrowFunction
        | DeleteExpression
        | TypeOfExpression
        | VoidExpression
        | AwaitExpression
        | PrefixUnaryExpression
        | PostfixUnaryExpression
        | BinaryExpression
        | ConditionalExpression
        | TemplateExpression
        | YieldExpression
        | SpreadElement
        | ClassExpression
        | OmittedExpression
        | ExpressionWithTypeArguments
        | AsExpression
        | NonNullExpression
        | MetaProperty
        | SyntheticExpression
        | TemplateSpan
        | SemicolonClassElement
        | Block
        | EmptyStatement
        | VariableStatement_FirstStatement
        | ExpressionStatement
        | IfStatement
        | DoStatement
        | WhileStatement
        | ForStatement
        | ForInStatement
        | ForOfStatement
        | ContinueStatement
        | BreakStatement
        | ReturnStatement
        | WithStatement
        | SwitchStatement
        | LabeledStatement
        | ThrowStatement
        | TryStatement
        | DebuggerStatement_LastStatement
        | VariableDeclaration
        | VariableDeclarationList
        | FunctionDeclaration
        | ClassDeclaration
        | InterfaceDeclaration
        | TypeAliasDeclaration
        | EnumDeclaration
        | ModuleDeclaration
        | ModuleBlock
        | CaseBlock
        | NamespaceExportDeclaration
        | ImportEqualsDeclaration
        | ImportDeclaration
        | ImportClause
        | NamespaceImport
        | NamedImports
        | ImportSpecifier
        | ExportAssignment
        | ExportDeclaration
        | NamedExports
        | NamespaceExport
        | ExportSpecifier
        | MissingDeclaration
        | ExternalModuleReference
        | JsxElement
        | JsxSelfClosingElement
        | JsxOpeningElement
        | JsxClosingElement
        | JsxFragment
        | JsxOpeningFragment
        | JsxClosingFragment
        | JsxAttribute
        | JsxAttributes
        | JsxSpreadAttribute
        | JsxExpression
        | CaseClause
        | DefaultClause
        | HeritageClause
        | CatchClause
        | AssertClause
        | AssertEntry
        | PropertyAssignment
        | ShorthandPropertyAssignment
        | SpreadAssignment
        | EnumMember
        | UnparsedPrologue
        | UnparsedPrepend
        | UnparsedText
        | UnparsedInternalText
        | UnparsedSyntheticReference
        | SourceFile
        | Bundle
        | UnparsedSource
        | InputFiles
        | JSDocTypeExpression_FirstJSDocNode
        | JSDocNameReference
        | JSDocMemberName
        | JSDocAllType
        | JSDocUnknownType
        | JSDocNullableType
        | JSDocNonNullableType
        | JSDocOptionalType
        | JSDocFunctionType
        | JSDocVariadicType
        | JSDocNamepathType
        | JSDocComment
        | JSDocText
        | JSDocTypeLiteral
        | JSDocSignature
        | JSDocLink
        | JSDocLinkCode
        | JSDocLinkPlain
        | JSDocTag_FirstJSDocTagNode
        | JSDocAugmentsTag
        | JSDocImplementsTag
        | JSDocAuthorTag
        | JSDocDeprecatedTag
        | JSDocClassTag
        | JSDocPublicTag
        | JSDocPrivateTag
        | JSDocProtectedTag
        | JSDocReadonlyTag
        | JSDocOverrideTag
        | JSDocCallbackTag
        | JSDocEnumTag
        | JSDocParameterTag
        | JSDocReturnTag
        | JSDocThisTag
        | JSDocTypeTag
        | JSDocTemplateTag
        | JSDocTypedefTag
        | JSDocSeeTag
        | JSDocPropertyTag_LastJSDocNode_LastJSDocTagNode
        | SyntaxList
        | NotEmittedStatement
        | PartiallyEmittedExpression
        | CommaListExpression
        | MergeDeclarationMarker
        | EndOfDeclarationMarker
        | SyntheticReferenceExpression
        | Count
      module Unknown : { type t = private t }
      module EndOfFileToken : { type t = private t }
      module SingleLineCommentTrivia : { type t = private t }
      module MultiLineCommentTrivia : { type t = private t }
      module NewLineTrivia : { type t = private t }
      module WhitespaceTrivia : { type t = private t }
      module ShebangTrivia : { type t = private t }
      module ConflictMarkerTrivia : { type t = private t }
      module NumericLiteral : { type t = private t }
      module BigIntLiteral : { type t = private t }
      module StringLiteral : { type t = private t }
      module JsxText : { type t = private t }
      module JsxTextAllWhiteSpaces : { type t = private t }
      module RegularExpressionLiteral : { type t = private t }
      module NoSubstitutionTemplateLiteral : { type t = private t }
      module TemplateHead : { type t = private t }
      module TemplateMiddle : { type t = private t }
      module TemplateTail : { type t = private t }
      module OpenBraceToken : { type t = private t }
      module CloseBraceToken : { type t = private t }
      module OpenParenToken : { type t = private t }
      module CloseParenToken : { type t = private t }
      module OpenBracketToken : { type t = private t }
      module CloseBracketToken : { type t = private t }
      module DotToken : { type t = private t }
      module DotDotDotToken : { type t = private t }
      module SemicolonToken : { type t = private t }
      module CommaToken : { type t = private t }
      module QuestionDotToken : { type t = private t }
      module LessThanToken : { type t = private t }
      module LessThanSlashToken : { type t = private t }
      module GreaterThanToken : { type t = private t }
      module LessThanEqualsToken : { type t = private t }
      module GreaterThanEqualsToken : { type t = private t }
      module EqualsEqualsToken : { type t = private t }
      module ExclamationEqualsToken : { type t = private t }
      module EqualsEqualsEqualsToken : { type t = private t }
      module ExclamationEqualsEqualsToken : { type t = private t }
      module EqualsGreaterThanToken : { type t = private t }
      module PlusToken : { type t = private t }
      module MinusToken : { type t = private t }
      module AsteriskToken : { type t = private t }
      module AsteriskAsteriskToken : { type t = private t }
      module SlashToken : { type t = private t }
      module PercentToken : { type t = private t }
      module PlusPlusToken : { type t = private t }
      module MinusMinusToken : { type t = private t }
      module LessThanLessThanToken : { type t = private t }
      module GreaterThanGreaterThanToken : { type t = private t }
      module GreaterThanGreaterThanGreaterThanToken : { type t = private t }
      module AmpersandToken : { type t = private t }
      module BarToken : { type t = private t }
      module CaretToken : { type t = private t }
      module ExclamationToken : { type t = private t }
      module TildeToken : { type t = private t }
      module AmpersandAmpersandToken : { type t = private t }
      module BarBarToken : { type t = private t }
      module QuestionToken : { type t = private t }
      module ColonToken : { type t = private t }
      module AtToken : { type t = private t }
      module QuestionQuestionToken : { type t = private t }
      module BacktickToken : { type t = private t }
      module HashToken : { type t = private t }
      module EqualsToken : { type t = private t }
      module PlusEqualsToken : { type t = private t }
      module MinusEqualsToken : { type t = private t }
      module AsteriskEqualsToken : { type t = private t }
      module AsteriskAsteriskEqualsToken : { type t = private t }
      module SlashEqualsToken : { type t = private t }
      module PercentEqualsToken : { type t = private t }
      module LessThanLessThanEqualsToken : { type t = private t }
      module GreaterThanGreaterThanEqualsToken : { type t = private t }
      module GreaterThanGreaterThanGreaterThanEqualsToken : { type t = private t }
      module AmpersandEqualsToken : { type t = private t }
      module BarEqualsToken : { type t = private t }
      module BarBarEqualsToken : { type t = private t }
      module AmpersandAmpersandEqualsToken : { type t = private t }
      module QuestionQuestionEqualsToken : { type t = private t }
      module CaretEqualsToken : { type t = private t }
      module Identifier : { type t = private t }
      module PrivateIdentifier : { type t = private t }
      module BreakKeyword : { type t = private t }
      module CaseKeyword : { type t = private t }
      module CatchKeyword : { type t = private t }
      module ClassKeyword : { type t = private t }
      module ConstKeyword : { type t = private t }
      module ContinueKeyword : { type t = private t }
      module DebuggerKeyword : { type t = private t }
      module DefaultKeyword : { type t = private t }
      module DeleteKeyword : { type t = private t }
      module DoKeyword : { type t = private t }
      module ElseKeyword : { type t = private t }
      module EnumKeyword : { type t = private t }
      module ExportKeyword : { type t = private t }
      module ExtendsKeyword : { type t = private t }
      module FalseKeyword : { type t = private t }
      module FinallyKeyword : { type t = private t }
      module ForKeyword : { type t = private t }
      module FunctionKeyword : { type t = private t }
      module IfKeyword : { type t = private t }
      module ImportKeyword : { type t = private t }
      module InKeyword : { type t = private t }
      module InstanceOfKeyword : { type t = private t }
      module NewKeyword : { type t = private t }
      module NullKeyword : { type t = private t }
      module ReturnKeyword : { type t = private t }
      module SuperKeyword : { type t = private t }
      module SwitchKeyword : { type t = private t }
      module ThisKeyword : { type t = private t }
      module ThrowKeyword : { type t = private t }
      module TrueKeyword : { type t = private t }
      module TryKeyword : { type t = private t }
      module TypeOfKeyword : { type t = private t }
      module VarKeyword : { type t = private t }
      module VoidKeyword : { type t = private t }
      module WhileKeyword : { type t = private t }
      module WithKeyword : { type t = private t }
      module ImplementsKeyword : { type t = private t }
      module InterfaceKeyword : { type t = private t }
      module LetKeyword : { type t = private t }
      module PackageKeyword : { type t = private t }
      module PrivateKeyword : { type t = private t }
      module ProtectedKeyword : { type t = private t }
      module PublicKeyword : { type t = private t }
      module StaticKeyword : { type t = private t }
      module YieldKeyword : { type t = private t }
      module AbstractKeyword : { type t = private t }
      module AsKeyword : { type t = private t }
      module AssertsKeyword : { type t = private t }
      module AssertKeyword : { type t = private t }
      module AnyKeyword : { type t = private t }
      module AsyncKeyword : { type t = private t }
      module AwaitKeyword : { type t = private t }
      module BooleanKeyword : { type t = private t }
      module ConstructorKeyword : { type t = private t }
      module DeclareKeyword : { type t = private t }
      module GetKeyword : { type t = private t }
      module InferKeyword : { type t = private t }
      module IntrinsicKeyword : { type t = private t }
      module IsKeyword : { type t = private t }
      module KeyOfKeyword : { type t = private t }
      module ModuleKeyword : { type t = private t }
      module NamespaceKeyword : { type t = private t }
      module NeverKeyword : { type t = private t }
      module ReadonlyKeyword : { type t = private t }
      module RequireKeyword : { type t = private t }
      module NumberKeyword : { type t = private t }
      module ObjectKeyword : { type t = private t }
      module SetKeyword : { type t = private t }
      module StringKeyword : { type t = private t }
      module SymbolKeyword : { type t = private t }
      module TypeKeyword : { type t = private t }
      module UndefinedKeyword : { type t = private t }
      module UniqueKeyword : { type t = private t }
      module UnknownKeyword : { type t = private t }
      module FromKeyword : { type t = private t }
      module GlobalKeyword : { type t = private t }
      module BigIntKeyword : { type t = private t }
      module OverrideKeyword : { type t = private t }
      module OfKeyword : { type t = private t }
      module QualifiedName : { type t = private t }
      module ComputedPropertyName : { type t = private t }
      module TypeParameter : { type t = private t }
      module Parameter : { type t = private t }
      module Decorator : { type t = private t }
      module PropertySignature : { type t = private t }
      module PropertyDeclaration : { type t = private t }
      module MethodSignature : { type t = private t }
      module MethodDeclaration : { type t = private t }
      module ClassStaticBlockDeclaration : { type t = private t }
      module Constructor : { type t = private t }
      module GetAccessor : { type t = private t }
      module SetAccessor : { type t = private t }
      module CallSignature : { type t = private t }
      module ConstructSignature : { type t = private t }
      module IndexSignature : { type t = private t }
      module TypePredicate : { type t = private t }
      module TypeReference : { type t = private t }
      module FunctionType : { type t = private t }
      module ConstructorType : { type t = private t }
      module TypeQuery : { type t = private t }
      module TypeLiteral : { type t = private t }
      module ArrayType : { type t = private t }
      module TupleType : { type t = private t }
      module OptionalType : { type t = private t }
      module RestType : { type t = private t }
      module UnionType : { type t = private t }
      module IntersectionType : { type t = private t }
      module ConditionalType : { type t = private t }
      module InferType : { type t = private t }
      module ParenthesizedType : { type t = private t }
      module ThisType : { type t = private t }
      module TypeOperator : { type t = private t }
      module IndexedAccessType : { type t = private t }
      module MappedType : { type t = private t }
      module LiteralType : { type t = private t }
      module NamedTupleMember : { type t = private t }
      module TemplateLiteralType : { type t = private t }
      module TemplateLiteralTypeSpan : { type t = private t }
      module ImportType : { type t = private t }
      module ObjectBindingPattern : { type t = private t }
      module ArrayBindingPattern : { type t = private t }
      module BindingElement : { type t = private t }
      module ArrayLiteralExpression : { type t = private t }
      module ObjectLiteralExpression : { type t = private t }
      module PropertyAccessExpression : { type t = private t }
      module ElementAccessExpression : { type t = private t }
      module CallExpression : { type t = private t }
      module NewExpression : { type t = private t }
      module TaggedTemplateExpression : { type t = private t }
      module TypeAssertionExpression : { type t = private t }
      module ParenthesizedExpression : { type t = private t }
      module FunctionExpression : { type t = private t }
      module ArrowFunction : { type t = private t }
      module DeleteExpression : { type t = private t }
      module TypeOfExpression : { type t = private t }
      module VoidExpression : { type t = private t }
      module AwaitExpression : { type t = private t }
      module PrefixUnaryExpression : { type t = private t }
      module PostfixUnaryExpression : { type t = private t }
      module BinaryExpression : { type t = private t }
      module ConditionalExpression : { type t = private t }
      module TemplateExpression : { type t = private t }
      module YieldExpression : { type t = private t }
      module SpreadElement : { type t = private t }
      module ClassExpression : { type t = private t }
      module OmittedExpression : { type t = private t }
      module ExpressionWithTypeArguments : { type t = private t }
      module AsExpression : { type t = private t }
      module NonNullExpression : { type t = private t }
      module MetaProperty : { type t = private t }
      module SyntheticExpression : { type t = private t }
      module TemplateSpan : { type t = private t }
      module SemicolonClassElement : { type t = private t }
      module Block : { type t = private t }
      module EmptyStatement : { type t = private t }
      module VariableStatement : { type t = private t }
      module ExpressionStatement : { type t = private t }
      module IfStatement : { type t = private t }
      module DoStatement : { type t = private t }
      module WhileStatement : { type t = private t }
      module ForStatement : { type t = private t }
      module ForInStatement : { type t = private t }
      module ForOfStatement : { type t = private t }
      module ContinueStatement : { type t = private t }
      module BreakStatement : { type t = private t }
      module ReturnStatement : { type t = private t }
      module WithStatement : { type t = private t }
      module SwitchStatement : { type t = private t }
      module LabeledStatement : { type t = private t }
      module ThrowStatement : { type t = private t }
      module TryStatement : { type t = private t }
      module DebuggerStatement : { type t = private t }
      module VariableDeclaration : { type t = private t }
      module VariableDeclarationList : { type t = private t }
      module FunctionDeclaration : { type t = private t }
      module ClassDeclaration : { type t = private t }
      module InterfaceDeclaration : { type t = private t }
      module TypeAliasDeclaration : { type t = private t }
      module EnumDeclaration : { type t = private t }
      module ModuleDeclaration : { type t = private t }
      module ModuleBlock : { type t = private t }
      module CaseBlock : { type t = private t }
      module NamespaceExportDeclaration : { type t = private t }
      module ImportEqualsDeclaration : { type t = private t }
      module ImportDeclaration : { type t = private t }
      module ImportClause : { type t = private t }
      module NamespaceImport : { type t = private t }
      module NamedImports : { type t = private t }
      module ImportSpecifier : { type t = private t }
      module ExportAssignment : { type t = private t }
      module ExportDeclaration : { type t = private t }
      module NamedExports : { type t = private t }
      module NamespaceExport : { type t = private t }
      module ExportSpecifier : { type t = private t }
      module MissingDeclaration : { type t = private t }
      module ExternalModuleReference : { type t = private t }
      module JsxElement : { type t = private t }
      module JsxSelfClosingElement : { type t = private t }
      module JsxOpeningElement : { type t = private t }
      module JsxClosingElement : { type t = private t }
      module JsxFragment : { type t = private t }
      module JsxOpeningFragment : { type t = private t }
      module JsxClosingFragment : { type t = private t }
      module JsxAttribute : { type t = private t }
      module JsxAttributes : { type t = private t }
      module JsxSpreadAttribute : { type t = private t }
      module JsxExpression : { type t = private t }
      module CaseClause : { type t = private t }
      module DefaultClause : { type t = private t }
      module HeritageClause : { type t = private t }
      module CatchClause : { type t = private t }
      module AssertClause : { type t = private t }
      module AssertEntry : { type t = private t }
      module PropertyAssignment : { type t = private t }
      module ShorthandPropertyAssignment : { type t = private t }
      module SpreadAssignment : { type t = private t }
      module EnumMember : { type t = private t }
      module UnparsedPrologue : { type t = private t }
      module UnparsedPrepend : { type t = private t }
      module UnparsedText : { type t = private t }
      module UnparsedInternalText : { type t = private t }
      module UnparsedSyntheticReference : { type t = private t }
      module SourceFile : { type t = private t }
      module Bundle : { type t = private t }
      module UnparsedSource : { type t = private t }
      module InputFiles : { type t = private t }
      module JSDocTypeExpression : { type t = private t }
      module JSDocNameReference : { type t = private t }
      module JSDocMemberName : { type t = private t }
      module JSDocAllType : { type t = private t }
      module JSDocUnknownType : { type t = private t }
      module JSDocNullableType : { type t = private t }
      module JSDocNonNullableType : { type t = private t }
      module JSDocOptionalType : { type t = private t }
      module JSDocFunctionType : { type t = private t }
      module JSDocVariadicType : { type t = private t }
      module JSDocNamepathType : { type t = private t }
      module JSDocComment : { type t = private t }
      module JSDocText : { type t = private t }
      module JSDocTypeLiteral : { type t = private t }
      module JSDocSignature : { type t = private t }
      module JSDocLink : { type t = private t }
      module JSDocLinkCode : { type t = private t }
      module JSDocLinkPlain : { type t = private t }
      module JSDocTag : { type t = private t }
      module JSDocAugmentsTag : { type t = private t }
      module JSDocImplementsTag : { type t = private t }
      module JSDocAuthorTag : { type t = private t }
      module JSDocDeprecatedTag : { type t = private t }
      module JSDocClassTag : { type t = private t }
      module JSDocPublicTag : { type t = private t }
      module JSDocPrivateTag : { type t = private t }
      module JSDocProtectedTag : { type t = private t }
      module JSDocReadonlyTag : { type t = private t }
      module JSDocOverrideTag : { type t = private t }
      module JSDocCallbackTag : { type t = private t }
      module JSDocEnumTag : { type t = private t }
      module JSDocParameterTag : { type t = private t }
      module JSDocReturnTag : { type t = private t }
      module JSDocThisTag : { type t = private t }
      module JSDocTypeTag : { type t = private t }
      module JSDocTemplateTag : { type t = private t }
      module JSDocTypedefTag : { type t = private t }
      module JSDocSeeTag : { type t = private t }
      module JSDocPropertyTag : { type t = private t }
      module SyntaxList : { type t = private t }
      module NotEmittedStatement : { type t = private t }
      module PartiallyEmittedExpression : { type t = private t }
      module CommaListExpression : { type t = private t }
      module MergeDeclarationMarker : { type t = private t }
      module EndOfDeclarationMarker : { type t = private t }
      module SyntheticReferenceExpression : { type t = private t }
      module Count : { type t = private t }
      module FirstAssignment : { type t = private t }
      module LastAssignment : { type t = private t }
      module FirstCompoundAssignment : { type t = private t }
      module LastCompoundAssignment : { type t = private t }
      module FirstReservedWord : { type t = private t }
      module LastReservedWord : { type t = private t }
      module FirstKeyword : { type t = private t }
      module LastKeyword : { type t = private t }
      module FirstFutureReservedWord : { type t = private t }
      module LastFutureReservedWord : { type t = private t }
      module FirstTypeNode : { type t = private t }
      module LastTypeNode : { type t = private t }
      module FirstPunctuation : { type t = private t }
      module LastPunctuation : { type t = private t }
      module FirstToken : { type t = private t }
      module LastToken : { type t = private t }
      module FirstTriviaToken : { type t = private t }
      module LastTriviaToken : { type t = private t }
      module FirstLiteralToken : { type t = private t }
      module LastLiteralToken : { type t = private t }
      module FirstTemplateToken : { type t = private t }
      module LastTemplateToken : { type t = private t }
      module FirstBinaryOperator : { type t = private t }
      module LastBinaryOperator : { type t = private t }
      module FirstStatement : { type t = private t }
      module LastStatement : { type t = private t }
      module FirstNode : { type t = private t }
      module FirstJSDocNode : { type t = private t }
      module LastJSDocNode : { type t = private t }
      module FirstJSDocTagNode : { type t = private t }
      module LastJSDocTagNode : { type t = private t }
    }
    module TriviaSyntaxKind : {
      type t = Union.t6<SyntaxKind.SingleLineCommentTrivia.t, SyntaxKind.MultiLineCommentTrivia.t, SyntaxKind.NewLineTrivia.t, SyntaxKind.WhitespaceTrivia.t, SyntaxKind.ShebangTrivia.t, SyntaxKind.ConflictMarkerTrivia.t>
    }
    module PunctuationSyntaxKind : {
      type t = Union.t8<SyntaxKind.OpenBraceToken.t, SyntaxKind.CloseBraceToken.t, SyntaxKind.OpenParenToken.t, SyntaxKind.CloseParenToken.t, SyntaxKind.OpenBracketToken.t, SyntaxKind.CloseBracketToken.t, SyntaxKind.DotToken.t, Union.t8<SyntaxKind.DotDotDotToken.t, SyntaxKind.SemicolonToken.t, SyntaxKind.CommaToken.t, SyntaxKind.QuestionDotToken.t, SyntaxKind.LessThanToken.t, SyntaxKind.LessThanSlashToken.t, SyntaxKind.GreaterThanToken.t, Union.t8<SyntaxKind.LessThanEqualsToken.t, SyntaxKind.GreaterThanEqualsToken.t, SyntaxKind.EqualsEqualsToken.t, SyntaxKind.ExclamationEqualsToken.t, SyntaxKind.EqualsEqualsEqualsToken.t, SyntaxKind.ExclamationEqualsEqualsToken.t, SyntaxKind.EqualsGreaterThanToken.t, Union.t8<SyntaxKind.PlusToken.t, SyntaxKind.MinusToken.t, SyntaxKind.AsteriskToken.t, SyntaxKind.AsteriskAsteriskToken.t, SyntaxKind.SlashToken.t, SyntaxKind.PercentToken.t, SyntaxKind.PlusPlusToken.t, Union.t8<SyntaxKind.MinusMinusToken.t, SyntaxKind.LessThanLessThanToken.t, SyntaxKind.GreaterThanGreaterThanToken.t, SyntaxKind.GreaterThanGreaterThanGreaterThanToken.t, SyntaxKind.AmpersandToken.t, SyntaxKind.BarToken.t, SyntaxKind.CaretToken.t, Union.t8<SyntaxKind.ExclamationToken.t, SyntaxKind.TildeToken.t, SyntaxKind.AmpersandAmpersandToken.t, SyntaxKind.BarBarToken.t, SyntaxKind.QuestionQuestionToken.t, SyntaxKind.QuestionToken.t, SyntaxKind.ColonToken.t, Union.t8<SyntaxKind.AtToken.t, SyntaxKind.BacktickToken.t, SyntaxKind.HashToken.t, SyntaxKind.EqualsToken.t, SyntaxKind.PlusEqualsToken.t, SyntaxKind.MinusEqualsToken.t, SyntaxKind.AsteriskEqualsToken.t, Union.t8<SyntaxKind.AsteriskAsteriskEqualsToken.t, SyntaxKind.SlashEqualsToken.t, SyntaxKind.PercentEqualsToken.t, SyntaxKind.LessThanLessThanEqualsToken.t, SyntaxKind.GreaterThanGreaterThanEqualsToken.t, SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken.t, SyntaxKind.AmpersandEqualsToken.t, Union.t2<SyntaxKind.BarEqualsToken.t, SyntaxKind.CaretEqualsToken.t>>>>>>>>>
    }
    module PseudoLiteralSyntaxKind : {
      type t = Union.t3<SyntaxKind.TemplateHead.t, SyntaxKind.TemplateMiddle.t, SyntaxKind.TemplateTail.t>
    }
    module LiteralSyntaxKind : {
      type t = Union.t7<SyntaxKind.NumericLiteral.t, SyntaxKind.BigIntLiteral.t, SyntaxKind.StringLiteral.t, SyntaxKind.JsxText.t, SyntaxKind.JsxTextAllWhiteSpaces.t, SyntaxKind.RegularExpressionLiteral.t, SyntaxKind.NoSubstitutionTemplateLiteral.t>
    }
    module KeywordSyntaxKind : {
      type t = Union.t8<SyntaxKind.AbstractKeyword.t, SyntaxKind.AnyKeyword.t, SyntaxKind.AsKeyword.t, SyntaxKind.AssertsKeyword.t, SyntaxKind.AssertKeyword.t, SyntaxKind.AsyncKeyword.t, SyntaxKind.AwaitKeyword.t, Union.t8<SyntaxKind.BigIntKeyword.t, SyntaxKind.BooleanKeyword.t, SyntaxKind.BreakKeyword.t, SyntaxKind.CaseKeyword.t, SyntaxKind.CatchKeyword.t, SyntaxKind.ClassKeyword.t, SyntaxKind.ConstKeyword.t, Union.t8<SyntaxKind.ConstructorKeyword.t, SyntaxKind.ContinueKeyword.t, SyntaxKind.DebuggerKeyword.t, SyntaxKind.DeclareKeyword.t, SyntaxKind.DefaultKeyword.t, SyntaxKind.DeleteKeyword.t, SyntaxKind.DoKeyword.t, Union.t8<SyntaxKind.ElseKeyword.t, SyntaxKind.EnumKeyword.t, SyntaxKind.ExportKeyword.t, SyntaxKind.ExtendsKeyword.t, SyntaxKind.FalseKeyword.t, SyntaxKind.FinallyKeyword.t, SyntaxKind.ForKeyword.t, Union.t8<SyntaxKind.FromKeyword.t, SyntaxKind.FunctionKeyword.t, SyntaxKind.GetKeyword.t, SyntaxKind.GlobalKeyword.t, SyntaxKind.IfKeyword.t, SyntaxKind.ImplementsKeyword.t, SyntaxKind.ImportKeyword.t, Union.t8<SyntaxKind.InferKeyword.t, SyntaxKind.InKeyword.t, SyntaxKind.InstanceOfKeyword.t, SyntaxKind.InterfaceKeyword.t, SyntaxKind.IntrinsicKeyword.t, SyntaxKind.IsKeyword.t, SyntaxKind.KeyOfKeyword.t, Union.t8<SyntaxKind.LetKeyword.t, SyntaxKind.ModuleKeyword.t, SyntaxKind.NamespaceKeyword.t, SyntaxKind.NeverKeyword.t, SyntaxKind.NewKeyword.t, SyntaxKind.NullKeyword.t, SyntaxKind.NumberKeyword.t, Union.t8<SyntaxKind.ObjectKeyword.t, SyntaxKind.OfKeyword.t, SyntaxKind.PackageKeyword.t, SyntaxKind.PrivateKeyword.t, SyntaxKind.ProtectedKeyword.t, SyntaxKind.PublicKeyword.t, SyntaxKind.ReadonlyKeyword.t, Union.t8<SyntaxKind.OverrideKeyword.t, SyntaxKind.RequireKeyword.t, SyntaxKind.ReturnKeyword.t, SyntaxKind.SetKeyword.t, SyntaxKind.StaticKeyword.t, SyntaxKind.StringKeyword.t, SyntaxKind.SuperKeyword.t, Union.t8<SyntaxKind.SwitchKeyword.t, SyntaxKind.SymbolKeyword.t, SyntaxKind.ThisKeyword.t, SyntaxKind.ThrowKeyword.t, SyntaxKind.TrueKeyword.t, SyntaxKind.TryKeyword.t, SyntaxKind.TypeKeyword.t, Union.t8<SyntaxKind.TypeOfKeyword.t, SyntaxKind.UndefinedKeyword.t, SyntaxKind.UniqueKeyword.t, SyntaxKind.UnknownKeyword.t, SyntaxKind.VarKeyword.t, SyntaxKind.VoidKeyword.t, SyntaxKind.WhileKeyword.t, Union.t2<SyntaxKind.WithKeyword.t, SyntaxKind.YieldKeyword.t>>>>>>>>>>>>
    }
    module TokenSyntaxKind : {
      type t = Union.t8<SyntaxKind.Unknown.t, SyntaxKind.EndOfFileToken.t, TriviaSyntaxKind.t, LiteralSyntaxKind.t, PseudoLiteralSyntaxKind.t, PunctuationSyntaxKind.t, SyntaxKind.Identifier.t, KeywordSyntaxKind.t>
    }
    module TokenFlags : {
      type t = [#0 | #16 | #32 | #64 | #128 | #256]
      module None : { type t = [#0] }
      module Scientific : { type t = [#16] }
      module Octal : { type t = [#32] }
      module HexSpecifier : { type t = [#64] }
      module BinarySpecifier : { type t = [#128] }
      module OctalSpecifier : { type t = [#256] }
    }
    module TokenClass : {
      type t =   | Punctuation
        | Keyword
        | Operator
        | Comment
        | Whitespace
        | Identifier
        | NumberLiteral
        | BigIntLiteral
        | StringLiteral
        | RegExpLiteral
      module Punctuation : { type t = private t }
      module Keyword : { type t = private t }
      module Operator : { type t = private t }
      module Comment : { type t = private t }
      module Whitespace : { type t = private t }
      module Identifier : { type t = private t }
      module NumberLiteral : { type t = private t }
      module BigIntLiteral : { type t = private t }
      module StringLiteral : { type t = private t }
      module RegExpLiteral : { type t = private t }
    }
    module TodoCommentDescriptor : { type t = intf'<[#Ts_TodoCommentDescriptor]> }
    module TodoComment : { type t = intf'<[#Ts_TodoComment]> }
    module ThisTypeNode : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_ThisTypeNode | #Ts_TypeNode]>
    }
    module TextSpan : { type t = intf'<[#Ts_TextSpan]> }
    module TextInsertion : { type t = intf'<[#Ts_TextInsertion]> }
    module TextChangeRange : { type t = intf'<[#Ts_TextChangeRange]> }
    module TextChange : { type t = intf'<[#Ts_TextChange]> }
    module TemplateSpan : { type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_TemplateSpan]> }
    module TemplateLiteralTypeSpan : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_TemplateLiteralTypeSpan | #Ts_TypeNode]>
    }
    module TemplateLiteralTypeNode : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_TemplateLiteralTypeNode | #Ts_TypeNode]>
    }
    module InstantiableType : { type t = intf'<[#Ts_InstantiableType | #Ts_Type]> }
    module TemplateLiteralType : { type t = intf'<[#Ts_InstantiableType | #Ts_TemplateLiteralType | #Ts_Type]> }
    module LiteralLikeNode : { type t = intf'<[#Ts_LiteralLikeNode | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module TemplateLiteralLikeNode : {
      type t = intf'<[#Ts_LiteralLikeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TemplateLiteralLikeNode]>
    }
    module TemplateTail : {
      type t = intf'<[#Ts_LiteralLikeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TemplateLiteralLikeNode | #Ts_TemplateTail]>
    }
    module TemplateMiddle : {
      type t = intf'<[#Ts_LiteralLikeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TemplateLiteralLikeNode | #Ts_TemplateMiddle]>
    }
    module TemplateHead : {
      type t = intf'<[#Ts_LiteralLikeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TemplateHead | #Ts_TemplateLiteralLikeNode]>
    }
    module PseudoLiteralToken : { type t = Union.t3<TemplateHead.t, TemplateMiddle.t, TemplateTail.t> }
    module LiteralExpression : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_LiteralExpression | #Ts_LiteralLikeNode | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module NoSubstitutionTemplateLiteral : {
      type t = intf'<[#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_LiteralExpression | #Ts_LiteralLikeNode | #Ts_MemberExpression | #Ts_NoSubstitutionTemplateLiteral | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_TemplateLiteralLikeNode | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module TemplateLiteralToken : { type t = Union.t2<NoSubstitutionTemplateLiteral.t, PseudoLiteralToken.t> }
    module TemplateExpression : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_TemplateExpression | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module TemplateLiteral : { type t = Union.t2<TemplateExpression.t, NoSubstitutionTemplateLiteral.t> }
    module System : { type t = intf'<[#Ts_System]> }
    module SyntheticExpression : {
      type t = intf'<[#Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SyntheticExpression]>
    }
    module TextRange : { type t = intf'<[#Ts_TextRange]> }
    module CommentRange : { type t = intf'<[#Ts_CommentRange | #Ts_TextRange]> }
    module SynthesizedComment : { type t = intf'<[#Ts_CommentRange | #Ts_SynthesizedComment | #Ts_TextRange]> }
    module SyntaxList : { type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_SyntaxList]> }
    module InternalSymbolName : {
      type t = [#"__call" | #"__constructor" | #"__new" | #"__index" | #"__export" | #"__global" | #"__missing" | #"__type" | #"__object" | #"__jsxAttributes" | #"__class" | #"__function" | #"__computed" | #"__resolving__" | #"export=" | #default | #this]
      module Call : { type t = [#"__call"] }
      module Constructor : { type t = [#"__constructor"] }
      module New : { type t = [#"__new"] }
      module Index : { type t = [#"__index"] }
      module ExportStar : { type t = [#"__export"] }
      module Global : { type t = [#"__global"] }
      module Missing : { type t = [#"__missing"] }
      module Type : { type t = [#"__type"] }
      module Object : { type t = [#"__object"] }
      module JSXAttributes : { type t = [#"__jsxAttributes"] }
      module Class : { type t = [#"__class"] }
      module Function : { type t = [#"__function"] }
      module Computed : { type t = [#"__computed"] }
      module Resolving : { type t = [#"__resolving__"] }
      module ExportEquals : { type t = [#"export="] }
      module Default_ : { type t = [#default] }
      module This : { type t = [#this] }
    }
    module M__String : {
      module AnonymousInterface1 : { type t = private any }
      type t = Union.t3<Intersection.t2<string, AnonymousInterface1.t>, Intersection.t2<unit, AnonymousInterface1.t>, InternalSymbolName.t>
    }
    module ReadonlyCollection : { type t<'K> = intf'<[#Ts_ReadonlyCollection('K)]> }
    module ReadonlyESMap : {
      type t<'K, 'V> = intf'<[#Ts_ReadonlyCollection('K) | #Ts_ReadonlyESMap('K, 'V)]>
    }
    module ReadonlyUnderscoreEscapedMap : {
      type t<'T> = intf'<[#Ts_ReadonlyCollection(M__String.t) | #Ts_ReadonlyUnderscoreEscapedMap('T) | #Ts_ReadonlyESMap(M__String.t, 'T)]>
    }
    module Collection : { type t<'K> = intf'<[#Ts_Collection('K) | #Ts_ReadonlyCollection('K)]> }
    module ESMap : {
      type t<'K, 'V> = intf'<[#Ts_Collection('K) | #Ts_ReadonlyCollection('K) | #Ts_ESMap('K, 'V) | #Ts_ReadonlyESMap('K, 'V)]>
    }
    module UnderscoreEscapedMap : {
      type t<'T> = intf'<[#Ts_Collection(M__String.t) | #Ts_ReadonlyCollection(M__String.t) | #Ts_ReadonlyUnderscoreEscapedMap('T) | #Ts_UnderscoreEscapedMap('T) | #Ts_ESMap(M__String.t, 'T) | #Ts_ReadonlyESMap(M__String.t, 'T)]>
    }
    module Symbol : { type t = intf'<[#Ts_Symbol]> }
    module SymbolTable : { type t = UnderscoreEscapedMap.t<Symbol.t> }
    module SymbolFormatFlags : {
      type t = [#0 | #1 | #2 | #4 | #8]
      module None : { type t = [#0] }
      module WriteTypeParametersOrArguments : { type t = [#1] }
      module UseOnlyExternalAliasing : { type t = [#2] }
      module AllowAnyNodeKind : { type t = [#4] }
      module UseAliasDefinedOutsideCurrentScope : { type t = [#8] }
    }
    module SymbolFlags : {
      type t = [#0 | #1 | #2 | #4 | #8 | #16 | #32 | #64 | #128 | #256 | #512 | #1024 | #2048 | #4096 | #8192 | #16384 | #32768 | #65536 | #131072 | #262144 | #524288 | #1048576 | #2097152 | #4194304 | #8388608 | #16777216 | #33554432 | #67108864 | #134217728 | #384 | #3 | #111551 | #788968 | #1920 | #1536 | #98304 | #111550 | #900095 | #110991 | #899503 | #788872 | #899327 | #899967 | #110735 | #103359 | #46015 | #78783 | #526824 | #2623475 | #944 | #418 | #98308 | #106500]
      module None : { type t = [#0] }
      module FunctionScopedVariable : { type t = [#1] }
      module BlockScopedVariable : { type t = [#2] }
      module Property : { type t = [#4] }
      module EnumMember : { type t = [#8] }
      module Function : { type t = [#16] }
      module Class : { type t = [#32] }
      module Interface : { type t = [#64] }
      module ConstEnum : { type t = [#128] }
      module RegularEnum : { type t = [#256] }
      module ValueModule : { type t = [#512] }
      module NamespaceModule : { type t = [#1024] }
      module TypeLiteral : { type t = [#2048] }
      module ObjectLiteral : { type t = [#4096] }
      module Method : { type t = [#8192] }
      module Constructor : { type t = [#16384] }
      module GetAccessor : { type t = [#32768] }
      module SetAccessor : { type t = [#65536] }
      module Signature : { type t = [#131072] }
      module TypeParameter : { type t = [#262144] }
      module TypeAlias : { type t = [#524288] }
      module ExportValue : { type t = [#1048576] }
      module Alias : { type t = [#2097152] }
      module Prototype : { type t = [#4194304] }
      module ExportStar : { type t = [#8388608] }
      module Optional : { type t = [#16777216] }
      module Transient : { type t = [#33554432] }
      module Assignment : { type t = [#67108864] }
      module ModuleExports : { type t = [#134217728] }
      module Enum : { type t = [#384] }
      module Variable : { type t = [#3] }
      module Value : { type t = [#111551] }
      module Type : { type t = [#788968] }
      module Namespace : { type t = [#1920] }
      module Module : { type t = [#1536] }
      module Accessor : { type t = [#98304] }
      module FunctionScopedVariableExcludes : { type t = [#111550] }
      module BlockScopedVariableExcludes : { type t = [#111551] }
      module ParameterExcludes : { type t = [#111551] }
      module PropertyExcludes : { type t = [#0] }
      module EnumMemberExcludes : { type t = [#900095] }
      module FunctionExcludes : { type t = [#110991] }
      module ClassExcludes : { type t = [#899503] }
      module InterfaceExcludes : { type t = [#788872] }
      module RegularEnumExcludes : { type t = [#899327] }
      module ConstEnumExcludes : { type t = [#899967] }
      module ValueModuleExcludes : { type t = [#110735] }
      module NamespaceModuleExcludes : { type t = [#0] }
      module MethodExcludes : { type t = [#103359] }
      module GetAccessorExcludes : { type t = [#46015] }
      module SetAccessorExcludes : { type t = [#78783] }
      module TypeParameterExcludes : { type t = [#526824] }
      module TypeAliasExcludes : { type t = [#788968] }
      module AliasExcludes : { type t = [#2097152] }
      module ModuleMember : { type t = [#2623475] }
      module ExportHasLocal : { type t = [#944] }
      module BlockScoped : { type t = [#418] }
      module PropertyOrAccessor : { type t = [#98308] }
      module ClassMember : { type t = [#106500] }
    }
    module SymbolDisplayPartKind : {
      type t =   | AliasName
        | ClassName
        | EnumName
        | FieldName
        | InterfaceName
        | Keyword
        | LineBreak
        | NumericLiteral
        | StringLiteral
        | LocalName
        | MethodName
        | ModuleName
        | Operator
        | ParameterName
        | PropertyName
        | Punctuation
        | Space
        | Text
        | TypeParameterName
        | EnumMemberName
        | FunctionName
        | RegularExpressionLiteral
        | Link
        | LinkName
        | LinkText
      module AliasName : { type t = private t }
      module ClassName : { type t = private t }
      module EnumName : { type t = private t }
      module FieldName : { type t = private t }
      module InterfaceName : { type t = private t }
      module Keyword : { type t = private t }
      module LineBreak : { type t = private t }
      module NumericLiteral : { type t = private t }
      module StringLiteral : { type t = private t }
      module LocalName : { type t = private t }
      module MethodName : { type t = private t }
      module ModuleName : { type t = private t }
      module Operator : { type t = private t }
      module ParameterName : { type t = private t }
      module PropertyName : { type t = private t }
      module Punctuation : { type t = private t }
      module Space : { type t = private t }
      module Text : { type t = private t }
      module TypeParameterName : { type t = private t }
      module EnumMemberName : { type t = private t }
      module FunctionName : { type t = private t }
      module RegularExpressionLiteral : { type t = private t }
      module Link : { type t = private t }
      module LinkName : { type t = private t }
      module LinkText : { type t = private t }
    }
    module PropertyAccessExpression : {
      type t = intf'<[#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyAccessExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module SuperPropertyAccessExpression : {
      type t = intf'<[#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyAccessExpression | #Ts_ReadonlyTextRange | #Ts_SuperPropertyAccessExpression | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module ElementAccessExpression : {
      type t = intf'<[#Ts_ElementAccessExpression | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module SuperElementAccessExpression : {
      type t = intf'<[#Ts_ElementAccessExpression | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SuperElementAccessExpression | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module SuperProperty : {
      type t = Union.t2<SuperPropertyAccessExpression.t, SuperElementAccessExpression.t>
    }
    module SuperExpression : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_SuperExpression | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module CallExpression : {
      type t = intf'<[#Ts_CallExpression | #Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module SuperCall : {
      type t = intf'<[#Ts_CallExpression | #Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SuperCall | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module SubstitutionType : { type t = intf'<[#Ts_InstantiableType | #Ts_SubstitutionType | #Ts_Type]> }
    module UnionOrIntersectionType : { type t = intf'<[#Ts_Type | #Ts_UnionOrIntersectionType]> }
    module UnionType : { type t = intf'<[#Ts_Type | #Ts_UnionOrIntersectionType | #Ts_UnionType]> }
    module IntersectionType : { type t = intf'<[#Ts_IntersectionType | #Ts_Type | #Ts_UnionOrIntersectionType]> }
    module StructuredType : { type t = Union.t3<ObjectType.t, UnionType.t, IntersectionType.t> }
    module StringMappingType : { type t = intf'<[#Ts_InstantiableType | #Ts_StringMappingType | #Ts_Type]> }
    module LiteralType : { type t = intf'<[#Ts_LiteralType | #Ts_Type]> }
    module StringLiteralType : { type t = intf'<[#Ts_LiteralType | #Ts_StringLiteralType | #Ts_Type]> }
    module SourceMapSpan : { type t = intf'<[#Ts_SourceMapSpan]> }
    module SourceMapSource : { type t = intf'<[#Ts_SourceMapSource]> }
    module SourceMapRange : { type t = intf'<[#Ts_SourceMapRange | #Ts_TextRange]> }
    module SourceFileLike : { type t = intf'<[#Ts_SourceFileLike]> }
    module SortedReadonlyArray : { type t<'T> = intf'<[#ReadonlyArray('T) | #Ts_SortedReadonlyArray('T)]> }
    module SortedArray : { type t<'T> = intf'<[#Array('T) | #Ts_SortedArray('T)]> }
    module SolutionBuilderHostBase : { type t<'T> = intf'<[#Ts_ProgramHost('T) | #Ts_SolutionBuilderHostBase('T)]> }
    module SolutionBuilderWithWatchHost : {
      type t<'T> = intf'<[#Ts_ProgramHost('T) | #Ts_SolutionBuilderHostBase('T) | #Ts_SolutionBuilderWithWatchHost('T) | #Ts_WatchHost]>
    }
    module SolutionBuilderHost : {
      type t<'T> = intf'<[#Ts_ProgramHost('T) | #Ts_SolutionBuilderHost('T) | #Ts_SolutionBuilderHostBase('T)]>
    }
    module SolutionBuilder : { type t<'T> = intf'<[#Ts_SolutionBuilder('T)]> }
    module SignatureKind : {
      type t = Call | Construct
      module Call : { type t = private t }
      module Construct : { type t = private t }
    }
    module SignatureHelpRetriggeredReason : { type t = intf'<[#Ts_SignatureHelpRetriggeredReason]> }
    module SignatureHelpInvokedReason : { type t = intf'<[#Ts_SignatureHelpInvokedReason]> }
    module SignatureHelpCharacterTypedReason : { type t = intf'<[#Ts_SignatureHelpCharacterTypedReason]> }
    module SignatureHelpTriggerReason : {
      type t = Union.t3<SignatureHelpInvokedReason.t, SignatureHelpCharacterTypedReason.t, SignatureHelpRetriggeredReason.t>
    }
    module SignatureHelpTriggerCharacter : { type t = Union.t3<[#","], [#"("], [#"<"]> }
    module SignatureHelpRetriggerCharacter : { type t = Union.t2<SignatureHelpTriggerCharacter.t, [#")"]> }
    module SignatureHelpParameter : { type t = intf'<[#Ts_SignatureHelpParameter]> }
    module SignatureHelpItemsOptions : { type t = intf'<[#Ts_SignatureHelpItemsOptions]> }
    module SignatureHelpItems : { type t = intf'<[#Ts_SignatureHelpItems]> }
    module SignatureHelpItem : { type t = intf'<[#Ts_SignatureHelpItem]> }
    module Signature : { type t = intf'<[#Ts_Signature]> }
    module ReadonlySet : { type t<'T> = intf'<[#Ts_ReadonlyCollection('T) | #Ts_ReadonlySet('T)]> }
    module Set : {
      type t<'T> = intf'<[#Ts_Collection('T) | #Ts_ReadonlyCollection('T) | #Ts_ReadonlySet('T) | #Ts_Set('T)]>
    }
    module SemicolonPreference : {
      type t = [#ignore | #insert | #remove]
      module Ignore : { type t = [#ignore] }
      module Insert : { type t = [#insert] }
      module Remove : { type t = [#remove] }
    }
    module SemicolonClassElement : {
      type t = intf'<[#Ts_ClassElement | #Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SemicolonClassElement]>
    }
    module SemanticClassificationFormat : {
      type t = [#original | #"2020"]
      module Original : { type t = [#original] }
      module TwentyTwenty : { type t = [#"2020"] }
    }
    module SelectionRange : { type t = intf'<[#Ts_SelectionRange]> }
    module ScriptTarget : {
      type t = [#0 | #1 | #2 | #3 | #4 | #5 | #6 | #7 | #8 | #9 | #99 | #100]
      module ES3 : { type t = [#0] }
      module ES5 : { type t = [#1] }
      module ES2015 : { type t = [#2] }
      module ES2016 : { type t = [#3] }
      module ES2017 : { type t = [#4] }
      module ES2018 : { type t = [#5] }
      module ES2019 : { type t = [#6] }
      module ES2020 : { type t = [#7] }
      module ES2021 : { type t = [#8] }
      module ES2022 : { type t = [#9] }
      module ESNext : { type t = [#99] }
      module JSON : { type t = [#100] }
      module Latest : { type t = [#99] }
    }
    module ScriptKind : {
      type t = Unknown | JS | JSX | TS | TSX | External | JSON | Deferred
      module Unknown : { type t = private t }
      module JS : { type t = private t }
      module JSX : { type t = private t }
      module TS : { type t = private t }
      module TSX : { type t = private t }
      module External : { type t = private t }
      module JSON : { type t = private t }
      module Deferred : { type t = private t }
    }
    module ScriptElementKindModifier : {
      type t = [#"" | #public | #"private" | #protected | #"export" | #declare | #static | #abstract | #optional | #deprecated | #".d.ts" | #".ts" | #".tsx" | #".js" | #".jsx" | #".json" | #".d.mts" | #".mts" | #".mjs" | #".d.cts" | #".cts" | #".cjs"]
      module None : { type t = [#""] }
      module PublicMemberModifier : { type t = [#public] }
      module PrivateMemberModifier : { type t = [#"private"] }
      module ProtectedMemberModifier : { type t = [#protected] }
      module ExportedModifier : { type t = [#"export"] }
      module AmbientModifier : { type t = [#declare] }
      module StaticModifier : { type t = [#static] }
      module AbstractModifier : { type t = [#abstract] }
      module OptionalModifier : { type t = [#optional] }
      module DeprecatedModifier : { type t = [#deprecated] }
      module DtsModifier : { type t = [#".d.ts"] }
      module TsModifier : { type t = [#".ts"] }
      module TsxModifier : { type t = [#".tsx"] }
      module JsModifier : { type t = [#".js"] }
      module JsxModifier : { type t = [#".jsx"] }
      module JsonModifier : { type t = [#".json"] }
      module DmtsModifier : { type t = [#".d.mts"] }
      module MtsModifier : { type t = [#".mts"] }
      module MjsModifier : { type t = [#".mjs"] }
      module DctsModifier : { type t = [#".d.cts"] }
      module CtsModifier : { type t = [#".cts"] }
      module CjsModifier : { type t = [#".cjs"] }
    }
    module ScriptElementKind : {
      type t = [#"" | #warning | #keyword | #script | #"module" | #class | #"local class" | #interface | #"type" | #enum | #"enum member" | #var | #"local var" | #function | #"local function" | #method | #getter | #setter | #property | #constructor | #call | #index | #construct | #parameter | #"type parameter" | #"primitive type" | #label | #alias | #const | #"let" | #directory | #"external module name" | #"JSX attribute" | #string | #link | #"link name" | #"link text"]
      module Unknown : { type t = [#""] }
      module Warning : { type t = [#warning] }
      module Keyword : { type t = [#keyword] }
      module ScriptElement : { type t = [#script] }
      module ModuleElement : { type t = [#"module"] }
      module ClassElement : { type t = [#class] }
      module LocalClassElement : { type t = [#"local class"] }
      module InterfaceElement : { type t = [#interface] }
      module TypeElement : { type t = [#"type"] }
      module EnumElement : { type t = [#enum] }
      module EnumMemberElement : { type t = [#"enum member"] }
      module VariableElement : { type t = [#var] }
      module LocalVariableElement : { type t = [#"local var"] }
      module FunctionElement : { type t = [#function] }
      module LocalFunctionElement : { type t = [#"local function"] }
      module MemberFunctionElement : { type t = [#method] }
      module MemberGetAccessorElement : { type t = [#getter] }
      module MemberSetAccessorElement : { type t = [#setter] }
      module MemberVariableElement : { type t = [#property] }
      module ConstructorImplementationElement : { type t = [#constructor] }
      module CallSignatureElement : { type t = [#call] }
      module IndexSignatureElement : { type t = [#index] }
      module ConstructSignatureElement : { type t = [#construct] }
      module ParameterElement : { type t = [#parameter] }
      module TypeParameterElement : { type t = [#"type parameter"] }
      module PrimitiveType : { type t = [#"primitive type"] }
      module Label : { type t = [#label] }
      module Alias : { type t = [#alias] }
      module ConstElement : { type t = [#const] }
      module LetElement : { type t = [#"let"] }
      module Directory : { type t = [#directory] }
      module ExternalModuleName : { type t = [#"external module name"] }
      module JsxAttribute : { type t = [#"JSX attribute"] }
      module String : { type t = [#string] }
      module Link : { type t = [#link] }
      module LinkName : { type t = [#"link name"] }
      module LinkText : { type t = [#"link text"] }
    }
    module Scanner : { type t = intf'<[#Ts_Scanner]> }
    module RestTypeNode : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_RestTypeNode | #Ts_TypeNode]>
    }
    module ResolvedTypeReferenceDirective : { type t = intf'<[#Ts_ResolvedTypeReferenceDirective]> }
    module ResolvedProjectReference : { type t = intf'<[#Ts_ResolvedProjectReference]> }
    module ResolvedModule : { type t = intf'<[#Ts_ResolvedModule]> }
    module ResolvedModuleFull : { type t = intf'<[#Ts_ResolvedModule | #Ts_ResolvedModuleFull]> }
    module ResolvedConfigFileName : {
      module AnonymousInterface3 : { type t = private any }
      type t = Intersection.t2<string, AnonymousInterface3.t>
    }
    module ResolveProjectReferencePathHost : { type t = intf'<[#Ts_ResolveProjectReferencePathHost]> }
    module ReportFileInError : { type t = intf'<[#Ts_ReportFileInError]> }
    module ReportEmitErrorSummary : {
      type t = (~errorCount:float, ~filesInError:array<undefined<ReportFileInError.t>>) => unit
    }
    module DocumentSpan : { type t = intf'<[#Ts_DocumentSpan]> }
    module RenameLocation : { type t = intf'<[#Ts_DocumentSpan | #Ts_RenameLocation]> }
    module RenameInfoOptions : { type t = intf'<[#Ts_RenameInfoOptions]> }
    module RenameInfoSuccess : { type t = intf'<[#Ts_RenameInfoSuccess]> }
    module RenameInfoFailure : { type t = intf'<[#Ts_RenameInfoFailure]> }
    module RenameInfo : { type t = Union.t2<RenameInfoSuccess.t, RenameInfoFailure.t> }
    module DefinitionInfo : { type t = intf'<[#Ts_DefinitionInfo | #Ts_DocumentSpan]> }
    module ReferencedSymbolDefinitionInfo : {
      type t = intf'<[#Ts_DefinitionInfo | #Ts_DocumentSpan | #Ts_ReferencedSymbolDefinitionInfo]>
    }
    module ReferencedSymbol : { type t = intf'<[#Ts_ReferencedSymbol]> }
    module ReferenceEntry : { type t = intf'<[#Ts_DocumentSpan | #Ts_ReferenceEntry]> }
    module RefactorTriggerReason : { type t = Union.t2<[#implicit], [#invoked]> }
    module RefactorEditInfo : { type t = intf'<[#Ts_RefactorEditInfo]> }
    module RefactorActionInfo : { type t = intf'<[#Ts_RefactorActionInfo]> }
    module Token : { type t<'TKind> = intf'<[#Ts_Token('TKind) | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module KeywordToken : {
      type t<'TKind> = intf'<[#Ts_KeywordToken('TKind) | #Ts_Token('TKind) | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module ModifierToken : {
      type t<'TKind> = intf'<[#Ts_KeywordToken('TKind) | #Ts_ModifierToken('TKind) | #Ts_Token('TKind) | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module ReadonlyKeyword : { type t = ModifierToken.t<SyntaxKind.ReadonlyKeyword.t> }
    module ReadonlyToken : { type t = ReadonlyKeyword.t }
    module ReadonlyMap : {
      type t<'T> = intf'<[#Ts_ReadonlyCollection(string) | #Ts_ReadonlyMap('T) | #Ts_ReadonlyESMap(string, 'T)]>
    }
    module ReadBuildProgramHost : { type t = intf'<[#Ts_ReadBuildProgramHost]> }
    module QuickInfo : { type t = intf'<[#Ts_QuickInfo]> }
    module PunctuationToken : {
      type t<'TKind> = intf'<[#Ts_PunctuationToken('TKind) | #Ts_Token('TKind) | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module QuestionToken : { type t = PunctuationToken.t<SyntaxKind.QuestionToken.t> }
    module QuestionDotToken : { type t = PunctuationToken.t<SyntaxKind.QuestionDotToken.t> }
    module Push : { type t<'T> = intf'<[#Ts_Push('T)]> }
    module PseudoBigInt : { type t = intf'<[#Ts_PseudoBigInt]> }
    module StringLiteral : {
      type t = intf'<[#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_LiteralExpression | #Ts_LiteralLikeNode | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_StringLiteral | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module StringLiteralLike : { type t = Union.t2<StringLiteral.t, NoSubstitutionTemplateLiteral.t> }
    module NumericLiteral : {
      type t = intf'<[#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_LiteralExpression | #Ts_LiteralLikeNode | #Ts_MemberExpression | #Ts_Node | #Ts_NumericLiteral | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module PropertyNameLiteral : { type t = Union.t3<Identifier.t, StringLiteralLike.t, NumericLiteral.t> }
    module PrivateIdentifier : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_PrivateIdentifier | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module ComputedPropertyName : { type t = intf'<[#Ts_ComputedPropertyName | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module PropertyName : {
      type t = Union.t5<Identifier.t, StringLiteral.t, NumericLiteral.t, ComputedPropertyName.t, PrivateIdentifier.t>
    }
    module PropertyLikeDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyLikeDeclaration | #Ts_ReadonlyTextRange]>
    }
    module PrinterOptions : { type t = intf'<[#Ts_PrinterOptions]> }
    module Printer : { type t = intf'<[#Ts_Printer]> }
    module PrintHandlers : { type t = intf'<[#Ts_PrintHandlers]> }
    module PrefixUnaryOperator : {
      type t = Union.t6<SyntaxKind.PlusPlusToken.t, SyntaxKind.MinusMinusToken.t, SyntaxKind.PlusToken.t, SyntaxKind.MinusToken.t, SyntaxKind.TildeToken.t, SyntaxKind.ExclamationToken.t>
    }
    module PreProcessedFileInfo : { type t = intf'<[#Ts_PreProcessedFileInfo]> }
    module PostfixUnaryOperator : { type t = Union.t2<SyntaxKind.PlusPlusToken.t, SyntaxKind.MinusMinusToken.t> }
    module PostfixUnaryExpression : {
      type t = intf'<[#Ts_Expression | #Ts_Node | #Ts_PostfixUnaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module PollingWatchKind : {
      type t = FixedInterval | PriorityInterval | DynamicPriority | FixedChunkSize
      module FixedInterval : { type t = private t }
      module PriorityInterval : { type t = private t }
      module DynamicPriority : { type t = private t }
      module FixedChunkSize : { type t = private t }
    }
    module PlusToken : { type t = PunctuationToken.t<SyntaxKind.PlusToken.t> }
    module PerformanceEvent : { type t = intf'<[#Ts_PerformanceEvent]> }
    module PerModuleNameCache : { type t = intf'<[#Ts_PerModuleNameCache]> }
    module Path : {
      module AnonymousInterface2 : { type t = private any }
      type t = Intersection.t2<string, AnonymousInterface2.t>
    }
    module PartiallyEmittedExpression : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_PartiallyEmittedExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module ParsedTsconfig : { type t = intf'<[#Ts_ParsedTsconfig]> }
    module ParsedCommandLine : { type t = intf'<[#Ts_ParsedCommandLine]> }
    module ParseConfigHost : { type t = intf'<[#Ts_ParseConfigHost]> }
    module ParseConfigFileHost : {
      type t = intf'<[#Ts_ConfigFileDiagnosticsReporter | #Ts_ParseConfigFileHost | #Ts_ParseConfigHost]>
    }
    module PublicKeyword : { type t = ModifierToken.t<SyntaxKind.PublicKeyword.t> }
    module ProtectedKeyword : { type t = ModifierToken.t<SyntaxKind.ProtectedKeyword.t> }
    module PrivateKeyword : { type t = ModifierToken.t<SyntaxKind.PrivateKeyword.t> }
    module AccessibilityModifier : { type t = Union.t3<PublicKeyword.t, PrivateKeyword.t, ProtectedKeyword.t> }
    module ParameterPropertyModifier : { type t = Union.t2<AccessibilityModifier.t, ReadonlyKeyword.t> }
    module SignatureDeclarationBase : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase]>
    }
    module FunctionLikeDeclarationBase : {
      type t = intf'<[#Ts_Declaration | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase]>
    }
    module ConstructorDeclaration : {
      type t = intf'<[#Ts_ClassElement | #Ts_ConstructorDeclaration | #Ts_Declaration | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase]>
    }
    module ParameterPropertyDeclaration : {
      module AnonymousInterface22 : { type t = private any }
      type t = Intersection.t2<ParameterDeclaration.t, AnonymousInterface22.t>
    }
    module PackageId : { type t = intf'<[#Ts_PackageId]> }
    module OutputFileType : {
      type t = JavaScript | SourceMap | Declaration
      module JavaScript : { type t = private t }
      module SourceMap : { type t = private t }
      module Declaration : { type t = private t }
    }
    module OutputFile : { type t = intf'<[#Ts_OutputFile]> }
    module OutliningSpanKind : {
      type t = [#comment | #region | #code | #imports]
      module Comment : { type t = [#comment] }
      module Region : { type t = [#region] }
      module Code : { type t = [#code] }
      module Imports : { type t = [#imports] }
    }
    module OutliningSpan : { type t = intf'<[#Ts_OutliningSpan]> }
    module OuterExpressionKinds : {
      type t = [#1 | #2 | #4 | #8 | #6 | #15 | #16]
      module Parentheses : { type t = [#1] }
      module TypeAssertions : { type t = [#2] }
      module NonNullAssertions : { type t = [#4] }
      module PartiallyEmittedExpressions : { type t = [#8] }
      module Assertions : { type t = [#6] }
      module All : { type t = [#15] }
      module ExcludeJSDocTypeAssertion : { type t = [#16] }
    }
    module CombinedCodeFixScope : { type t = intf'<[#Ts_CombinedCodeFixScope]> }
    module OrganizeImportsArgs : { type t = intf'<[#Ts_CombinedCodeFixScope | #Ts_OrganizeImportsArgs]> }
    module OptionalTypeNode : {
      type t = intf'<[#Ts_Node | #Ts_OptionalTypeNode | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module PropertyAccessChain : {
      type t = intf'<[#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyAccessChain | #Ts_PropertyAccessExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module NonNullExpression : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_NonNullExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module NonNullChain : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_NonNullChain | #Ts_NonNullExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module ElementAccessChain : {
      type t = intf'<[#Ts_ElementAccessChain | #Ts_ElementAccessExpression | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module CallChain : {
      type t = intf'<[#Ts_CallChain | #Ts_CallExpression | #Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module OptionalChain : {
      type t = Union.t4<PropertyAccessChain.t, ElementAccessChain.t, CallChain.t, NonNullChain.t>
    }
    module OperationCanceledException : { type t = intf'<[#Ts_OperationCanceledException]> }
    module TypeLiteralNode : {
      type t = intf'<[#Ts_Declaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeLiteralNode | #Ts_TypeNode]>
    }
    module InterfaceDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_InterfaceDeclaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module ClassLikeDeclarationBase : {
      type t = intf'<[#Ts_ClassLikeDeclarationBase | #Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module ClassExpression : {
      type t = intf'<[#Ts_ClassExpression | #Ts_ClassLikeDeclarationBase | #Ts_Declaration | #Ts_Expression | #Ts_JSDocContainer | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module ClassDeclaration : {
      type t = intf'<[#Ts_ClassDeclaration | #Ts_ClassLikeDeclarationBase | #Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module ClassLikeDeclaration : { type t = Union.t2<ClassDeclaration.t, ClassExpression.t> }
    module ObjectTypeDeclaration : {
      type t = Union.t3<ClassLikeDeclaration.t, InterfaceDeclaration.t, TypeLiteralNode.t>
    }
    module ObjectFlags : {
      type t = [#1 | #2 | #4 | #8 | #16 | #32 | #64 | #128 | #256 | #512 | #1024 | #2048 | #4096 | #8192 | #16384 | #32768 | #3 | #4194304 | #8388608]
      module Class : { type t = [#1] }
      module Interface : { type t = [#2] }
      module Reference : { type t = [#4] }
      module Tuple : { type t = [#8] }
      module Anonymous : { type t = [#16] }
      module Mapped : { type t = [#32] }
      module Instantiated : { type t = [#64] }
      module ObjectLiteral : { type t = [#128] }
      module EvolvingArray : { type t = [#256] }
      module ObjectLiteralPatternWithComputedProperties : { type t = [#512] }
      module ReverseMapped : { type t = [#1024] }
      module JsxAttributes : { type t = [#2048] }
      module MarkerType : { type t = [#4096] }
      module JSLiteral : { type t = [#8192] }
      module FreshLiteral : { type t = [#16384] }
      module ArrayLiteral : { type t = [#32768] }
      module ClassOrInterface : { type t = [#3] }
      module ContainsSpread : { type t = [#4194304] }
      module ObjectRestType : { type t = [#8388608] }
    }
    module NumberLiteralType : { type t = intf'<[#Ts_LiteralType | #Ts_NumberLiteralType | #Ts_Type]> }
    module NotEmittedStatement : {
      type t = intf'<[#Ts_JSDocContainer | #Ts_Node | #Ts_NotEmittedStatement | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module NodesVisitor : { type t = intf'<[#Ts_NodesVisitor]> }
    module NodeVisitor : { type t = intf'<[#Ts_NodeVisitor]> }
    module NodeFlags : {
      type t = [#0 | #1 | #2 | #4 | #8 | #16 | #32 | #64 | #128 | #256 | #512 | #1024 | #2048 | #4096 | #8192 | #16384 | #32768 | #65536 | #131072 | #262144 | #524288 | #4194304 | #33554432 | #3 | #768 | #2816 | #25358336 | #40960]
      module None : { type t = [#0] }
      module Let : { type t = [#1] }
      module Const : { type t = [#2] }
      module NestedNamespace : { type t = [#4] }
      module Synthesized : { type t = [#8] }
      module Namespace : { type t = [#16] }
      module OptionalChain : { type t = [#32] }
      module ExportContext : { type t = [#64] }
      module ContainsThis : { type t = [#128] }
      module HasImplicitReturn : { type t = [#256] }
      module HasExplicitReturn : { type t = [#512] }
      module GlobalAugmentation : { type t = [#1024] }
      module HasAsyncFunctions : { type t = [#2048] }
      module DisallowInContext : { type t = [#4096] }
      module YieldContext : { type t = [#8192] }
      module DecoratorContext : { type t = [#16384] }
      module AwaitContext : { type t = [#32768] }
      module ThisNodeHasError : { type t = [#65536] }
      module JavaScriptFile : { type t = [#131072] }
      module ThisNodeOrAnySubNodesHasError : { type t = [#262144] }
      module HasAggregatedChildData : { type t = [#524288] }
      module JSDoc : { type t = [#4194304] }
      module JsonFile : { type t = [#33554432] }
      module BlockScoped : { type t = [#3] }
      module ReachabilityCheckFlags : { type t = [#768] }
      module ReachabilityAndEmitFlags : { type t = [#2816] }
      module ContextFlags : { type t = [#25358336] }
      module TypeExcludesFlags : { type t = [#40960] }
    }
    module NodeFactory : {
      module AnonymousInterface14 : { type t = private any }
      type t = intf'<[#Ts_NodeFactory]>
    }
    module NodeBuilderFlags : {
      type t = [#0 | #1 | #2 | #4 | #8 | #16 | #32 | #64 | #128 | #256 | #512 | #1024 | #2048 | #4096 | #8192 | #16384 | #268435456 | #536870912 | #1073741824 | #32768 | #65536 | #131072 | #262144 | #524288 | #1048576 | #2097152 | #67108864 | #70221824 | #4194304 | #8388608 | #16777216]
      module None : { type t = [#0] }
      module NoTruncation : { type t = [#1] }
      module WriteArrayAsGenericType : { type t = [#2] }
      module GenerateNamesForShadowedTypeParams : { type t = [#4] }
      module UseStructuralFallback : { type t = [#8] }
      module ForbidIndexedAccessSymbolReferences : { type t = [#16] }
      module WriteTypeArgumentsOfSignature : { type t = [#32] }
      module UseFullyQualifiedType : { type t = [#64] }
      module UseOnlyExternalAliasing : { type t = [#128] }
      module SuppressAnyReturnType : { type t = [#256] }
      module WriteTypeParametersInQualifiedName : { type t = [#512] }
      module MultilineObjectLiterals : { type t = [#1024] }
      module WriteClassExpressionAsTypeLiteral : { type t = [#2048] }
      module UseTypeOfFunction : { type t = [#4096] }
      module OmitParameterModifiers : { type t = [#8192] }
      module UseAliasDefinedOutsideCurrentScope : { type t = [#16384] }
      module UseSingleQuotesForStringLiteralType : { type t = [#268435456] }
      module NoTypeReduction : { type t = [#536870912] }
      module NoUndefinedOptionalParameterType : { type t = [#1073741824] }
      module AllowThisInObjectLiteral : { type t = [#32768] }
      module AllowQualifiedNameInPlaceOfIdentifier : { type t = [#65536] }
      module AllowQualifedNameInPlaceOfIdentifier : { type t = [#65536] }
      module AllowAnonymousIdentifier : { type t = [#131072] }
      module AllowEmptyUnionOrIntersection : { type t = [#262144] }
      module AllowEmptyTuple : { type t = [#524288] }
      module AllowUniqueESSymbolType : { type t = [#1048576] }
      module AllowEmptyIndexInfoType : { type t = [#2097152] }
      module AllowNodeModulesRelativePaths : { type t = [#67108864] }
      module IgnoreErrors : { type t = [#70221824] }
      module InObjectTypeLiteral : { type t = [#4194304] }
      module InTypeAlias : { type t = [#8388608] }
      module InInitialEntityName : { type t = [#16777216] }
    }
    module NewLineKind : {
      type t = CarriageReturnLineFeed | LineFeed
      module CarriageReturnLineFeed : { type t = private t }
      module LineFeed : { type t = private t }
    }
    module NavigationTree : { type t = intf'<[#Ts_NavigationTree]> }
    module NavigationBarItem : { type t = intf'<[#Ts_NavigationBarItem]> }
    module NavigateToItem : { type t = intf'<[#Ts_NavigateToItem]> }
    module NamedImportsOrExports : { type t = Union.t2<NamedImports.t, NamedExports.t> }
    module NamedImportBindings : { type t = Union.t2<NamespaceImport.t, NamedImports.t> }
    module NamespaceExport : {
      type t = intf'<[#Ts_Declaration | #Ts_NamedDeclaration | #Ts_NamespaceExport | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module NamedExportBindings : { type t = Union.t2<NamespaceExport.t, NamedExports.t> }
    module ModuleResolutionKind : {
      type t = [#1 | #2 | #3 | #99]
      module Classic : { type t = [#1] }
      module NodeJs : { type t = [#2] }
      module Node12 : { type t = [#3] }
      module NodeNext : { type t = [#99] }
    }
    module ResolvedModuleWithFailedLookupLocations : { type t = intf'<[#Ts_ResolvedModuleWithFailedLookupLocations]> }
    module NonRelativeModuleNameResolutionCache : {
      type t = intf'<[#Ts_NonRelativeModuleNameResolutionCache | #Ts_PackageJsonInfoCache]>
    }
    module ModuleResolutionCache : {
      type t = intf'<[#Ts_PerDirectoryResolutionCache(ResolvedModuleWithFailedLookupLocations.t) | #Ts_ModuleResolutionCache | #Ts_NonRelativeModuleNameResolutionCache | #Ts_PackageJsonInfoCache]>
    }
    module ExternalModuleReference : {
      type t = intf'<[#Ts_ExternalModuleReference | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module QualifiedName : { type t = intf'<[#Ts_Node | #Ts_QualifiedName | #Ts_ReadonlyTextRange]> }
    module EntityName : { type t = Union.t2<Identifier.t, QualifiedName.t> }
    module ModuleReference : { type t = Union.t2<EntityName.t, ExternalModuleReference.t> }
    module ModuleName : { type t = Union.t2<Identifier.t, StringLiteral.t> }
    module ModuleKind : {
      type t = [#0 | #1 | #2 | #3 | #4 | #5 | #6 | #7 | #99 | #100 | #199]
      module None : { type t = [#0] }
      module CommonJS : { type t = [#1] }
      module AMD : { type t = [#2] }
      module UMD : { type t = [#3] }
      module System : { type t = [#4] }
      module ES2015 : { type t = [#5] }
      module ES2020 : { type t = [#6] }
      module ES2022 : { type t = [#7] }
      module ESNext : { type t = [#99] }
      module Node12 : { type t = [#100] }
      module NodeNext : { type t = [#199] }
    }
    module ModuleDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_ModuleDeclaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module NamespaceDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_ModuleDeclaration | #Ts_NamedDeclaration | #Ts_NamespaceDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module ModuleBlock : {
      type t = intf'<[#Ts_JSDocContainer | #Ts_ModuleBlock | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module NamespaceBody : { type t = Union.t2<ModuleBlock.t, NamespaceDeclaration.t> }
    module JSDocNamespaceDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_JSDocNamespaceDeclaration | #Ts_ModuleDeclaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module JSDocNamespaceBody : { type t = Union.t2<Identifier.t, JSDocNamespaceDeclaration.t> }
    module ModuleBody : { type t = Union.t2<NamespaceBody.t, JSDocNamespaceBody.t> }
    module NodeArray : {
      type t<'T> = intf'<[#ReadonlyArray('T) | #Ts_NodeArray('T) | #Ts_ReadonlyTextRange]>
    }
    module OverrideKeyword : { type t = ModifierToken.t<SyntaxKind.OverrideKeyword.t> }
    module ExportKeyword : { type t = ModifierToken.t<SyntaxKind.ExportKeyword.t> }
    module DefaultKeyword : { type t = ModifierToken.t<SyntaxKind.DefaultKeyword.t> }
    module DeclareKeyword : { type t = ModifierToken.t<SyntaxKind.DeclareKeyword.t> }
    module ConstKeyword : { type t = ModifierToken.t<SyntaxKind.ConstKeyword.t> }
    module StaticKeyword : { type t = ModifierToken.t<SyntaxKind.StaticKeyword.t> }
    module AsyncKeyword : { type t = ModifierToken.t<SyntaxKind.AsyncKeyword.t> }
    module AbstractKeyword : { type t = ModifierToken.t<SyntaxKind.AbstractKeyword.t> }
    module Modifier : {
      type t = Union.t8<AbstractKeyword.t, AsyncKeyword.t, ConstKeyword.t, DeclareKeyword.t, DefaultKeyword.t, ExportKeyword.t, PrivateKeyword.t, Union.t5<ProtectedKeyword.t, PublicKeyword.t, OverrideKeyword.t, ReadonlyKeyword.t, StaticKeyword.t>>
    }
    module ModifiersArray : { type t = NodeArray.t<Modifier.t> }
    module ModifierSyntaxKind : {
      type t = Union.t8<SyntaxKind.AbstractKeyword.t, SyntaxKind.AsyncKeyword.t, SyntaxKind.ConstKeyword.t, SyntaxKind.DeclareKeyword.t, SyntaxKind.DefaultKeyword.t, SyntaxKind.ExportKeyword.t, SyntaxKind.PrivateKeyword.t, Union.t5<SyntaxKind.ProtectedKeyword.t, SyntaxKind.PublicKeyword.t, SyntaxKind.ReadonlyKeyword.t, SyntaxKind.OverrideKeyword.t, SyntaxKind.StaticKeyword.t>>
    }
    module ModifierFlags : {
      type t = [#0 | #1 | #2 | #4 | #8 | #16 | #32 | #64 | #128 | #256 | #512 | #2048 | #4096 | #8192 | #16384 | #536870912 | #28 | #16476 | #24 | #18654 | #513 | #27647]
      module None : { type t = [#0] }
      module Export_ : { type t = [#1] }
      module Ambient : { type t = [#2] }
      module Public : { type t = [#4] }
      module Private : { type t = [#8] }
      module Protected : { type t = [#16] }
      module Static : { type t = [#32] }
      module Readonly : { type t = [#64] }
      module Abstract : { type t = [#128] }
      module Async : { type t = [#256] }
      module Default_ : { type t = [#512] }
      module Const : { type t = [#2048] }
      module HasComputedJSDocModifiers : { type t = [#4096] }
      module Deprecated : { type t = [#8192] }
      module Override : { type t = [#16384] }
      module HasComputedFlags : { type t = [#536870912] }
      module AccessibilityModifier : { type t = [#28] }
      module ParameterPropertyModifier : { type t = [#16476] }
      module NonPublicAccessibilityModifier : { type t = [#24] }
      module TypeScriptModifier : { type t = [#18654] }
      module ExportDefault : { type t = [#513] }
      module All : { type t = [#27647] }
    }
    module ModeAwareCache : { type t<'T> = intf'<[#Ts_ModeAwareCache('T)]> }
    module MissingDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_MissingDeclaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module MinusToken : { type t = PunctuationToken.t<SyntaxKind.MinusToken.t> }
    module MetaProperty : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_MetaProperty | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module MemberName : { type t = Union.t2<Identifier.t, PrivateIdentifier.t> }
    module Map : {
      type t<'T> = intf'<[#Ts_Collection(string) | #Ts_Map('T) | #Ts_ReadonlyCollection(string) | #Ts_ESMap(string, 'T) | #Ts_ReadonlyESMap(string, 'T)]>
    }
    module LogicalOrCoalescingAssignmentOperator : {
      type t = Union.t3<SyntaxKind.AmpersandAmpersandEqualsToken.t, SyntaxKind.BarBarEqualsToken.t, SyntaxKind.QuestionQuestionEqualsToken.t>
    }
    module LiteralTypeNode : {
      type t = intf'<[#Ts_LiteralTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module RegularExpressionLiteral : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_LiteralExpression | #Ts_LiteralLikeNode | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_RegularExpressionLiteral | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module JsxText : {
      type t = intf'<[#Ts_JsxText | #Ts_LiteralLikeNode | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module BigIntLiteral : {
      type t = intf'<[#Ts_BigIntLiteral | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_LiteralExpression | #Ts_LiteralLikeNode | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module LiteralToken : {
      type t = Union.t6<NumericLiteral.t, BigIntLiteral.t, StringLiteral.t, JsxText.t, RegularExpressionLiteral.t, NoSubstitutionTemplateLiteral.t>
    }
    module ListFormat : {
      type t = [#0 | #1 | #2 | #3 | #4 | #8 | #16 | #32 | #60 | #64 | #128 | #256 | #512 | #1024 | #2048 | #4096 | #8192 | #15360 | #16384 | #32768 | #49152 | #65536 | #131072 | #262144 | #524288 | #1048576 | #2097152 | #262656 | #768 | #32897 | #528 | #657 | #516 | #520 | #525136 | #524880 | #526226 | #8914 | #2576 | #18960 | #129 | #145 | #163969 | #131073 | #2146305 | #53776 | #8848 | #33]
      module None : { type t = [#0] }
      module SingleLine : { type t = [#0] }
      module MultiLine : { type t = [#1] }
      module PreserveLines : { type t = [#2] }
      module LinesMask : { type t = [#3] }
      module NotDelimited : { type t = [#0] }
      module BarDelimited : { type t = [#4] }
      module AmpersandDelimited : { type t = [#8] }
      module CommaDelimited : { type t = [#16] }
      module AsteriskDelimited : { type t = [#32] }
      module DelimitersMask : { type t = [#60] }
      module AllowTrailingComma : { type t = [#64] }
      module Indented : { type t = [#128] }
      module SpaceBetweenBraces : { type t = [#256] }
      module SpaceBetweenSiblings : { type t = [#512] }
      module Braces : { type t = [#1024] }
      module Parenthesis : { type t = [#2048] }
      module AngleBrackets : { type t = [#4096] }
      module SquareBrackets : { type t = [#8192] }
      module BracketsMask : { type t = [#15360] }
      module OptionalIfUndefined : { type t = [#16384] }
      module OptionalIfEmpty : { type t = [#32768] }
      module Optional : { type t = [#49152] }
      module PreferNewLine : { type t = [#65536] }
      module NoTrailingNewLine : { type t = [#131072] }
      module NoInterveningComments : { type t = [#262144] }
      module NoSpaceIfEmpty : { type t = [#524288] }
      module SingleElement : { type t = [#1048576] }
      module SpaceAfterList : { type t = [#2097152] }
      module Modifiers : { type t = [#262656] }
      module HeritageClauses : { type t = [#512] }
      module SingleLineTypeLiteralMembers : { type t = [#768] }
      module MultiLineTypeLiteralMembers : { type t = [#32897] }
      module SingleLineTupleTypeElements : { type t = [#528] }
      module MultiLineTupleTypeElements : { type t = [#657] }
      module UnionTypeConstituents : { type t = [#516] }
      module IntersectionTypeConstituents : { type t = [#520] }
      module ObjectBindingPatternElements : { type t = [#525136] }
      module ArrayBindingPatternElements : { type t = [#524880] }
      module ObjectLiteralExpressionProperties : { type t = [#526226] }
      module ImportClauseEntries : { type t = [#526226] }
      module ArrayLiteralExpressionElements : { type t = [#8914] }
      module CommaListElements : { type t = [#528] }
      module CallExpressionArguments : { type t = [#2576] }
      module NewExpressionArguments : { type t = [#18960] }
      module TemplateExpressionSpans : { type t = [#262144] }
      module SingleLineBlockStatements : { type t = [#768] }
      module MultiLineBlockStatements : { type t = [#129] }
      module VariableDeclarationList : { type t = [#528] }
      module SingleLineFunctionBodyStatements : { type t = [#768] }
      module MultiLineFunctionBodyStatements : { type t = [#1] }
      module ClassHeritageClauses : { type t = [#0] }
      module ClassMembers : { type t = [#129] }
      module InterfaceMembers : { type t = [#129] }
      module EnumMembers : { type t = [#145] }
      module CaseBlockClauses : { type t = [#129] }
      module NamedImportsOrExportsElements : { type t = [#525136] }
      module JsxElementOrFragmentChildren : { type t = [#262144] }
      module JsxElementAttributes : { type t = [#262656] }
      module CaseOrDefaultClauseStatements : { type t = [#163969] }
      module HeritageClauseTypes : { type t = [#528] }
      module SourceFileStatements : { type t = [#131073] }
      module Decorators : { type t = [#2146305] }
      module TypeArguments : { type t = [#53776] }
      module TypeParameters : { type t = [#53776] }
      module Parameters : { type t = [#2576] }
      module IndexSignatureParameters : { type t = [#8848] }
      module JSDocComment : { type t = [#33] }
    }
    module LineAndCharacter : { type t = intf'<[#Ts_LineAndCharacter]> }
    module LanguageVariant : {
      type t = Standard | JSX
      module Standard : { type t = private t }
      module JSX : { type t = private t }
    }
    module LanguageServiceMode : {
      type t = Semantic | PartialSemantic | Syntactic
      module Semantic : { type t = private t }
      module PartialSemantic : { type t = private t }
      module Syntactic : { type t = private t }
    }
    module GetEffectiveTypeRootsHost : { type t = intf'<[#Ts_GetEffectiveTypeRootsHost]> }
    module LanguageServiceHost : { type t = intf'<[#Ts_GetEffectiveTypeRootsHost | #Ts_LanguageServiceHost]> }
    module LanguageService : { type t = intf'<[#Ts_LanguageService]> }
    module KeywordTypeSyntaxKind : {
      type t = Union.t8<SyntaxKind.AnyKeyword.t, SyntaxKind.BigIntKeyword.t, SyntaxKind.BooleanKeyword.t, SyntaxKind.IntrinsicKeyword.t, SyntaxKind.NeverKeyword.t, SyntaxKind.NumberKeyword.t, SyntaxKind.ObjectKeyword.t, Union.t5<SyntaxKind.StringKeyword.t, SyntaxKind.SymbolKeyword.t, SyntaxKind.UndefinedKeyword.t, SyntaxKind.UnknownKeyword.t, SyntaxKind.VoidKeyword.t>>
    }
    module KeywordTypeNode : {
      type t<'TKind> = intf'<[#Ts_KeywordToken('TKind) | #Ts_KeywordTypeNode('TKind) | #Ts_Token('TKind) | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module JsxTokenSyntaxKind : {
      type t = Union.t7<SyntaxKind.LessThanSlashToken.t, SyntaxKind.EndOfFileToken.t, SyntaxKind.ConflictMarkerTrivia.t, SyntaxKind.JsxText.t, SyntaxKind.JsxTextAllWhiteSpaces.t, SyntaxKind.OpenBraceToken.t, SyntaxKind.LessThanToken.t>
    }
    module ThisExpression : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_ThisExpression | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module JsxTagNamePropertyAccess : {
      type t = intf'<[#Ts_Declaration | #Ts_Expression | #Ts_JsxTagNamePropertyAccess | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyAccessExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module JsxTagNameExpression : { type t = Union.t3<Identifier.t, ThisExpression.t, JsxTagNamePropertyAccess.t> }
    module JsxOpeningFragment : {
      type t = intf'<[#Ts_Expression | #Ts_JsxOpeningFragment | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JsxFlags : {
      type t = None | IntrinsicNamedElement | IntrinsicIndexedElement | IntrinsicElement
      module None : { type t = private t }
      module IntrinsicNamedElement : { type t = private t }
      module IntrinsicIndexedElement : { type t = private t }
      module IntrinsicElement : { type t = private t }
    }
    module JsxEmit : {
      type t = None | Preserve | React | ReactNative | ReactJSX | ReactJSXDev
      module None : { type t = private t }
      module Preserve : { type t = private t }
      module React : { type t = private t }
      module ReactNative : { type t = private t }
      module ReactJSX : { type t = private t }
      module ReactJSXDev : { type t = private t }
    }
    module JsxClosingTagInfo : { type t = intf'<[#Ts_JsxClosingTagInfo]> }
    module JsxClosingFragment : {
      type t = intf'<[#Ts_Expression | #Ts_JsxClosingFragment | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JsxClosingElement : { type t = intf'<[#Ts_JsxClosingElement | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module JsxFragment : {
      type t = intf'<[#Ts_Expression | #Ts_JsxFragment | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module JsxExpression : {
      type t = intf'<[#Ts_Expression | #Ts_JsxExpression | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JsxElement : {
      type t = intf'<[#Ts_Expression | #Ts_JsxElement | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module JsxSelfClosingElement : {
      type t = intf'<[#Ts_Expression | #Ts_JsxSelfClosingElement | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module JsxChild : {
      type t = Union.t5<JsxText.t, JsxExpression.t, JsxElement.t, JsxSelfClosingElement.t, JsxFragment.t>
    }
    module JsxSpreadAttribute : {
      type t = intf'<[#Ts_Declaration | #Ts_JsxSpreadAttribute | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange]>
    }
    module JsxAttributeLike : { type t = Union.t2<JsxAttribute.t, JsxSpreadAttribute.t> }
    module ObjectLiteralExpressionBase : {
      type t<'T> = intf'<[#Ts_ObjectLiteralExpressionBase('T) | #Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module JsxAttributes : {
      type t = intf'<[#Ts_ObjectLiteralExpressionBase(JsxAttributeLike.t) | #Ts_Declaration | #Ts_Expression | #Ts_JsxAttributes | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module ExpressionStatement : {
      type t = intf'<[#Ts_ExpressionStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module JsonObjectExpressionStatement : {
      type t = intf'<[#Ts_ExpressionStatement | #Ts_JSDocContainer | #Ts_JsonObjectExpressionStatement | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module NullLiteral : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_NullLiteral | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module PrefixUnaryExpression : {
      type t = intf'<[#Ts_Expression | #Ts_Node | #Ts_PrefixUnaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module JsonMinusNumericLiteral : {
      type t = intf'<[#Ts_Expression | #Ts_JsonMinusNumericLiteral | #Ts_Node | #Ts_PrefixUnaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module TrueLiteral : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_TrueLiteral | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module FalseLiteral : {
      type t = intf'<[#Ts_Expression | #Ts_FalseLiteral | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module BooleanLiteral : { type t = Union.t2<TrueLiteral.t, FalseLiteral.t> }
    module SpreadAssignment : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange | #Ts_SpreadAssignment]>
    }
    module MethodDeclaration : {
      type t = intf'<[#Ts_ClassElement | #Ts_Declaration | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_MethodDeclaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase]>
    }
    module SetAccessorDeclaration : {
      type t = intf'<[#Ts_ClassElement | #Ts_Declaration | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange | #Ts_SetAccessorDeclaration | #Ts_SignatureDeclarationBase | #Ts_TypeElement]>
    }
    module GetAccessorDeclaration : {
      type t = intf'<[#Ts_ClassElement | #Ts_Declaration | #Ts_FunctionLikeDeclarationBase | #Ts_GetAccessorDeclaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeElement]>
    }
    module AccessorDeclaration : { type t = Union.t2<GetAccessorDeclaration.t, SetAccessorDeclaration.t> }
    module ObjectLiteralElementLike : {
      type t = Union.t5<PropertyAssignment.t, ShorthandPropertyAssignment.t, SpreadAssignment.t, MethodDeclaration.t, AccessorDeclaration.t>
    }
    module ObjectLiteralExpression : {
      type t = intf'<[#Ts_ObjectLiteralExpressionBase(ObjectLiteralElementLike.t) | #Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ObjectLiteralExpression | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module ArrayLiteralExpression : {
      type t = intf'<[#Ts_ArrayLiteralExpression | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module JsonObjectExpression : {
      type t = Union.t7<ObjectLiteralExpression.t, ArrayLiteralExpression.t, JsonMinusNumericLiteral.t, NumericLiteral.t, StringLiteral.t, BooleanLiteral.t, NullLiteral.t>
    }
    module FileExtensionInfo : { type t = intf'<[#Ts_FileExtensionInfo]> }
    module JsFileExtensionInfo : { type t = FileExtensionInfo.t }
    module JSDocType : {
      type t = intf'<[#Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module JSDocUnknownType : {
      type t = intf'<[#Ts_JSDocType | #Ts_JSDocUnknownType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module JSDocUnknownTag : {
      type t = intf'<[#Ts_JSDocTag | #Ts_JSDocUnknownTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocTypeTag : {
      type t = intf'<[#Ts_JSDocTag | #Ts_JSDocTypeTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocVariadicType : {
      type t = intf'<[#Ts_JSDocType | #Ts_JSDocVariadicType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module JSDocOptionalType : {
      type t = intf'<[#Ts_JSDocOptionalType | #Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module JSDocNullableType : {
      type t = intf'<[#Ts_JSDocNullableType | #Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module JSDocNonNullableType : {
      type t = intf'<[#Ts_JSDocNonNullableType | #Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module JSDocTypeReferencingNode : {
      type t = Union.t4<JSDocVariadicType.t, JSDocOptionalType.t, JSDocNullableType.t, JSDocNonNullableType.t>
    }
    module JSDocTypeLiteral : {
      type t = intf'<[#Ts_JSDocType | #Ts_JSDocTypeLiteral | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module JSDocThisTag : {
      type t = intf'<[#Ts_JSDocTag | #Ts_JSDocThisTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocTagInfo : { type t = intf'<[#Ts_JSDocTagInfo]> }
    module JSDocSyntaxKind : {
      type t = Union.t8<SyntaxKind.EndOfFileToken.t, SyntaxKind.WhitespaceTrivia.t, SyntaxKind.AtToken.t, SyntaxKind.NewLineTrivia.t, SyntaxKind.AsteriskToken.t, SyntaxKind.OpenBraceToken.t, SyntaxKind.CloseBraceToken.t, Union.t8<SyntaxKind.LessThanToken.t, SyntaxKind.GreaterThanToken.t, SyntaxKind.OpenBracketToken.t, SyntaxKind.CloseBracketToken.t, SyntaxKind.EqualsToken.t, SyntaxKind.CommaToken.t, SyntaxKind.DotToken.t, Union.t5<SyntaxKind.Identifier.t, SyntaxKind.BacktickToken.t, SyntaxKind.HashToken.t, SyntaxKind.Unknown.t, KeywordSyntaxKind.t>>>
    }
    module JSDocSeeTag : {
      type t = intf'<[#Ts_JSDocSeeTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocReturnTag : {
      type t = intf'<[#Ts_JSDocReturnTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocReadonlyTag : {
      type t = intf'<[#Ts_JSDocReadonlyTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocPublicTag : {
      type t = intf'<[#Ts_JSDocPublicTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocProtectedTag : {
      type t = intf'<[#Ts_JSDocProtectedTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocPrivateTag : {
      type t = intf'<[#Ts_JSDocPrivateTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocOverrideTag : {
      type t = intf'<[#Ts_JSDocOverrideTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocNamepathType : {
      type t = intf'<[#Ts_JSDocNamepathType | #Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module JSDocNameReference : { type t = intf'<[#Ts_JSDocNameReference | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module JSDocMemberName : { type t = intf'<[#Ts_JSDocMemberName | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module SymbolDisplayPart : { type t = intf'<[#Ts_SymbolDisplayPart]> }
    module JSDocLinkDisplayPart : { type t = intf'<[#Ts_JSDocLinkDisplayPart | #Ts_SymbolDisplayPart]> }
    module JSDocImplementsTag : {
      module AnonymousInterface14 : { type t = private any }
      type t = intf'<[#Ts_JSDocImplementsTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocEnumTag : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocEnumTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocDeprecatedTag : {
      type t = intf'<[#Ts_JSDocDeprecatedTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocText : { type t = intf'<[#Ts_JSDocText | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module JSDocLinkPlain : { type t = intf'<[#Ts_JSDocLinkPlain | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module JSDocLinkCode : { type t = intf'<[#Ts_JSDocLinkCode | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module JSDocLink : { type t = intf'<[#Ts_JSDocLink | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module JSDocComment : { type t = Union.t4<JSDocText.t, JSDocLink.t, JSDocLinkCode.t, JSDocLinkPlain.t> }
    module JSDocClassTag : {
      type t = intf'<[#Ts_JSDocClassTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocAuthorTag : {
      type t = intf'<[#Ts_JSDocAuthorTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocAugmentsTag : {
      module AnonymousInterface14 : { type t = private any }
      type t = intf'<[#Ts_JSDocAugmentsTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocAllType : {
      type t = intf'<[#Ts_JSDocAllType | #Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module JSDoc : { type t = intf'<[#Ts_JSDoc | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module Iterator : {
      module rec AnonymousInterface31 : { type t = private any }
      and AnonymousInterface55 : { type t<'T> = private any }
      type t<'T> = intf'<[#Ts_Iterator('T)]>
    }
    module InvalidatedProjectKind : {
      type t = Build | UpdateBundle | UpdateOutputFileStamps
      module Build : { type t = private t }
      module UpdateBundle : { type t = private t }
      module UpdateOutputFileStamps : { type t = private t }
    }
    module InvalidatedProjectBase : { type t = intf'<[#Ts_InvalidatedProjectBase]> }
    module UpdateOutputFileStampsProject : {
      type t = intf'<[#Ts_InvalidatedProjectBase | #Ts_UpdateOutputFileStampsProject]>
    }
    module UpdateBundleProject : { type t<'T> = intf'<[#Ts_UpdateBundleProject('T) | #Ts_InvalidatedProjectBase]> }
    module BuildInvalidedProject : {
      type t<'T> = intf'<[#Ts_BuildInvalidedProject('T) | #Ts_InvalidatedProjectBase]>
    }
    module InvalidatedProject : {
      type t<'T> = Union.t3<UpdateOutputFileStampsProject.t, BuildInvalidedProject.t<'T>, UpdateBundleProject.t<'T>>
    }
    module InterfaceTypeWithDeclaredMembers : {
      type t = intf'<[#Ts_InterfaceType | #Ts_InterfaceTypeWithDeclaredMembers | #Ts_ObjectType | #Ts_Type]>
    }
    module InstallPackageOptions : { type t = intf'<[#Ts_InstallPackageOptions]> }
    module InputFiles : { type t = intf'<[#Ts_InputFiles | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module UserPreferences : { type t = intf'<[#Ts_UserPreferences]> }
    module InlayHintsOptions : { type t = intf'<[#Ts_InlayHintsOptions | #Ts_UserPreferences]> }
    module InlayHintsContext : { type t = intf'<[#Ts_InlayHintsContext]> }
    module InlayHintKind : {
      type t = [#Type | #Parameter | #Enum]
      module Type : { type t = [#Type] }
      module Parameter : { type t = [#Parameter] }
      module Enum : { type t = [#Enum] }
    }
    module InlayHint : { type t = intf'<[#Ts_InlayHint]> }
    module InferencePriority : {
      type t = private float
      module NakedTypeVariable : { type t = private t }
      module SpeculativeTuple : { type t = private t }
      module SubstituteSource : { type t = private t }
      module HomomorphicMappedType : { type t = private t }
      module PartialHomomorphicMappedType : { type t = private t }
      module MappedTypeConstraint : { type t = private t }
      module ContravariantConditional : { type t = private t }
      module ReturnType : { type t = private t }
      module LiteralKeyof : { type t = private t }
      module NoConstraints : { type t = private t }
      module AlwaysStrict : { type t = private t }
      module MaxValue : { type t = private t }
      module PriorityImpliesCombination : { type t = private t }
      module Circularity : { type t = private t }
    }
    module InferTypeNode : {
      type t = intf'<[#Ts_InferTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module IndexedAccessTypeNode : {
      type t = intf'<[#Ts_IndexedAccessTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module IndexType : { type t = intf'<[#Ts_IndexType | #Ts_InstantiableType | #Ts_Type]> }
    module IndexKind : {
      type t = String | Number
      module String : { type t = private t }
      module Number : { type t = private t }
    }
    module IndexInfo : { type t = intf'<[#Ts_IndexInfo]> }
    module IndentStyle : {
      type t = None | Block | Smart
      module None : { type t = private t }
      module Block : { type t = private t }
      module Smart : { type t = private t }
    }
    module IncrementalProgramOptions : { type t<'T> = intf'<[#Ts_IncrementalProgramOptions('T)]> }
    module IncrementExpression : { type t = UpdateExpression.t }
    module IncompleteCompletionsCache : { type t = intf'<[#Ts_IncompleteCompletionsCache]> }
    module ImportsNotUsedAsValues : {
      type t = Remove | Preserve | Error
      module Remove : { type t = private t }
      module Preserve : { type t = private t }
      module Error : { type t = private t }
    }
    module ImportTypeNode : {
      type t = intf'<[#Ts_ImportTypeNode | #Ts_Node | #Ts_NodeWithTypeArguments | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module ImportExpression : {
      type t = intf'<[#Ts_Expression | #Ts_ImportExpression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module ImportCall : {
      type t = intf'<[#Ts_CallExpression | #Ts_Declaration | #Ts_Expression | #Ts_ImportCall | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module ImplementationLocation : { type t = intf'<[#Ts_DocumentSpan | #Ts_ImplementationLocation]> }
    module IScriptSnapshot : { type t = intf'<[#Ts_IScriptSnapshot]> }
    module HostCancellationToken : { type t = intf'<[#Ts_HostCancellationToken]> }
    module HighlightSpanKind : {
      type t = [#none | #definition | #reference | #writtenReference]
      module None : { type t = [#none] }
      module Definition : { type t = [#definition] }
      module Reference : { type t = [#reference] }
      module WrittenReference : { type t = [#writtenReference] }
    }
    module HighlightSpan : { type t = intf'<[#Ts_HighlightSpan]> }
    module HeritageClause : { type t = intf'<[#Ts_HeritageClause | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module TaggedTemplateExpression : {
      type t = intf'<[#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TaggedTemplateExpression | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module NewExpression : {
      type t = intf'<[#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NewExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module JsxOpeningElement : {
      type t = intf'<[#Ts_Expression | #Ts_JsxOpeningElement | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module HasTypeArguments : {
      type t = Union.t5<CallExpression.t, NewExpression.t, TaggedTemplateExpression.t, JsxOpeningElement.t, JsxSelfClosingElement.t>
    }
    module TypePredicateNode : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode | #Ts_TypePredicateNode]>
    }
    module TypeOperatorNode : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode | #Ts_TypeOperatorNode]>
    }
    module ParenthesizedTypeNode : {
      type t = intf'<[#Ts_Node | #Ts_ParenthesizedTypeNode | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module MappedTypeNode : {
      type t = intf'<[#Ts_Declaration | #Ts_MappedTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module JSDocTypeExpression : {
      type t = intf'<[#Ts_JSDocTypeExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module TypeAliasDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement | #Ts_TypeAliasDeclaration]>
    }
    module MethodSignature : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocContainer | #Ts_MethodSignature | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeElement]>
    }
    module JSDocFunctionType : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocContainer | #Ts_JSDocFunctionType | #Ts_JSDocType | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeNode]>
    }
    module IndexSignatureDeclaration : {
      type t = intf'<[#Ts_ClassElement | #Ts_Declaration | #Ts_IndexSignatureDeclaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeElement]>
    }
    module FunctionOrConstructorTypeNodeBase : {
      type t = intf'<[#Ts_Declaration | #Ts_FunctionOrConstructorTypeNodeBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeNode]>
    }
    module FunctionTypeNode : {
      type t = intf'<[#Ts_Declaration | #Ts_FunctionOrConstructorTypeNodeBase | #Ts_FunctionTypeNode | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeNode]>
    }
    module FunctionExpression : {
      type t = intf'<[#Ts_Declaration | #Ts_Expression | #Ts_FunctionExpression | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module FunctionDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_FunctionDeclaration | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_Statement]>
    }
    module ConstructorTypeNode : {
      type t = intf'<[#Ts_ConstructorTypeNode | #Ts_Declaration | #Ts_FunctionOrConstructorTypeNodeBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeNode]>
    }
    module ConstructSignatureDeclaration : {
      type t = intf'<[#Ts_ConstructSignatureDeclaration | #Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeElement]>
    }
    module CallSignatureDeclaration : {
      type t = intf'<[#Ts_CallSignatureDeclaration | #Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeElement]>
    }
    module ArrowFunction : {
      type t = intf'<[#Ts_ArrowFunction | #Ts_Declaration | #Ts_Expression | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase]>
    }
    module SignatureDeclaration : {
      type t = Union.t8<CallSignatureDeclaration.t, ConstructSignatureDeclaration.t, MethodSignature.t, IndexSignatureDeclaration.t, FunctionTypeNode.t, ConstructorTypeNode.t, JSDocFunctionType.t, Union.t6<FunctionDeclaration.t, MethodDeclaration.t, ConstructorDeclaration.t, AccessorDeclaration.t, FunctionExpression.t, ArrowFunction.t>>
    }
    module TypeAssertion : {
      type t = intf'<[#Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeAssertion | #Ts_UnaryExpression]>
    }
    module AsExpression : {
      type t = intf'<[#Ts_AsExpression | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module AssertionExpression : { type t = Union.t2<TypeAssertion.t, AsExpression.t> }
    module HasType : {
      type t = Union.t8<SignatureDeclaration.t, VariableDeclaration.t, ParameterDeclaration.t, PropertySignature.t, PropertyDeclaration.t, TypePredicateNode.t, ParenthesizedTypeNode.t, Union.t8<TypeOperatorNode.t, MappedTypeNode.t, AssertionExpression.t, TypeAliasDeclaration.t, JSDocTypeExpression.t, JSDocNonNullableType.t, JSDocNullableType.t, Union.t2<JSDocOptionalType.t, JSDocVariadicType.t>>>
    }
    module WithStatement : {
      type t = intf'<[#Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement | #Ts_WithStatement]>
    }
    module IterationStatement : {
      type t = intf'<[#Ts_IterationStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module WhileStatement : {
      type t = intf'<[#Ts_IterationStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement | #Ts_WhileStatement]>
    }
    module VariableStatement : {
      type t = intf'<[#Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement | #Ts_VariableStatement]>
    }
    module TryStatement : {
      type t = intf'<[#Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement | #Ts_TryStatement]>
    }
    module ThrowStatement : {
      type t = intf'<[#Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement | #Ts_ThrowStatement]>
    }
    module SwitchStatement : {
      type t = intf'<[#Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement | #Ts_SwitchStatement]>
    }
    module ReturnStatement : {
      type t = intf'<[#Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_ReturnStatement | #Ts_Statement]>
    }
    module ParenthesizedExpression : {
      type t = intf'<[#Ts_Expression | #Ts_JSDocContainer | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ParenthesizedExpression | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module NamespaceExportDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_NamespaceExportDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module NamedTupleMember : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedTupleMember | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module LabeledStatement : {
      type t = intf'<[#Ts_JSDocContainer | #Ts_LabeledStatement | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module ImportDeclaration : {
      type t = intf'<[#Ts_ImportDeclaration | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module IfStatement : {
      type t = intf'<[#Ts_IfStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module ForStatement : {
      type t = intf'<[#Ts_ForStatement | #Ts_IterationStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module ForOfStatement : {
      type t = intf'<[#Ts_ForOfStatement | #Ts_IterationStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module ForInStatement : {
      type t = intf'<[#Ts_ForInStatement | #Ts_IterationStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module ExportAssignment : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_ExportAssignment | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module EnumDeclaration : {
      type t = intf'<[#Ts_Declaration | #Ts_DeclarationStatement | #Ts_EnumDeclaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module EndOfFileToken : {
      type t = Intersection.t2<Token.t<SyntaxKind.EndOfFileToken.t>, JSDocContainer.t>
    }
    module EmptyStatement : {
      type t = intf'<[#Ts_EmptyStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module DoStatement : {
      type t = intf'<[#Ts_DoStatement | #Ts_IterationStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module DebuggerStatement : {
      type t = intf'<[#Ts_DebuggerStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module ClassStaticBlockDeclaration : {
      type t = intf'<[#Ts_ClassElement | #Ts_ClassStaticBlockDeclaration | #Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module ContinueStatement : {
      type t = intf'<[#Ts_ContinueStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module BreakStatement : {
      type t = intf'<[#Ts_BreakStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module Block : {
      type t = intf'<[#Ts_Block | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]>
    }
    module HasJSDoc : {
      type t = Union.t8<ParameterDeclaration.t, CallSignatureDeclaration.t, ClassStaticBlockDeclaration.t, ConstructSignatureDeclaration.t, MethodSignature.t, PropertySignature.t, ArrowFunction.t, Union.t8<ParenthesizedExpression.t, SpreadAssignment.t, ShorthandPropertyAssignment.t, PropertyAssignment.t, FunctionExpression.t, EmptyStatement.t, DebuggerStatement.t, Union.t8<Block.t, VariableStatement.t, ExpressionStatement.t, IfStatement.t, DoStatement.t, WhileStatement.t, ForStatement.t, Union.t8<ForInStatement.t, ForOfStatement.t, BreakStatement.t, ContinueStatement.t, ReturnStatement.t, WithStatement.t, SwitchStatement.t, Union.t8<LabeledStatement.t, ThrowStatement.t, TryStatement.t, FunctionDeclaration.t, ConstructorDeclaration.t, MethodDeclaration.t, VariableDeclaration.t, Union.t8<PropertyDeclaration.t, AccessorDeclaration.t, ClassLikeDeclaration.t, InterfaceDeclaration.t, TypeAliasDeclaration.t, EnumMember.t, EnumDeclaration.t, Union.t8<ModuleDeclaration.t, ImportEqualsDeclaration.t, ImportDeclaration.t, NamespaceExportDeclaration.t, ExportAssignment.t, IndexSignatureDeclaration.t, FunctionTypeNode.t, Union.t6<ConstructorTypeNode.t, JSDocFunctionType.t, ExportDeclaration.t, NamedTupleMember.t, ExportSpecifier.t, EndOfFileToken.t>>>>>>>>
    }
    module HasExpressionInitializer : {
      type t = Union.t7<VariableDeclaration.t, ParameterDeclaration.t, BindingElement.t, PropertySignature.t, PropertyDeclaration.t, PropertyAssignment.t, EnumMember.t>
    }
    module HasInitializer : {
      type t = Union.t5<HasExpressionInitializer.t, ForStatement.t, ForInStatement.t, ForOfStatement.t, JsxAttribute.t>
    }
    module GetCompletionsAtPositionOptions : { type t = intf'<[#Ts_GetCompletionsAtPositionOptions | #Ts_UserPreferences]> }
    module GeneratedIdentifierFlags : {
      type t = [#0 | #8 | #16 | #32 | #64]
      module None : { type t = [#0] }
      module ReservedInNestedScopes : { type t = [#8] }
      module Optimistic : { type t = [#16] }
      module FileLevel : { type t = [#32] }
      module AllowNameSubstitution : { type t = [#64] }
    }
    module FunctionOrConstructorTypeNode : { type t = Union.t2<FunctionTypeNode.t, ConstructorTypeNode.t> }
    module FunctionLikeDeclaration : {
      type t = Union.t7<FunctionDeclaration.t, MethodDeclaration.t, GetAccessorDeclaration.t, SetAccessorDeclaration.t, ConstructorDeclaration.t, FunctionExpression.t, ArrowFunction.t>
    }
    module FunctionLike : { type t = SignatureDeclaration.t }
    module FormatDiagnosticsHost : { type t = intf'<[#Ts_FormatDiagnosticsHost]> }
    module EditorSettings : { type t = intf'<[#Ts_EditorSettings]> }
    module FormatCodeSettings : { type t = intf'<[#Ts_EditorSettings | #Ts_FormatCodeSettings]> }
    module EditorOptions : { type t = intf'<[#Ts_EditorOptions]> }
    module FormatCodeOptions : { type t = intf'<[#Ts_EditorOptions | #Ts_FormatCodeOptions]> }
    module VariableDeclarationList : {
      type t = intf'<[#Ts_Node | #Ts_ReadonlyTextRange | #Ts_VariableDeclarationList]>
    }
    module ForInitializer : { type t = Union.t2<VariableDeclarationList.t, Expression.t> }
    module ForInOrOfStatement : { type t = Union.t2<ForInStatement.t, ForOfStatement.t> }
    module IncompleteType : { type t = intf'<[#Ts_IncompleteType]> }
    module FlowType : { type t = Union.t2<Type.t, IncompleteType.t> }
    module FlowNodeBase : { type t = intf'<[#Ts_FlowNodeBase]> }
    module FlowSwitchClause : { type t = intf'<[#Ts_FlowNodeBase | #Ts_FlowSwitchClause]> }
    module FlowStart : { type t = intf'<[#Ts_FlowNodeBase | #Ts_FlowStart]> }
    module FlowReduceLabel : { type t = intf'<[#Ts_FlowNodeBase | #Ts_FlowReduceLabel]> }
    module FlowLabel : { type t = intf'<[#Ts_FlowLabel | #Ts_FlowNodeBase]> }
    module FlowCondition : { type t = intf'<[#Ts_FlowCondition | #Ts_FlowNodeBase]> }
    module FlowCall : { type t = intf'<[#Ts_FlowCall | #Ts_FlowNodeBase]> }
    module FlowAssignment : { type t = intf'<[#Ts_FlowAssignment | #Ts_FlowNodeBase]> }
    module FlowArrayMutation : { type t = intf'<[#Ts_FlowArrayMutation | #Ts_FlowNodeBase]> }
    module FlowNode : {
      type t = Union.t8<FlowStart.t, FlowLabel.t, FlowAssignment.t, FlowCall.t, FlowCondition.t, FlowSwitchClause.t, FlowArrayMutation.t, Union.t2<FlowCall.t, FlowReduceLabel.t>>
    }
    module FlowFlags : {
      type t = [#1 | #2 | #4 | #8 | #16 | #32 | #64 | #128 | #256 | #512 | #1024 | #2048 | #4096 | #12 | #96]
      module Unreachable : { type t = [#1] }
      module Start : { type t = [#2] }
      module BranchLabel : { type t = [#4] }
      module LoopLabel : { type t = [#8] }
      module Assignment : { type t = [#16] }
      module TrueCondition : { type t = [#32] }
      module FalseCondition : { type t = [#64] }
      module SwitchClause : { type t = [#128] }
      module ArrayMutation : { type t = [#256] }
      module Call : { type t = [#512] }
      module ReduceLabel : { type t = [#1024] }
      module Referenced : { type t = [#2048] }
      module Shared : { type t = [#4096] }
      module Label : { type t = [#12] }
      module Condition : { type t = [#96] }
    }
    module FileWatcherEventKind : {
      type t = Created | Changed | Deleted
      module Created : { type t = private t }
      module Changed : { type t = private t }
      module Deleted : { type t = private t }
    }
    module FileWatcherCallback : { type t = (~fileName:string, ~eventKind:FileWatcherEventKind.t) => unit }
    module FileWatcher : { type t = intf'<[#Ts_FileWatcher]> }
    module FileTextChanges : { type t = intf'<[#Ts_FileTextChanges]> }
    module FileReference : { type t = intf'<[#Ts_FileReference | #Ts_TextRange]> }
    module Extension : {
      type t = [#".ts" | #".tsx" | #".d.ts" | #".js" | #".jsx" | #".json" | #".tsbuildinfo" | #".mjs" | #".mts" | #".d.mts" | #".cjs" | #".cts" | #".d.cts"]
      module Ts : { type t = [#".ts"] }
      module Tsx : { type t = [#".tsx"] }
      module Dts : { type t = [#".d.ts"] }
      module Js : { type t = [#".js"] }
      module Jsx : { type t = [#".jsx"] }
      module Json : { type t = [#".json"] }
      module TsBuildInfo : { type t = [#".tsbuildinfo"] }
      module Mjs : { type t = [#".mjs"] }
      module Mts : { type t = [#".mts"] }
      module Dmts : { type t = [#".d.mts"] }
      module Cjs : { type t = [#".cjs"] }
      module Cts : { type t = [#".cts"] }
      module Dcts : { type t = [#".d.cts"] }
    }
    module ExtendedConfigCacheEntry : { type t = intf'<[#Ts_ExtendedConfigCacheEntry]> }
    module ExitStatus : {
      type t =   | Success
        | DiagnosticsPresent_OutputsSkipped
        | DiagnosticsPresent_OutputsGenerated
        | InvalidProject_OutputsSkipped
        | ProjectReferenceCycle_OutputsSkipped_ProjectReferenceCycle_OutputsSkupped
      module Success : { type t = private t }
      module DiagnosticsPresent_OutputsSkipped : { type t = private t }
      module DiagnosticsPresent_OutputsGenerated : { type t = private t }
      module InvalidProject_OutputsSkipped : { type t = private t }
      module ProjectReferenceCycle_OutputsSkipped : { type t = private t }
      module ProjectReferenceCycle_OutputsSkupped : { type t = private t }
    }
    module ExclamationToken : { type t = PunctuationToken.t<SyntaxKind.ExclamationToken.t> }
    module EvolvingArrayType : { type t = intf'<[#Ts_EvolvingArrayType | #Ts_ObjectType | #Ts_Type]> }
    module DiagnosticMessage : { type t = intf'<[#Ts_DiagnosticMessage]> }
    module ErrorCallback : { type t = (~message:DiagnosticMessage.t, ~length:float) => unit }
    module EqualsGreaterThanToken : { type t = PunctuationToken.t<SyntaxKind.EqualsGreaterThanToken.t> }
    module EnumType : { type t = intf'<[#Ts_EnumType | #Ts_Type]> }
    module PropertyAccessEntityNameExpression : {
      type t = intf'<[#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyAccessEntityNameExpression | #Ts_PropertyAccessExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]>
    }
    module EntityNameExpression : { type t = Union.t2<Identifier.t, PropertyAccessEntityNameExpression.t> }
    module EntityNameOrEntityNameExpression : { type t = Union.t2<EntityName.t, EntityNameExpression.t> }
    module EndOfLineState : {
      type t =   | None
        | InMultiLineCommentTrivia
        | InSingleQuoteStringLiteral
        | InDoubleQuoteStringLiteral
        | InTemplateHeadOrNoSubstitutionTemplate
        | InTemplateMiddleOrTail
        | InTemplateSubstitutionPosition
      module None : { type t = private t }
      module InMultiLineCommentTrivia : { type t = private t }
      module InSingleQuoteStringLiteral : { type t = private t }
      module InDoubleQuoteStringLiteral : { type t = private t }
      module InTemplateHeadOrNoSubstitutionTemplate : { type t = private t }
      module InTemplateMiddleOrTail : { type t = private t }
      module InTemplateSubstitutionPosition : { type t = private t }
    }
    module EmitResult : { type t = intf'<[#Ts_EmitResult]> }
    module EmitOutput : { type t = intf'<[#Ts_EmitOutput]> }
    module EmitHint : {
      type t =   | SourceFile
        | Expression
        | IdentifierName
        | MappedTypeParameter
        | Unspecified
        | EmbeddedStatement
        | JsxAttributeValue
      module SourceFile : { type t = private t }
      module Expression : { type t = private t }
      module IdentifierName : { type t = private t }
      module MappedTypeParameter : { type t = private t }
      module Unspecified : { type t = private t }
      module EmbeddedStatement : { type t = private t }
      module JsxAttributeValue : { type t = private t }
    }
    module EmitHelperUniqueNameCallback : { type t = string => string }
    module EmitHelperBase : { type t = intf'<[#Ts_EmitHelperBase]> }
    module UnscopedEmitHelper : { type t = intf'<[#Ts_EmitHelperBase | #Ts_UnscopedEmitHelper]> }
    module ScopedEmitHelper : { type t = intf'<[#Ts_EmitHelperBase | #Ts_ScopedEmitHelper]> }
    module EmitHelper : { type t = Union.t2<ScopedEmitHelper.t, UnscopedEmitHelper.t> }
    module EmitFlags : {
      type t = [#0 | #1 | #2 | #4 | #8 | #16 | #32 | #48 | #64 | #128 | #256 | #384 | #512 | #1024 | #1536 | #2048 | #4096 | #8192 | #16384 | #32768 | #65536 | #131072 | #262144 | #524288 | #1048576 | #2097152 | #4194304 | #8388608 | #16777216]
      module None : { type t = [#0] }
      module SingleLine : { type t = [#1] }
      module AdviseOnEmitNode : { type t = [#2] }
      module NoSubstitution : { type t = [#4] }
      module CapturesThis : { type t = [#8] }
      module NoLeadingSourceMap : { type t = [#16] }
      module NoTrailingSourceMap : { type t = [#32] }
      module NoSourceMap : { type t = [#48] }
      module NoNestedSourceMaps : { type t = [#64] }
      module NoTokenLeadingSourceMaps : { type t = [#128] }
      module NoTokenTrailingSourceMaps : { type t = [#256] }
      module NoTokenSourceMaps : { type t = [#384] }
      module NoLeadingComments : { type t = [#512] }
      module NoTrailingComments : { type t = [#1024] }
      module NoComments : { type t = [#1536] }
      module NoNestedComments : { type t = [#2048] }
      module HelperName : { type t = [#4096] }
      module ExportName : { type t = [#8192] }
      module LocalName : { type t = [#16384] }
      module InternalName : { type t = [#32768] }
      module Indented : { type t = [#65536] }
      module NoIndentation : { type t = [#131072] }
      module AsyncFunctionBody : { type t = [#262144] }
      module ReuseTempVariableScope : { type t = [#524288] }
      module CustomPrologue : { type t = [#1048576] }
      module NoHoisting : { type t = [#2097152] }
      module HasEndOfDeclarationMarker : { type t = [#4194304] }
      module Iterator : { type t = [#8388608] }
      module NoAsciiEscaping : { type t = [#16777216] }
    }
    module BuilderProgram : { type t = intf'<[#Ts_BuilderProgram]> }
    module SemanticDiagnosticsBuilderProgram : { type t = intf'<[#Ts_BuilderProgram | #Ts_SemanticDiagnosticsBuilderProgram]> }
    module EmitAndSemanticDiagnosticsBuilderProgram : {
      type t = intf'<[#Ts_BuilderProgram | #Ts_EmitAndSemanticDiagnosticsBuilderProgram | #Ts_SemanticDiagnosticsBuilderProgram]>
    }
    module ElementFlags : {
      type t = [#1 | #2 | #4 | #8 | #3 | #12 | #14 | #11]
      module Required : { type t = [#1] }
      module Optional : { type t = [#2] }
      module Rest : { type t = [#4] }
      module Variadic : { type t = [#8] }
      module Fixed : { type t = [#3] }
      module Variable : { type t = [#12] }
      module NonRequired : { type t = [#14] }
      module NonRest : { type t = [#11] }
    }
    module DotToken : { type t = PunctuationToken.t<SyntaxKind.DotToken.t> }
    module DocumentRegistryBucketKey : {
      module AnonymousInterface0 : { type t = private any }
      type t = Intersection.t2<string, AnonymousInterface0.t>
    }
    module DocumentRegistry : { type t = intf'<[#Ts_DocumentRegistry]> }
    module DocumentHighlights : { type t = intf'<[#Ts_DocumentHighlights]> }
    module DocCommentTemplateOptions : { type t = intf'<[#Ts_DocCommentTemplateOptions]> }
    module DirectoryWatcherCallback : { type t = string => unit }
    module DiagnosticWithLocation : {
      type t = intf'<[#Ts_Diagnostic | #Ts_DiagnosticRelatedInformation | #Ts_DiagnosticWithLocation]>
    }
    module DiagnosticReporter : { type t = Diagnostic.t => unit }
    module DiagnosticMessageChain : { type t = intf'<[#Ts_DiagnosticMessageChain]> }
    module DiagnosticCategory : {
      type t = Warning | Error | Suggestion | Message
      module Warning : { type t = private t }
      module Error : { type t = private t }
      module Suggestion : { type t = private t }
      module Message : { type t = private t }
    }
    module ObjectBindingPattern : { type t = intf'<[#Ts_Node | #Ts_ObjectBindingPattern | #Ts_ReadonlyTextRange]> }
    module ArrayBindingPattern : { type t = intf'<[#Ts_ArrayBindingPattern | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module BindingPattern : { type t = Union.t2<ObjectBindingPattern.t, ArrayBindingPattern.t> }
    module DestructuringPattern : {
      type t = Union.t3<BindingPattern.t, ObjectLiteralExpression.t, ArrayLiteralExpression.t>
    }
    module EqualsToken : { type t = PunctuationToken.t<SyntaxKind.EqualsToken.t> }
    module BinaryExpression : {
      type t = intf'<[#Ts_BinaryExpression | #Ts_Declaration | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module AssignmentExpression : {
      type t<'TOperator> = intf'<[#Ts_AssignmentExpression('TOperator) | #Ts_BinaryExpression | #Ts_Declaration | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module ObjectDestructuringAssignment : {
      type t = intf'<[#Ts_AssignmentExpression(EqualsToken.t) | #Ts_BinaryExpression | #Ts_Declaration | #Ts_Expression | #Ts_Node | #Ts_ObjectDestructuringAssignment | #Ts_ReadonlyTextRange]>
    }
    module ArrayDestructuringAssignment : {
      type t = intf'<[#Ts_AssignmentExpression(EqualsToken.t) | #Ts_ArrayDestructuringAssignment | #Ts_BinaryExpression | #Ts_Declaration | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module DestructuringAssignment : {
      type t = Union.t2<ObjectDestructuringAssignment.t, ArrayDestructuringAssignment.t>
    }
    module DeleteExpression : {
      type t = intf'<[#Ts_DeleteExpression | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression]>
    }
    module DefinitionInfoAndBoundSpan : { type t = intf'<[#Ts_DefinitionInfoAndBoundSpan]> }
    module DeferredTypeReference : {
      type t = intf'<[#Ts_DeferredTypeReference | #Ts_ObjectType | #Ts_Type | #Ts_TypeReference]>
    }
    module JSDocTypedefTag : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocTag | #Ts_JSDocTypedefTag | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocSignature : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocSignature | #Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module JSDocCallbackTag : {
      type t = intf'<[#Ts_Declaration | #Ts_JSDocCallbackTag | #Ts_JSDocTag | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module JSDocTemplateTag : {
      type t = intf'<[#Ts_JSDocTag | #Ts_JSDocTemplateTag | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module DeclarationWithTypeParameterChildren : {
      type t = Union.t5<SignatureDeclaration.t, ClassLikeDeclaration.t, InterfaceDeclaration.t, TypeAliasDeclaration.t, JSDocTemplateTag.t>
    }
    module DeclarationWithTypeParameters : {
      type t = Union.t4<DeclarationWithTypeParameterChildren.t, JSDocTypedefTag.t, JSDocCallbackTag.t, JSDocSignature.t>
    }
    module DeclarationName : {
      type t = Union.t8<Identifier.t, PrivateIdentifier.t, StringLiteralLike.t, NumericLiteral.t, ComputedPropertyName.t, ElementAccessExpression.t, BindingPattern.t, EntityNameExpression.t>
    }
    module CustomTransformers : { type t = intf'<[#Ts_CustomTransformers]> }
    module CustomTransformer : { type t = intf'<[#Ts_CustomTransformer]> }
    module CustomTransformerFactory : { type t = TransformationContext.t => CustomTransformer.t }
    module CreateProgramOptions : { type t = intf'<[#Ts_CreateProgramOptions]> }
    module ProjectReference : { type t = intf'<[#Ts_ProjectReference]> }
    module ModuleResolutionHost : { type t = intf'<[#Ts_ModuleResolutionHost]> }
    module CompilerHost : { type t = intf'<[#Ts_CompilerHost | #Ts_ModuleResolutionHost]> }
    module CreateProgram : {
      type t<'T> = (~rootNames:undefined<array<string>>, ~options:undefined<CompilerOptions.t>, ~host:CompilerHost.t=?, ~oldProgram:'T=?, ~configFileParsingDiagnostics:array<Diagnostic.t>=?, ~projectReferences:undefined<array<ProjectReference.t>>=?, unit) => 'T
    }
    module ConditionalTypeNode : {
      type t = intf'<[#Ts_ConditionalTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module ConditionalType : { type t = intf'<[#Ts_ConditionalType | #Ts_InstantiableType | #Ts_Type]> }
    module ConditionalRoot : { type t = intf'<[#Ts_ConditionalRoot]> }
    module ConditionalExpression : {
      type t = intf'<[#Ts_ConditionalExpression | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module FunctionBody : { type t = Block.t }
    module ConciseBody : { type t = Union.t2<FunctionBody.t, Expression.t> }
    module CompletionsTriggerCharacter : {
      type t = Union.t8<[#"."], [#"\""], [#"'"], [#"`"], [#"/"], [#"@"], [#"<"], Union.t2<[#"#"], [#" "]>>
    }
    module CompletionTriggerKind : {
      type t = [#1 | #2 | #3]
      module Invoked : { type t = [#1] }
      module TriggerCharacter : { type t = [#2] }
      module TriggerForIncompleteCompletions : { type t = [#3] }
    }
    module CompletionInfo : { type t = intf'<[#Ts_CompletionInfo]> }
    module CompletionEntryDetails : { type t = intf'<[#Ts_CompletionEntryDetails]> }
    module CompletionEntryDataAutoImport : { type t = intf'<[#Ts_CompletionEntryDataAutoImport]> }
    module CompletionEntryDataUnresolved : {
      type t = intf'<[#Ts_CompletionEntryDataAutoImport | #Ts_CompletionEntryDataUnresolved]>
    }
    module CompletionEntryDataResolved : {
      type t = intf'<[#Ts_CompletionEntryDataAutoImport | #Ts_CompletionEntryDataResolved]>
    }
    module CompletionEntryData : {
      type t = Union.t2<CompletionEntryDataUnresolved.t, CompletionEntryDataResolved.t>
    }
    module CompletionEntry : { type t = intf'<[#Ts_CompletionEntry]> }
    module PluginImport : { type t = intf'<[#Ts_PluginImport]> }
    module MapLike : { type t<'T> = intf'<[#Ts_MapLike('T)]> }
    module CompilerOptionsValue : {
      type t = nullable<Union.t8<string, float, bool, array<Union.t2<string, float>>, array<string>, MapLike.t<array<string>>, array<PluginImport.t>, array<ProjectReference.t>>>
    }
    module CommentKind : {
      type t = Union.t2<SyntaxKind.SingleLineCommentTrivia.t, SyntaxKind.MultiLineCommentTrivia.t>
    }
    module CommaListExpression : {
      type t = intf'<[#Ts_CommaListExpression | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]>
    }
    module CombinedCodeActions : { type t = intf'<[#Ts_CombinedCodeActions]> }
    module ColonToken : { type t = PunctuationToken.t<SyntaxKind.ColonToken.t> }
    module CodeAction : { type t = intf'<[#Ts_CodeAction]> }
    module CodeFixAction : { type t = intf'<[#Ts_CodeAction | #Ts_CodeFixAction]> }
    module InstallPackageAction : { type t = intf'<[#Ts_InstallPackageAction]> }
    module CodeActionCommand : { type t = InstallPackageAction.t }
    module Classifier : { type t = intf'<[#Ts_Classifier]> }
    module ClassifiedSpan2020 : { type t = intf'<[#Ts_ClassifiedSpan2020]> }
    module ClassifiedSpan : { type t = intf'<[#Ts_ClassifiedSpan]> }
    module Classifications : { type t = intf'<[#Ts_Classifications]> }
    module ClassificationTypeNames : {
      type t = [#comment | #identifier | #keyword | #number | #bigint | #operator | #string | #whitespace | #text | #punctuation | #"class name" | #"enum name" | #"interface name" | #"module name" | #"type parameter name" | #"type alias name" | #"parameter name" | #"doc comment tag name" | #"jsx open tag name" | #"jsx close tag name" | #"jsx self closing tag name" | #"jsx attribute" | #"jsx text" | #"jsx attribute string literal value"]
      module Comment : { type t = [#comment] }
      module Identifier : { type t = [#identifier] }
      module Keyword : { type t = [#keyword] }
      module NumericLiteral : { type t = [#number] }
      module BigintLiteral : { type t = [#bigint] }
      module Operator : { type t = [#operator] }
      module StringLiteral : { type t = [#string] }
      module WhiteSpace : { type t = [#whitespace] }
      module Text : { type t = [#text] }
      module Punctuation : { type t = [#punctuation] }
      module ClassName : { type t = [#"class name"] }
      module EnumName : { type t = [#"enum name"] }
      module InterfaceName : { type t = [#"interface name"] }
      module ModuleName : { type t = [#"module name"] }
      module TypeParameterName : { type t = [#"type parameter name"] }
      module TypeAliasName : { type t = [#"type alias name"] }
      module ParameterName : { type t = [#"parameter name"] }
      module DocCommentTagName : { type t = [#"doc comment tag name"] }
      module JsxOpenTagName : { type t = [#"jsx open tag name"] }
      module JsxCloseTagName : { type t = [#"jsx close tag name"] }
      module JsxSelfClosingTagName : { type t = [#"jsx self closing tag name"] }
      module JsxAttribute : { type t = [#"jsx attribute"] }
      module JsxText : { type t = [#"jsx text"] }
      module JsxAttributeStringLiteralValue : { type t = [#"jsx attribute string literal value"] }
    }
    module ClassificationType : {
      type t = [#1 | #2 | #3 | #4 | #5 | #6 | #7 | #8 | #9 | #10 | #11 | #12 | #13 | #14 | #15 | #16 | #17 | #18 | #19 | #20 | #21 | #22 | #23 | #24 | #25]
      module Comment : { type t = [#1] }
      module Identifier : { type t = [#2] }
      module Keyword : { type t = [#3] }
      module NumericLiteral : { type t = [#4] }
      module Operator : { type t = [#5] }
      module StringLiteral : { type t = [#6] }
      module RegularExpressionLiteral : { type t = [#7] }
      module WhiteSpace : { type t = [#8] }
      module Text : { type t = [#9] }
      module Punctuation : { type t = [#10] }
      module ClassName : { type t = [#11] }
      module EnumName : { type t = [#12] }
      module InterfaceName : { type t = [#13] }
      module ModuleName : { type t = [#14] }
      module TypeParameterName : { type t = [#15] }
      module TypeAliasName : { type t = [#16] }
      module ParameterName : { type t = [#17] }
      module DocCommentTagName : { type t = [#18] }
      module JsxOpenTagName : { type t = [#19] }
      module JsxCloseTagName : { type t = [#20] }
      module JsxSelfClosingTagName : { type t = [#21] }
      module JsxAttribute : { type t = [#22] }
      module JsxText : { type t = [#23] }
      module JsxAttributeStringLiteralValue : { type t = [#24] }
      module BigintLiteral : { type t = [#25] }
    }
    module ClassificationResult : { type t = intf'<[#Ts_ClassificationResult]> }
    module ClassificationInfo : { type t = intf'<[#Ts_ClassificationInfo]> }
    module ClassMemberModifier : { type t = Union.t3<AccessibilityModifier.t, ReadonlyKeyword.t, StaticKeyword.t> }
    module CheckJsDirective : { type t = intf'<[#Ts_CheckJsDirective | #Ts_TextRange]> }
    module CatchClause : { type t = intf'<[#Ts_CatchClause | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module CaseBlock : { type t = intf'<[#Ts_CaseBlock | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module CancellationToken : { type t = intf'<[#Ts_CancellationToken]> }
    module JsxOpeningLikeElement : { type t = Union.t2<JsxSelfClosingElement.t, JsxOpeningElement.t> }
    module Decorator : { type t = intf'<[#Ts_Decorator | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module CallLikeExpression : {
      type t = Union.t5<CallExpression.t, NewExpression.t, TaggedTemplateExpression.t, Decorator.t, JsxOpeningLikeElement.t>
    }
    module CallHierarchyOutgoingCall : { type t = intf'<[#Ts_CallHierarchyOutgoingCall]> }
    module CallHierarchyItem : { type t = intf'<[#Ts_CallHierarchyItem]> }
    module CallHierarchyIncomingCall : { type t = intf'<[#Ts_CallHierarchyIncomingCall]> }
    module Bundle : { type t = intf'<[#Ts_Bundle | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module BuilderProgramHost : { type t = intf'<[#Ts_BuilderProgramHost]> }
    module BuildOptions : { type t = intf'<[#Ts_BuildOptions]> }
    module BreakOrContinueStatement : { type t = Union.t2<BreakStatement.t, ContinueStatement.t> }
    module DefaultClause : { type t = intf'<[#Ts_DefaultClause | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module CaseClause : { type t = intf'<[#Ts_CaseClause | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module CaseOrDefaultClause : { type t = Union.t2<CaseClause.t, DefaultClause.t> }
    module BlockLike : { type t = Union.t4<SourceFile.t, Block.t, ModuleBlock.t, CaseOrDefaultClause.t> }
    module ObjectBindingOrAssignmentPattern : { type t = Union.t2<ObjectBindingPattern.t, ObjectLiteralExpression.t> }
    module ArrayBindingOrAssignmentPattern : { type t = Union.t2<ArrayBindingPattern.t, ArrayLiteralExpression.t> }
    module BindingOrAssignmentPattern : {
      type t = Union.t2<ObjectBindingOrAssignmentPattern.t, ArrayBindingOrAssignmentPattern.t>
    }
    module OmittedExpression : {
      type t = intf'<[#Ts_Expression | #Ts_Node | #Ts_OmittedExpression | #Ts_ReadonlyTextRange]>
    }
    module BindingOrAssignmentElementTarget : {
      type t = Union.t5<BindingOrAssignmentPattern.t, Identifier.t, PropertyAccessExpression.t, ElementAccessExpression.t, OmittedExpression.t>
    }
    module DotDotDotToken : { type t = PunctuationToken.t<SyntaxKind.DotDotDotToken.t> }
    module SpreadElement : {
      type t = intf'<[#Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SpreadElement]>
    }
    module BindingOrAssignmentElementRestIndicator : { type t = Union.t3<DotDotDotToken.t, SpreadElement.t, SpreadAssignment.t> }
    module ObjectBindingOrAssignmentElement : {
      type t = Union.t4<BindingElement.t, PropertyAssignment.t, ShorthandPropertyAssignment.t, SpreadAssignment.t>
    }
    module ArrayBindingOrAssignmentElement : {
      type t = Union.t8<BindingElement.t, OmittedExpression.t, SpreadElement.t, ArrayLiteralExpression.t, ObjectLiteralExpression.t, AssignmentExpression.t<EqualsToken.t>, Identifier.t, Union.t2<PropertyAccessExpression.t, ElementAccessExpression.t>>
    }
    module BindingOrAssignmentElement : {
      type t = Union.t4<VariableDeclaration.t, ParameterDeclaration.t, ObjectBindingOrAssignmentElement.t, ArrayBindingOrAssignmentElement.t>
    }
    module BindingName : { type t = Union.t2<Identifier.t, BindingPattern.t> }
    module LogicalOperator : {
      type t = Union.t2<SyntaxKind.AmpersandAmpersandToken.t, SyntaxKind.BarBarToken.t>
    }
    module ShiftOperator : {
      type t = Union.t3<SyntaxKind.LessThanLessThanToken.t, SyntaxKind.GreaterThanGreaterThanToken.t, SyntaxKind.GreaterThanGreaterThanGreaterThanToken.t>
    }
    module MultiplicativeOperator : {
      type t = Union.t3<SyntaxKind.AsteriskToken.t, SyntaxKind.SlashToken.t, SyntaxKind.PercentToken.t>
    }
    module ExponentiationOperator : { type t = SyntaxKind.AsteriskAsteriskToken.t }
    module MultiplicativeOperatorOrHigher : { type t = Union.t2<ExponentiationOperator.t, MultiplicativeOperator.t> }
    module AdditiveOperator : { type t = Union.t2<SyntaxKind.PlusToken.t, SyntaxKind.MinusToken.t> }
    module AdditiveOperatorOrHigher : { type t = Union.t2<MultiplicativeOperatorOrHigher.t, AdditiveOperator.t> }
    module ShiftOperatorOrHigher : { type t = Union.t2<AdditiveOperatorOrHigher.t, ShiftOperator.t> }
    module RelationalOperator : {
      type t = Union.t6<SyntaxKind.LessThanToken.t, SyntaxKind.LessThanEqualsToken.t, SyntaxKind.GreaterThanToken.t, SyntaxKind.GreaterThanEqualsToken.t, SyntaxKind.InstanceOfKeyword.t, SyntaxKind.InKeyword.t>
    }
    module RelationalOperatorOrHigher : { type t = Union.t2<ShiftOperatorOrHigher.t, RelationalOperator.t> }
    module EqualityOperator : {
      type t = Union.t4<SyntaxKind.EqualsEqualsToken.t, SyntaxKind.EqualsEqualsEqualsToken.t, SyntaxKind.ExclamationEqualsEqualsToken.t, SyntaxKind.ExclamationEqualsToken.t>
    }
    module EqualityOperatorOrHigher : { type t = Union.t2<RelationalOperatorOrHigher.t, EqualityOperator.t> }
    module BitwiseOperator : {
      type t = Union.t3<SyntaxKind.AmpersandToken.t, SyntaxKind.BarToken.t, SyntaxKind.CaretToken.t>
    }
    module BitwiseOperatorOrHigher : { type t = Union.t2<EqualityOperatorOrHigher.t, BitwiseOperator.t> }
    module LogicalOperatorOrHigher : { type t = Union.t2<BitwiseOperatorOrHigher.t, LogicalOperator.t> }
    module CompoundAssignmentOperator : {
      type t = Union.t8<SyntaxKind.PlusEqualsToken.t, SyntaxKind.MinusEqualsToken.t, SyntaxKind.AsteriskAsteriskEqualsToken.t, SyntaxKind.AsteriskEqualsToken.t, SyntaxKind.SlashEqualsToken.t, SyntaxKind.PercentEqualsToken.t, SyntaxKind.AmpersandEqualsToken.t, Union.t8<SyntaxKind.BarEqualsToken.t, SyntaxKind.CaretEqualsToken.t, SyntaxKind.LessThanLessThanEqualsToken.t, SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken.t, SyntaxKind.GreaterThanGreaterThanEqualsToken.t, SyntaxKind.BarBarEqualsToken.t, SyntaxKind.AmpersandAmpersandEqualsToken.t, SyntaxKind.QuestionQuestionEqualsToken.t>>
    }
    module AssignmentOperator : { type t = Union.t2<SyntaxKind.EqualsToken.t, CompoundAssignmentOperator.t> }
    module AssignmentOperatorOrHigher : {
      type t = Union.t3<SyntaxKind.QuestionQuestionToken.t, LogicalOperatorOrHigher.t, AssignmentOperator.t>
    }
    module BinaryOperator : { type t = Union.t2<AssignmentOperatorOrHigher.t, SyntaxKind.CommaToken.t> }
    module BinaryOperatorToken : { type t = Token.t<BinaryOperator.t> }
    module BigIntLiteralType : { type t = intf'<[#Ts_BigIntLiteralType | #Ts_LiteralType | #Ts_Type]> }
    module TypeParameter : { type t = intf'<[#Ts_InstantiableType | #Ts_Type | #Ts_TypeParameter]> }
    module IndexedAccessType : { type t = intf'<[#Ts_IndexedAccessType | #Ts_InstantiableType | #Ts_Type]> }
    module TypeVariable : { type t = Union.t2<TypeParameter.t, IndexedAccessType.t> }
    module BaseType : { type t = Union.t3<ObjectType.t, IntersectionType.t, TypeVariable.t> }
    module AwaitKeyword : { type t = KeywordToken.t<SyntaxKind.AwaitKeyword.t> }
    module AwaitKeywordToken : { type t = AwaitKeyword.t }
    module AwaitExpression : {
      type t = intf'<[#Ts_AwaitExpression | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression]>
    }
    module AsteriskToken : { type t = PunctuationToken.t<SyntaxKind.AsteriskToken.t> }
    module AssignmentPattern : { type t = Union.t2<ObjectLiteralExpression.t, ArrayLiteralExpression.t> }
    module AssignmentOperatorToken : { type t = Token.t<AssignmentOperator.t> }
    module AssertsKeyword : { type t = KeywordToken.t<SyntaxKind.AssertsKeyword.t> }
    module AssertsToken : { type t = AssertsKeyword.t }
    module AssertionKey : { type t = Union.t2<Identifier.t, StringLiteral.t> }
    module AssertKeyword : { type t = KeywordToken.t<SyntaxKind.AssertKeyword.t> }
    module AssertEntry : { type t = intf'<[#Ts_AssertEntry | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module AssertClause : { type t = intf'<[#Ts_AssertClause | #Ts_Node | #Ts_ReadonlyTextRange]> }
    module ArrayTypeNode : {
      type t = intf'<[#Ts_ArrayTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]>
    }
    module ArrayBindingElement : { type t = Union.t2<BindingElement.t, OmittedExpression.t> }
    module ApplyCodeActionCommandResult : { type t = intf'<[#Ts_ApplyCodeActionCommandResult]> }
    module ApplicableRefactorInfo : { type t = intf'<[#Ts_ApplicableRefactorInfo]> }
    module AnonymousInterface6 : { type t = private any }
    module AnonymousInterface41 : { type t = private any }
    module AnonymousInterface40 : { type t = private any }
    module AnonymousInterface32 : { type t = private any }
    module AnonymousInterface21 : { type t = private any }
    module AnonymousInterface20 : { type t = private any }
    module AnonymousInterface14 : { type t = private any }
    module AmdDependency : { type t = intf'<[#Ts_AmdDependency]> }
    module ScriptReferenceHost : { type t = intf'<[#Ts_ScriptReferenceHost]> }
    module Program : {
      module AnonymousInterface4 : { type t = private any }
      type t = intf'<[#Ts_Program | #Ts_ScriptReferenceHost]>
    }
    module AffectedFileResult : {
      module AnonymousInterface53 : { type t<'T> = private any }
      type t<'T> = undefined<AnonymousInterface53.t<'T>>
    }
    module AccessExpression : { type t = Union.t2<PropertyAccessExpression.t, ElementAccessExpression.t> }
  }
} = Types
open Types
module Ts = {
  open Ts
  module AbstractKeyword = {
    open AbstractKeyword
    type t = ModifierToken.t<SyntaxKind.AbstractKeyword.t>
    type t0 = t
  }
  module AccessExpression = {
    open AccessExpression
    type t = Union.t2<PropertyAccessExpression.t, ElementAccessExpression.t>
    type t0 = t
  }
  module AccessibilityModifier = {
    open AccessibilityModifier
    type t = Union.t3<PublicKeyword.t, PrivateKeyword.t, ProtectedKeyword.t>
    type t0 = t
  }
  module AccessorDeclaration = {
    open AccessorDeclaration
    type t = Union.t2<GetAccessorDeclaration.t, SetAccessorDeclaration.t>
    type t0 = t
  }
  module AdditiveOperator = {
    open AdditiveOperator
    type t = Union.t2<SyntaxKind.PlusToken.t, SyntaxKind.MinusToken.t>
    type t0 = t
  }
  module AdditiveOperatorOrHigher = {
    open AdditiveOperatorOrHigher
    type t = Union.t2<MultiplicativeOperatorOrHigher.t, AdditiveOperator.t>
    type t0 = t
  }
  module AffectedFileResult = {
    open AffectedFileResult
    module AnonymousInterface53 = {
      open AnonymousInterface53
      type t<'T> = t<'T>
      @get
      external getResult: t<'T> => 'T = "result"
      @set
      external setResult: (t<'T>, 'T) => unit = "result"
      @get
      external getAffected: t<'T> => Union.t2<SourceFile.t, Program.t> = "affected"
      @set
      external setAffected: (t<'T>, Union.t2<SourceFile.t, Program.t>) => unit = "affected"
      @obj
      external make: (~result: 'T, ~affected: Union.t2<SourceFile.t, Program.t>) => t<'T> = ""
    }
    type t<'T> = undefined<AnonymousInterface53.t<'T>>
    type t1<'T> = t<'T>
  }
  module AmdDependency = {
    open AmdDependency
    type t = t
    type t0 = t
    type tags = [#Ts_AmdDependency]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_AmdDependency ]
    @get
    external getPath: this<'tags, 'base> => string = "path"
    @set
    external setPath: (this<'tags, 'base>, string) => unit = "path"
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @obj
    external make: (~path: string, ~name: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module AnonymousInterface14 = {
    open AnonymousInterface14
    type t = t
    @get
    external expression: t => Union.t2<Identifier.t, PropertyAccessEntityNameExpression.t> = "expression"
    @obj
    external make: ~expression: Union.t2<Identifier.t, PropertyAccessEntityNameExpression.t> => t = ""
  }
  module AnonymousInterface20 = {
    open AnonymousInterface20
    type t = t
    @get
    external getOptions: t => CompilerOptions.t = "options"
    @set
    external setOptions: (t, CompilerOptions.t) => unit = "options"
    @get
    external getErrors: t => array<Diagnostic.t> = "errors"
    @set
    external setErrors: (t, array<Diagnostic.t>) => unit = "errors"
    @obj
    external make: (~options: CompilerOptions.t, ~errors: array<Diagnostic.t>) => t = ""
  }
  module AnonymousInterface21 = {
    open AnonymousInterface21
    type t = t
    @get
    external getOptions: t => TypeAcquisition.t = "options"
    @set
    external setOptions: (t, TypeAcquisition.t) => unit = "options"
    @get
    external getErrors: t => array<Diagnostic.t> = "errors"
    @set
    external setErrors: (t, array<Diagnostic.t>) => unit = "errors"
    @obj
    external make: (~options: TypeAcquisition.t, ~errors: array<Diagnostic.t>) => t = ""
  }
  module AnonymousInterface32 = {
    open AnonymousInterface32
    type t = t
    @send
    external getExecutingFilePath: t => string = "getExecutingFilePath"
    @send
    external resolvePath: (t, ~path:string) => string = "resolvePath"
    @send
    external fileExists: (t, ~fileName:string) => bool = "fileExists"
    @send @return(nullable)
    external readFile: (t, ~fileName:string) => option<string> = "readFile"
  }
  module AnonymousInterface40 = {
    open AnonymousInterface40
    type t = t
    let apply: (t, ~nodes:undefined<NodeArray.t<'T>>, ~visitor:undefined<Visitor.t>, ~test:(Dom.node => bool)=?, ~start:float=?, ~count:float=?, unit) => undefined<NodeArray.t<'T>> = (t, ~nodes, ~visitor, ~test=?, ~start=?, ~count=?, unit) => %raw(`t(nodes, visitor, test, start, count)`)
  }
  module AnonymousInterface41 = {
    open AnonymousInterface41
    type t = t
    let apply: (t, ~nodes:NodeArray.t<'T>, ~visitor:undefined<Visitor.t>, ~test:(Dom.node => bool)=?, ~start:float=?, ~count:float=?, unit) => NodeArray.t<'T> = (t, ~nodes, ~visitor, ~test=?, ~start=?, ~count=?, unit) => %raw(`t(nodes, visitor, test, start, count)`)
  }
  module AnonymousInterface6 = {
    open AnonymousInterface6
    type t = t
    @get
    external getConfig: t => any = "config"
    @set
    external setConfig: (t, any) => unit = "config"
    @get
    external getError: t => Diagnostic.t = "error"
    @set
    external setError: (t, Diagnostic.t) => unit = "error"
    @obj
    external make: (~config: any, ~error: Diagnostic.t) => t = ""
  }
  module ApplicableRefactorInfo = {
    open ApplicableRefactorInfo
    type t = t
    type t0 = t
    type tags = [#Ts_ApplicableRefactorInfo]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ApplicableRefactorInfo ]
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @get
    external getDescription: this<'tags, 'base> => string = "description"
    @set
    external setDescription: (this<'tags, 'base>, string) => unit = "description"
    @get
    external getInlineable: this<'tags, 'base> => bool = "inlineable"
    @set
    external setInlineable: (this<'tags, 'base>, bool) => unit = "inlineable"
    @get
    external getActions: this<'tags, 'base> => array<RefactorActionInfo.t> = "actions"
    @set
    external setActions: (this<'tags, 'base>, array<RefactorActionInfo.t>) => unit = "actions"
    @obj
    external make: (~name: string, ~description: string, ~inlineable: bool, ~actions: array<RefactorActionInfo.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ApplyCodeActionCommandResult = {
    open ApplyCodeActionCommandResult
    type t = t
    type t0 = t
    type tags = [#Ts_ApplyCodeActionCommandResult]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ApplyCodeActionCommandResult ]
    @get
    external getSuccessMessage: this<'tags, 'base> => string = "successMessage"
    @set
    external setSuccessMessage: (this<'tags, 'base>, string) => unit = "successMessage"
    @obj
    external make: ~successMessage: string => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ArrayBindingElement = {
    open ArrayBindingElement
    type t = Union.t2<BindingElement.t, OmittedExpression.t>
    type t0 = t
  }
  module ArrayBindingOrAssignmentElement = {
    open ArrayBindingOrAssignmentElement
    type t = Union.t8<BindingElement.t, OmittedExpression.t, SpreadElement.t, ArrayLiteralExpression.t, ObjectLiteralExpression.t, AssignmentExpression.t<EqualsToken.t>, Identifier.t, Union.t2<PropertyAccessExpression.t, ElementAccessExpression.t>>
    type t0 = t
  }
  module ArrayBindingOrAssignmentPattern = {
    open ArrayBindingOrAssignmentPattern
    type t = Union.t2<ArrayBindingPattern.t, ArrayLiteralExpression.t>
    type t0 = t
  }
  module ArrayBindingPattern = {
    open ArrayBindingPattern
    type t = t
    type t0 = t
    type tags = [#Ts_ArrayBindingPattern | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ArrayBindingPattern ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ArrayBindingPattern.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t3<VariableDeclaration.t, ParameterDeclaration.t, BindingElement.t> = "parent"
    @get
    external elements: this<'tags, 'base> => NodeArray.t<ArrayBindingElement.t> = "elements"
    @obj
    external make: (~kind: SyntaxKind.ArrayBindingPattern.t, ~parent: Union.t3<VariableDeclaration.t, ParameterDeclaration.t, BindingElement.t>, ~elements: NodeArray.t<ArrayBindingElement.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module ArrayDestructuringAssignment = {
    open ArrayDestructuringAssignment
    type t = t
    type t0 = t
    type tags = [#Ts_AssignmentExpression(EqualsToken.t) | #Ts_ArrayDestructuringAssignment | #Ts_BinaryExpression | #Ts_Declaration | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ArrayDestructuringAssignment ]
    @get
    external left: this<'tags, 'base> => ArrayLiteralExpression.t = "left"
    @obj
    external make: ~left: ArrayLiteralExpression.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asAssignmentExpression: t => AssignmentExpression.t<EqualsToken.t> = "%identity"
  }
  module ArrayLiteralExpression = {
    open ArrayLiteralExpression
    type t = t
    type t0 = t
    type tags = [#Ts_ArrayLiteralExpression | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ArrayLiteralExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ArrayLiteralExpression.t = "kind"
    @get
    external elements: this<'tags, 'base> => NodeArray.t<Expression.t> = "elements"
    @obj
    external make: (~kind: SyntaxKind.ArrayLiteralExpression.t, ~elements: NodeArray.t<Expression.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
  }
  module ArrayTypeNode = {
    open ArrayTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_ArrayTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ArrayTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ArrayType.t = "kind"
    @get
    external elementType: this<'tags, 'base> => TypeNode.t = "elementType"
    @obj
    external make: (~kind: SyntaxKind.ArrayType.t, ~elementType: TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
  }
  module ArrowFunction = {
    open ArrowFunction
    type t = t
    type t0 = t
    type tags = [#Ts_ArrowFunction | #Ts_Declaration | #Ts_Expression | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ArrowFunction ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ArrowFunction.t = "kind"
    @get
    external equalsGreaterThanToken: this<'tags, 'base> => EqualsGreaterThanToken.t = "equalsGreaterThanToken"
    @get
    external body: this<'tags, 'base> => ConciseBody.t = "body"
    @get
    external name: this<'tags, 'base> => never = "name"
    @obj
    external make: (~kind: SyntaxKind.ArrowFunction.t, ~equalsGreaterThanToken: EqualsGreaterThanToken.t, ~body: ConciseBody.t, ~name: never) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asExpression: t => Expression.t = "%identity"
    external asFunctionLikeDeclarationBase: t => FunctionLikeDeclarationBase.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module AsExpression = {
    open AsExpression
    type t = t
    type t0 = t
    type tags = [#Ts_AsExpression | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_AsExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.AsExpression.t = "kind"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: SyntaxKind.AsExpression.t, ~expression: Expression.t, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asExpression: t => Expression.t = "%identity"
  }
  module AssertClause = {
    open AssertClause
    type t = t
    type t0 = t
    type tags = [#Ts_AssertClause | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_AssertClause ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.AssertClause.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t2<ImportDeclaration.t, ExportDeclaration.t> = "parent"
    @get
    external elements: this<'tags, 'base> => NodeArray.t<AssertEntry.t> = "elements"
    @get
    external multiLine: this<'tags, 'base> => bool = "multiLine"
    @obj
    external make: (~kind: SyntaxKind.AssertClause.t, ~parent: Union.t2<ImportDeclaration.t, ExportDeclaration.t>, ~elements: NodeArray.t<AssertEntry.t>, ~multiLine: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module AssertEntry = {
    open AssertEntry
    type t = t
    type t0 = t
    type tags = [#Ts_AssertEntry | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_AssertEntry ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.AssertEntry.t = "kind"
    @get
    external parent: this<'tags, 'base> => AssertClause.t = "parent"
    @get
    external name: this<'tags, 'base> => AssertionKey.t = "name"
    @get
    external value: this<'tags, 'base> => Expression.t = "value"
    @obj
    external make: (~kind: SyntaxKind.AssertEntry.t, ~parent: AssertClause.t, ~name: AssertionKey.t, ~value: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module AssertKeyword = {
    open AssertKeyword
    type t = KeywordToken.t<SyntaxKind.AssertKeyword.t>
    type t0 = t
  }
  module AssertionExpression = {
    open AssertionExpression
    type t = Union.t2<TypeAssertion.t, AsExpression.t>
    type t0 = t
  }
  module AssertionKey = {
    open AssertionKey
    type t = Union.t2<Identifier.t, StringLiteral.t>
    type t0 = t
  }
  module AssertsIdentifierTypePredicate = {
    open AssertsIdentifierTypePredicate
    type t = t
    type t0 = t
    type tags = [#Ts_AssertsIdentifierTypePredicate | #Ts_TypePredicateBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_AssertsIdentifierTypePredicate ]
    @get
    external getKind: this<'tags, 'base> => TypePredicateKind.AssertsIdentifier.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, TypePredicateKind.AssertsIdentifier.t) => unit = "kind"
    @get
    external getParameterName: this<'tags, 'base> => string = "parameterName"
    @set
    external setParameterName: (this<'tags, 'base>, string) => unit = "parameterName"
    @get
    external getParameterIndex: this<'tags, 'base> => float = "parameterIndex"
    @set
    external setParameterIndex: (this<'tags, 'base>, float) => unit = "parameterIndex"
    @get @return(nullable)
    external getType: this<'tags, 'base> => option<Type.t> = "type"
    @set
    external setType: (this<'tags, 'base>, undefined<Type.t>) => unit = "type"
    @obj
    external make: (~kind: TypePredicateKind.AssertsIdentifier.t, ~parameterName: string, ~parameterIndex: float, ~\"type": Type.t=?, unit) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypePredicateBase: t => TypePredicateBase.t = "%identity"
  }
  module AssertsKeyword = {
    open AssertsKeyword
    type t = KeywordToken.t<SyntaxKind.AssertsKeyword.t>
    type t0 = t
  }
  module AssertsThisTypePredicate = {
    open AssertsThisTypePredicate
    type t = t
    type t0 = t
    type tags = [#Ts_AssertsThisTypePredicate | #Ts_TypePredicateBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_AssertsThisTypePredicate ]
    @get
    external getKind: this<'tags, 'base> => TypePredicateKind.AssertsThis.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, TypePredicateKind.AssertsThis.t) => unit = "kind"
    @get
    external getParameterName: this<'tags, 'base> => unit = "parameterName"
    @set
    external setParameterName: (this<'tags, 'base>, unit) => unit = "parameterName"
    @get
    external getParameterIndex: this<'tags, 'base> => unit = "parameterIndex"
    @set
    external setParameterIndex: (this<'tags, 'base>, unit) => unit = "parameterIndex"
    @get @return(nullable)
    external getType: this<'tags, 'base> => option<Type.t> = "type"
    @set
    external setType: (this<'tags, 'base>, undefined<Type.t>) => unit = "type"
    @obj
    external make: (~kind: TypePredicateKind.AssertsThis.t, ~parameterName: never=?, ~parameterIndex: never=?, ~\"type": Type.t=?, unit) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypePredicateBase: t => TypePredicateBase.t = "%identity"
  }
  module AssertsToken = {
    open AssertsToken
    type t = AssertsKeyword.t
    type t0 = t
  }
  module AssignmentExpression = {
    open AssignmentExpression
    type t<'TOperator> = t<'TOperator>
    type t1<'TOperator> = t<'TOperator>
    type tags<'TOperator> = [#Ts_AssignmentExpression('TOperator) | #Ts_BinaryExpression | #Ts_Declaration | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags1<'TOperator> = tags<'TOperator>
    type this<'tags, 'base, 'TOperator> = intf<'tags, 'base> constraint 'tags = [> #Ts_AssignmentExpression('TOperator) ]
    @get
    external left: this<'tags, 'base, 'TOperator> => LeftHandSideExpression.t = "left"
    @get
    external operatorToken: this<'tags, 'base, 'TOperator> => 'TOperator = "operatorToken"
    @obj
    external make: (~left: LeftHandSideExpression.t, ~operatorToken: 'TOperator) => t<'TOperator> = ""
    external castFrom: this<'tags, 'base, 'TOperator> => t<'TOperator> = "%identity"
    external asBinaryExpression: t<'TOperator> => BinaryExpression.t = "%identity"
  }
  module AssignmentOperator = {
    open AssignmentOperator
    type t = Union.t2<SyntaxKind.EqualsToken.t, CompoundAssignmentOperator.t>
    type t0 = t
  }
  module AssignmentOperatorOrHigher = {
    open AssignmentOperatorOrHigher
    type t = Union.t3<SyntaxKind.QuestionQuestionToken.t, LogicalOperatorOrHigher.t, AssignmentOperator.t>
    type t0 = t
  }
  module AssignmentOperatorToken = {
    open AssignmentOperatorToken
    type t = Token.t<AssignmentOperator.t>
    type t0 = t
  }
  module AssignmentPattern = {
    open AssignmentPattern
    type t = Union.t2<ObjectLiteralExpression.t, ArrayLiteralExpression.t>
    type t0 = t
  }
  module AsteriskToken = {
    open AsteriskToken
    type t = PunctuationToken.t<SyntaxKind.AsteriskToken.t>
    type t0 = t
  }
  module AsyncKeyword = {
    open AsyncKeyword
    type t = ModifierToken.t<SyntaxKind.AsyncKeyword.t>
    type t0 = t
  }
  module AwaitExpression = {
    open AwaitExpression
    type t = t
    type t0 = t
    type tags = [#Ts_AwaitExpression | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_AwaitExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.AwaitExpression.t = "kind"
    @get
    external expression: this<'tags, 'base> => UnaryExpression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.AwaitExpression.t, ~expression: UnaryExpression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asUnaryExpression: t => UnaryExpression.t = "%identity"
  }
  module AwaitKeyword = {
    open AwaitKeyword
    type t = KeywordToken.t<SyntaxKind.AwaitKeyword.t>
    type t0 = t
  }
  module AwaitKeywordToken = {
    open AwaitKeywordToken
    type t = AwaitKeyword.t
    type t0 = t
  }
  module BaseType = {
    open BaseType
    type t = Union.t3<ObjectType.t, IntersectionType.t, TypeVariable.t>
    type t0 = t
  }
  module BigIntLiteral = {
    open BigIntLiteral
    type t = t
    type t0 = t
    type tags = [#Ts_BigIntLiteral | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_LiteralExpression | #Ts_LiteralLikeNode | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_BigIntLiteral ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.BigIntLiteral.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.BigIntLiteral.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLiteralExpression: t => LiteralExpression.t = "%identity"
  }
  module BigIntLiteralType = {
    open BigIntLiteralType
    type t = t
    type t0 = t
    type tags = [#Ts_BigIntLiteralType | #Ts_LiteralType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_BigIntLiteralType ]
    @get
    external getValue: this<'tags, 'base> => PseudoBigInt.t = "value"
    @set
    external setValue: (this<'tags, 'base>, PseudoBigInt.t) => unit = "value"
    @obj
    external make: ~value: PseudoBigInt.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLiteralType: t => LiteralType.t = "%identity"
  }
  module BinaryExpression = {
    open BinaryExpression
    type t = t
    type t0 = t
    type tags = [#Ts_BinaryExpression | #Ts_Declaration | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_BinaryExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.BinaryExpression.t = "kind"
    @get
    external left: this<'tags, 'base> => Expression.t = "left"
    @get
    external operatorToken: this<'tags, 'base> => BinaryOperatorToken.t = "operatorToken"
    @get
    external right: this<'tags, 'base> => Expression.t = "right"
    @obj
    external make: (~kind: SyntaxKind.BinaryExpression.t, ~left: Expression.t, ~operatorToken: BinaryOperatorToken.t, ~right: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asExpression: t => Expression.t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module BinaryOperator = {
    open BinaryOperator
    type t = Union.t2<AssignmentOperatorOrHigher.t, SyntaxKind.CommaToken.t>
    type t0 = t
  }
  module BinaryOperatorToken = {
    open BinaryOperatorToken
    type t = Token.t<BinaryOperator.t>
    type t0 = t
  }
  module BindingElement = {
    open BindingElement
    type t = t
    type t0 = t
    type tags = [#Ts_BindingElement | #Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_BindingElement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.BindingElement.t = "kind"
    @get
    external parent: this<'tags, 'base> => BindingPattern.t = "parent"
    @get
    external propertyName: this<'tags, 'base> => PropertyName.t = "propertyName"
    @get
    external dotDotDotToken: this<'tags, 'base> => DotDotDotToken.t = "dotDotDotToken"
    @get
    external name: this<'tags, 'base> => BindingName.t = "name"
    @get
    external initializer: this<'tags, 'base> => Expression.t = "initializer"
    @obj
    external make: (~kind: SyntaxKind.BindingElement.t, ~parent: BindingPattern.t, ~propertyName: PropertyName.t, ~dotDotDotToken: DotDotDotToken.t, ~name: BindingName.t, ~initializer: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
  }
  module BindingName = {
    open BindingName
    type t = Union.t2<Identifier.t, BindingPattern.t>
    type t0 = t
  }
  module BindingOrAssignmentElement = {
    open BindingOrAssignmentElement
    type t = Union.t4<VariableDeclaration.t, ParameterDeclaration.t, ObjectBindingOrAssignmentElement.t, ArrayBindingOrAssignmentElement.t>
    type t0 = t
  }
  module BindingOrAssignmentElementRestIndicator = {
    open BindingOrAssignmentElementRestIndicator
    type t = Union.t3<DotDotDotToken.t, SpreadElement.t, SpreadAssignment.t>
    type t0 = t
  }
  module BindingOrAssignmentElementTarget = {
    open BindingOrAssignmentElementTarget
    type t = Union.t5<BindingOrAssignmentPattern.t, Identifier.t, PropertyAccessExpression.t, ElementAccessExpression.t, OmittedExpression.t>
    type t0 = t
  }
  module BindingOrAssignmentPattern = {
    open BindingOrAssignmentPattern
    type t = Union.t2<ObjectBindingOrAssignmentPattern.t, ArrayBindingOrAssignmentPattern.t>
    type t0 = t
  }
  module BindingPattern = {
    open BindingPattern
    type t = Union.t2<ObjectBindingPattern.t, ArrayBindingPattern.t>
    type t0 = t
  }
  module BitwiseOperator = {
    open BitwiseOperator
    type t = Union.t3<SyntaxKind.AmpersandToken.t, SyntaxKind.BarToken.t, SyntaxKind.CaretToken.t>
    type t0 = t
  }
  module BitwiseOperatorOrHigher = {
    open BitwiseOperatorOrHigher
    type t = Union.t2<EqualityOperatorOrHigher.t, BitwiseOperator.t>
    type t0 = t
  }
  module Block = {
    open Block
    type t = t
    type t0 = t
    type tags = [#Ts_Block | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Block ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.Block.t = "kind"
    @get
    external statements: this<'tags, 'base> => NodeArray.t<Statement.t> = "statements"
    @obj
    external make: (~kind: SyntaxKind.Block.t, ~statements: NodeArray.t<Statement.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module BlockLike = {
    open BlockLike
    type t = Union.t4<SourceFile.t, Block.t, ModuleBlock.t, CaseOrDefaultClause.t>
    type t0 = t
  }
  module BooleanLiteral = {
    open BooleanLiteral
    type t = Union.t2<TrueLiteral.t, FalseLiteral.t>
    type t0 = t
  }
  module BreakOrContinueStatement = {
    open BreakOrContinueStatement
    type t = Union.t2<BreakStatement.t, ContinueStatement.t>
    type t0 = t
  }
  module BreakStatement = {
    open BreakStatement
    type t = t
    type t0 = t
    type tags = [#Ts_BreakStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_BreakStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.BreakStatement.t = "kind"
    @get
    external label: this<'tags, 'base> => Identifier.t = "label"
    @obj
    external make: (~kind: SyntaxKind.BreakStatement.t, ~label: Identifier.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module BuildInvalidedProject = {
    open BuildInvalidedProject
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_BuildInvalidedProject('T) | #Ts_InvalidatedProjectBase]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_BuildInvalidedProject('T) ]
    @get
    external kind: this<'tags, 'base, 'T> => InvalidatedProjectKind.Build.t = "kind"
    @send @return(nullable)
    external getBuilderProgram: this<'tags, 'base, 'T> => option<'T> = "getBuilderProgram"
    @send @return(nullable)
    external getProgram: this<'tags, 'base, 'T> => option<Program.t> = "getProgram"
    @send @return(nullable)
    external getSourceFile: (this<'tags, 'base, 'T>, ~fileName:string) => option<SourceFile.t> = "getSourceFile"
    @send
    external getSourceFiles: this<'tags, 'base, 'T> => array<SourceFile.t> = "getSourceFiles"
    @send
    external getOptionsDiagnostics: (this<'tags, 'base, 'T>, ~cancellationToken:CancellationToken.t=?, unit) => array<Diagnostic.t> = "getOptionsDiagnostics"
    @send
    external getGlobalDiagnostics: (this<'tags, 'base, 'T>, ~cancellationToken:CancellationToken.t=?, unit) => array<Diagnostic.t> = "getGlobalDiagnostics"
    @send
    external getConfigFileParsingDiagnostics: this<'tags, 'base, 'T> => array<Diagnostic.t> = "getConfigFileParsingDiagnostics"
    @send
    external getSyntacticDiagnostics: (this<'tags, 'base, 'T>, ~sourceFile:SourceFile.t=?, ~cancellationToken:CancellationToken.t=?, unit) => array<Diagnostic.t> = "getSyntacticDiagnostics"
    @send
    external getAllDependencies: (this<'tags, 'base, 'T>, ~sourceFile:SourceFile.t) => array<string> = "getAllDependencies"
    @send
    external getSemanticDiagnostics: (this<'tags, 'base, 'T>, ~sourceFile:SourceFile.t=?, ~cancellationToken:CancellationToken.t=?, unit) => array<Diagnostic.t> = "getSemanticDiagnostics"
    @send
    external getSemanticDiagnosticsOfNextAffectedFile: (this<'tags, 'base, 'T>, ~cancellationToken:CancellationToken.t=?, ~ignoreSourceFile:(@uncurry SourceFile.t => bool)=?, unit) => AffectedFileResult.t<array<Diagnostic.t>> = "getSemanticDiagnosticsOfNextAffectedFile"
    @send @return(nullable)
    external emit: (this<'tags, 'base, 'T>, ~targetSourceFile:SourceFile.t=?, ~writeFile:WriteFileCallback.t=?, ~cancellationToken:CancellationToken.t=?, ~emitOnlyDtsFiles:bool=?, ~customTransformers:CustomTransformers.t=?, unit) => option<EmitResult.t> = "emit"
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asInvalidatedProjectBase: t<'T> => InvalidatedProjectBase.t = "%identity"
  }
  module BuildOptions = {
    open BuildOptions
    type t = t
    type t0 = t
    type tags = [#Ts_BuildOptions]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_BuildOptions ]
    @get
    external getDry: this<'tags, 'base> => bool = "dry"
    @set
    external setDry: (this<'tags, 'base>, bool) => unit = "dry"
    @get
    external getForce: this<'tags, 'base> => bool = "force"
    @set
    external setForce: (this<'tags, 'base>, bool) => unit = "force"
    @get
    external getVerbose: this<'tags, 'base> => bool = "verbose"
    @set
    external setVerbose: (this<'tags, 'base>, bool) => unit = "verbose"
    @get
    external getIncremental: this<'tags, 'base> => bool = "incremental"
    @set
    external setIncremental: (this<'tags, 'base>, bool) => unit = "incremental"
    @get
    external getAssumeChangesOnlyAffectDirectDependencies: this<'tags, 'base> => bool = "assumeChangesOnlyAffectDirectDependencies"
    @set
    external setAssumeChangesOnlyAffectDirectDependencies: (this<'tags, 'base>, bool) => unit = "assumeChangesOnlyAffectDirectDependencies"
    @get
    external getTraceResolution: this<'tags, 'base> => bool = "traceResolution"
    @set
    external setTraceResolution: (this<'tags, 'base>, bool) => unit = "traceResolution"
    @get_index @return(nullable)
    external get: (this<'tags, 'base>, string) => option<CompilerOptionsValue.t> = ""
    @set_index
    external set: (this<'tags, 'base>, string, undefined<CompilerOptionsValue.t>) => unit = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module BuilderProgram = {
    open BuilderProgram
    type t = t
    type t0 = t
    type tags = [#Ts_BuilderProgram]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_BuilderProgram ]
    @send
    external getProgram: this<'tags, 'base> => Program.t = "getProgram"
    @send
    external getCompilerOptions: this<'tags, 'base> => CompilerOptions.t = "getCompilerOptions"
    @send @return(nullable)
    external getSourceFile: (this<'tags, 'base>, ~fileName:string) => option<SourceFile.t> = "getSourceFile"
    @send
    external getSourceFiles: this<'tags, 'base> => array<SourceFile.t> = "getSourceFiles"
    @send
    external getOptionsDiagnostics: (this<'tags, 'base>, ~cancellationToken:CancellationToken.t=?, unit) => array<Diagnostic.t> = "getOptionsDiagnostics"
    @send
    external getGlobalDiagnostics: (this<'tags, 'base>, ~cancellationToken:CancellationToken.t=?, unit) => array<Diagnostic.t> = "getGlobalDiagnostics"
    @send
    external getConfigFileParsingDiagnostics: this<'tags, 'base> => array<Diagnostic.t> = "getConfigFileParsingDiagnostics"
    @send
    external getSyntacticDiagnostics: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, ~cancellationToken:CancellationToken.t=?, unit) => array<Diagnostic.t> = "getSyntacticDiagnostics"
    @send
    external getDeclarationDiagnostics: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, ~cancellationToken:CancellationToken.t=?, unit) => array<DiagnosticWithLocation.t> = "getDeclarationDiagnostics"
    @send
    external getAllDependencies: (this<'tags, 'base>, ~sourceFile:SourceFile.t) => array<string> = "getAllDependencies"
    @send
    external getSemanticDiagnostics: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, ~cancellationToken:CancellationToken.t=?, unit) => array<Diagnostic.t> = "getSemanticDiagnostics"
    @send
    external emit: (this<'tags, 'base>, ~targetSourceFile:SourceFile.t=?, ~writeFile:WriteFileCallback.t=?, ~cancellationToken:CancellationToken.t=?, ~emitOnlyDtsFiles:bool=?, ~customTransformers:CustomTransformers.t=?, unit) => EmitResult.t = "emit"
    @send
    external getCurrentDirectory: this<'tags, 'base> => string = "getCurrentDirectory"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module BuilderProgramHost = {
    open BuilderProgramHost
    type t = t
    type t0 = t
    type tags = [#Ts_BuilderProgramHost]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_BuilderProgramHost ]
    @send
    external useCaseSensitiveFileNames: this<'tags, 'base> => bool = "useCaseSensitiveFileNames"
    @send
    external createHash: (this<'tags, 'base>, ~data:string) => string = "createHash"
    @get
    external getWriteFile: this<'tags, 'base> => WriteFileCallback.t = "writeFile"
    @set
    external setWriteFile: (this<'tags, 'base>, WriteFileCallback.t) => unit = "writeFile"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module Bundle = {
    open Bundle
    type t = t
    type t0 = t
    type tags = [#Ts_Bundle | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Bundle ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.Bundle.t = "kind"
    @get
    external prepends: this<'tags, 'base> => array<Union.t2<InputFiles.t, UnparsedSource.t>> = "prepends"
    @get
    external sourceFiles: this<'tags, 'base> => array<SourceFile.t> = "sourceFiles"
    @obj
    external make: (~kind: SyntaxKind.Bundle.t, ~prepends: array<Union.t2<InputFiles.t, UnparsedSource.t>>, ~sourceFiles: array<SourceFile.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module CallChain = {
    open CallChain
    type t = t
    type t0 = t
    type tags = [#Ts_CallChain | #Ts_CallExpression | #Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CallChain ]
    @get
    external get_optionalChainBrand: this<'tags, 'base> => any = "_optionalChainBrand"
    @set
    external set_optionalChainBrand: (this<'tags, 'base>, any) => unit = "_optionalChainBrand"
    @obj
    external make: ~\"_optionalChainBrand": any => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asCallExpression: t => CallExpression.t = "%identity"
  }
  module CallExpression = {
    open CallExpression
    type t = t
    type t0 = t
    type tags = [#Ts_CallExpression | #Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CallExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.CallExpression.t = "kind"
    @get
    external expression: this<'tags, 'base> => LeftHandSideExpression.t = "expression"
    @get
    external questionDotToken: this<'tags, 'base> => QuestionDotToken.t = "questionDotToken"
    @get
    external typeArguments: this<'tags, 'base> => NodeArray.t<TypeNode.t> = "typeArguments"
    @get
    external arguments: this<'tags, 'base> => NodeArray.t<Expression.t> = "arguments"
    @obj
    external make: (~kind: SyntaxKind.CallExpression.t, ~expression: LeftHandSideExpression.t, ~questionDotToken: QuestionDotToken.t, ~typeArguments: NodeArray.t<TypeNode.t>, ~arguments: NodeArray.t<Expression.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLeftHandSideExpression: t => LeftHandSideExpression.t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module CallHierarchyIncomingCall = {
    open CallHierarchyIncomingCall
    type t = t
    type t0 = t
    type tags = [#Ts_CallHierarchyIncomingCall]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CallHierarchyIncomingCall ]
    @get
    external getFrom: this<'tags, 'base> => CallHierarchyItem.t = "from"
    @set
    external setFrom: (this<'tags, 'base>, CallHierarchyItem.t) => unit = "from"
    @get
    external getFromSpans: this<'tags, 'base> => array<TextSpan.t> = "fromSpans"
    @set
    external setFromSpans: (this<'tags, 'base>, array<TextSpan.t>) => unit = "fromSpans"
    @obj
    external make: (~from: CallHierarchyItem.t, ~fromSpans: array<TextSpan.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CallHierarchyItem = {
    open CallHierarchyItem
    type t = t
    type t0 = t
    type tags = [#Ts_CallHierarchyItem]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CallHierarchyItem ]
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @get
    external getKind: this<'tags, 'base> => ScriptElementKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, ScriptElementKind.t) => unit = "kind"
    @get
    external getKindModifiers: this<'tags, 'base> => string = "kindModifiers"
    @set
    external setKindModifiers: (this<'tags, 'base>, string) => unit = "kindModifiers"
    @get
    external getFile: this<'tags, 'base> => string = "file"
    @set
    external setFile: (this<'tags, 'base>, string) => unit = "file"
    @get
    external getSpan: this<'tags, 'base> => TextSpan.t = "span"
    @set
    external setSpan: (this<'tags, 'base>, TextSpan.t) => unit = "span"
    @get
    external getSelectionSpan: this<'tags, 'base> => TextSpan.t = "selectionSpan"
    @set
    external setSelectionSpan: (this<'tags, 'base>, TextSpan.t) => unit = "selectionSpan"
    @get
    external getContainerName: this<'tags, 'base> => string = "containerName"
    @set
    external setContainerName: (this<'tags, 'base>, string) => unit = "containerName"
    @obj
    external make: (~name: string, ~kind: ScriptElementKind.t, ~kindModifiers: string, ~file: string, ~span: TextSpan.t, ~selectionSpan: TextSpan.t, ~containerName: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CallHierarchyOutgoingCall = {
    open CallHierarchyOutgoingCall
    type t = t
    type t0 = t
    type tags = [#Ts_CallHierarchyOutgoingCall]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CallHierarchyOutgoingCall ]
    @get
    external getTo: this<'tags, 'base> => CallHierarchyItem.t = "to"
    @set
    external setTo: (this<'tags, 'base>, CallHierarchyItem.t) => unit = "to"
    @get
    external getFromSpans: this<'tags, 'base> => array<TextSpan.t> = "fromSpans"
    @set
    external setFromSpans: (this<'tags, 'base>, array<TextSpan.t>) => unit = "fromSpans"
    @obj
    external make: (~to: CallHierarchyItem.t, ~fromSpans: array<TextSpan.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CallLikeExpression = {
    open CallLikeExpression
    type t = Union.t5<CallExpression.t, NewExpression.t, TaggedTemplateExpression.t, Decorator.t, JsxOpeningLikeElement.t>
    type t0 = t
  }
  module CallSignatureDeclaration = {
    open CallSignatureDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_CallSignatureDeclaration | #Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeElement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CallSignatureDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.CallSignature.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.CallSignature.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asSignatureDeclarationBase: t => SignatureDeclarationBase.t = "%identity"
    external asTypeElement: t => TypeElement.t = "%identity"
  }
  module CancellationToken = {
    open CancellationToken
    type t = t
    type t0 = t
    type tags = [#Ts_CancellationToken]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CancellationToken ]
    @send
    external isCancellationRequested: this<'tags, 'base> => bool = "isCancellationRequested"
    @send
    external throwIfCancellationRequested: this<'tags, 'base> => unit = "throwIfCancellationRequested"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CaseBlock = {
    open CaseBlock
    type t = t
    type t0 = t
    type tags = [#Ts_CaseBlock | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CaseBlock ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.CaseBlock.t = "kind"
    @get
    external parent: this<'tags, 'base> => SwitchStatement.t = "parent"
    @get
    external clauses: this<'tags, 'base> => NodeArray.t<CaseOrDefaultClause.t> = "clauses"
    @obj
    external make: (~kind: SyntaxKind.CaseBlock.t, ~parent: SwitchStatement.t, ~clauses: NodeArray.t<CaseOrDefaultClause.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module CaseClause = {
    open CaseClause
    type t = t
    type t0 = t
    type tags = [#Ts_CaseClause | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CaseClause ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.CaseClause.t = "kind"
    @get
    external parent: this<'tags, 'base> => CaseBlock.t = "parent"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @get
    external statements: this<'tags, 'base> => NodeArray.t<Statement.t> = "statements"
    @obj
    external make: (~kind: SyntaxKind.CaseClause.t, ~parent: CaseBlock.t, ~expression: Expression.t, ~statements: NodeArray.t<Statement.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module CaseOrDefaultClause = {
    open CaseOrDefaultClause
    type t = Union.t2<CaseClause.t, DefaultClause.t>
    type t0 = t
  }
  module CatchClause = {
    open CatchClause
    type t = t
    type t0 = t
    type tags = [#Ts_CatchClause | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CatchClause ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.CatchClause.t = "kind"
    @get
    external parent: this<'tags, 'base> => TryStatement.t = "parent"
    @get
    external variableDeclaration: this<'tags, 'base> => VariableDeclaration.t = "variableDeclaration"
    @get
    external block: this<'tags, 'base> => Block.t = "block"
    @obj
    external make: (~kind: SyntaxKind.CatchClause.t, ~parent: TryStatement.t, ~variableDeclaration: VariableDeclaration.t, ~block: Block.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module CheckJsDirective = {
    open CheckJsDirective
    type t = t
    type t0 = t
    type tags = [#Ts_CheckJsDirective | #Ts_TextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CheckJsDirective ]
    @get
    external getEnabled: this<'tags, 'base> => bool = "enabled"
    @set
    external setEnabled: (this<'tags, 'base>, bool) => unit = "enabled"
    @obj
    external make: ~enabled: bool => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTextRange: t => TextRange.t = "%identity"
  }
  module ClassDeclaration = {
    open ClassDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_ClassDeclaration | #Ts_ClassLikeDeclarationBase | #Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ClassDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ClassDeclaration.t = "kind"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @obj
    external make: (~kind: SyntaxKind.ClassDeclaration.t, ~name: Identifier.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asClassLikeDeclarationBase: t => ClassLikeDeclarationBase.t = "%identity"
    external asDeclarationStatement: t => DeclarationStatement.t = "%identity"
  }
  module ClassElement = {
    open ClassElement
    type t = t
    type t0 = t
    type tags = [#Ts_ClassElement | #Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ClassElement ]
    @get
    external get_classElementBrand: this<'tags, 'base> => any = "_classElementBrand"
    @set
    external set_classElementBrand: (this<'tags, 'base>, any) => unit = "_classElementBrand"
    @get
    external name: this<'tags, 'base> => PropertyName.t = "name"
    @obj
    external make: (~\"_classElementBrand": any, ~name: PropertyName.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
  }
  module ClassExpression = {
    open ClassExpression
    type t = t
    type t0 = t
    type tags = [#Ts_ClassExpression | #Ts_ClassLikeDeclarationBase | #Ts_Declaration | #Ts_Expression | #Ts_JSDocContainer | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ClassExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ClassExpression.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.ClassExpression.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asClassLikeDeclarationBase: t => ClassLikeDeclarationBase.t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
  }
  module ClassLikeDeclaration = {
    open ClassLikeDeclaration
    type t = Union.t2<ClassDeclaration.t, ClassExpression.t>
    type t0 = t
  }
  module ClassLikeDeclarationBase = {
    open ClassLikeDeclarationBase
    type t = t
    type t0 = t
    type tags = [#Ts_ClassLikeDeclarationBase | #Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ClassLikeDeclarationBase ]
    @get
    external kind: this<'tags, 'base> => Union.t2<SyntaxKind.ClassDeclaration.t, SyntaxKind.ClassExpression.t> = "kind"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external typeParameters: this<'tags, 'base> => NodeArray.t<TypeParameterDeclaration.t> = "typeParameters"
    @get
    external heritageClauses: this<'tags, 'base> => NodeArray.t<HeritageClause.t> = "heritageClauses"
    @get
    external members: this<'tags, 'base> => NodeArray.t<ClassElement.t> = "members"
    @obj
    external make: (~kind: Union.t2<SyntaxKind.ClassDeclaration.t, SyntaxKind.ClassExpression.t>, ~name: Identifier.t, ~typeParameters: NodeArray.t<TypeParameterDeclaration.t>, ~heritageClauses: NodeArray.t<HeritageClause.t>, ~members: NodeArray.t<ClassElement.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module ClassMemberModifier = {
    open ClassMemberModifier
    type t = Union.t3<AccessibilityModifier.t, ReadonlyKeyword.t, StaticKeyword.t>
    type t0 = t
  }
  module ClassStaticBlockDeclaration = {
    open ClassStaticBlockDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_ClassElement | #Ts_ClassStaticBlockDeclaration | #Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ClassStaticBlockDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ClassStaticBlockDeclaration.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t2<ClassDeclaration.t, ClassExpression.t> = "parent"
    @get
    external body: this<'tags, 'base> => Block.t = "body"
    @obj
    external make: (~kind: SyntaxKind.ClassStaticBlockDeclaration.t, ~parent: Union.t2<ClassDeclaration.t, ClassExpression.t>, ~body: Block.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asClassElement: t => ClassElement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module ClassificationInfo = {
    open ClassificationInfo
    type t = t
    type t0 = t
    type tags = [#Ts_ClassificationInfo]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ClassificationInfo ]
    @get
    external getLength: this<'tags, 'base> => float = "length"
    @set
    external setLength: (this<'tags, 'base>, float) => unit = "length"
    @get
    external getClassification: this<'tags, 'base> => TokenClass.t = "classification"
    @set
    external setClassification: (this<'tags, 'base>, TokenClass.t) => unit = "classification"
    @obj
    external make: (~length: float, ~classification: TokenClass.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ClassificationResult = {
    open ClassificationResult
    type t = t
    type t0 = t
    type tags = [#Ts_ClassificationResult]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ClassificationResult ]
    @get
    external getFinalLexState: this<'tags, 'base> => EndOfLineState.t = "finalLexState"
    @set
    external setFinalLexState: (this<'tags, 'base>, EndOfLineState.t) => unit = "finalLexState"
    @get
    external getEntries: this<'tags, 'base> => array<ClassificationInfo.t> = "entries"
    @set
    external setEntries: (this<'tags, 'base>, array<ClassificationInfo.t>) => unit = "entries"
    @obj
    external make: (~finalLexState: EndOfLineState.t, ~entries: array<ClassificationInfo.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ClassificationType = {
    open ClassificationType
    type t = t
    type t_0 = t
    module Comment = {
      open Comment
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "comment"
    }
    module Identifier = {
      open Identifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "identifier"
    }
    module Keyword = {
      open Keyword
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "keyword"
    }
    module NumericLiteral = {
      open NumericLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "numericLiteral"
    }
    module Operator = {
      open Operator
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "operator"
    }
    module StringLiteral = {
      open StringLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "stringLiteral"
    }
    module RegularExpressionLiteral = {
      open RegularExpressionLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "regularExpressionLiteral"
    }
    module WhiteSpace = {
      open WhiteSpace
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "whiteSpace"
    }
    module Text = {
      open Text
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "text"
    }
    module Punctuation = {
      open Punctuation
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "punctuation"
    }
    module ClassName = {
      open ClassName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "className"
    }
    module EnumName = {
      open EnumName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "enumName"
    }
    module InterfaceName = {
      open InterfaceName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "interfaceName"
    }
    module ModuleName = {
      open ModuleName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "moduleName"
    }
    module TypeParameterName = {
      open TypeParameterName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "typeParameterName"
    }
    module TypeAliasName = {
      open TypeAliasName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "typeAliasName"
    }
    module ParameterName = {
      open ParameterName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "parameterName"
    }
    module DocCommentTagName = {
      open DocCommentTagName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "docCommentTagName"
    }
    module JsxOpenTagName = {
      open JsxOpenTagName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "jsxOpenTagName"
    }
    module JsxCloseTagName = {
      open JsxCloseTagName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "jsxCloseTagName"
    }
    module JsxSelfClosingTagName = {
      open JsxSelfClosingTagName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "jsxSelfClosingTagName"
    }
    module JsxAttribute = {
      open JsxAttribute
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "jsxAttribute"
    }
    module JsxText = {
      open JsxText
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "jsxText"
    }
    module JsxAttributeStringLiteralValue = {
      open JsxAttributeStringLiteralValue
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "jsxAttributeStringLiteralValue"
    }
    module BigintLiteral = {
      open BigintLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationType") @val
      external value: t = "bigintLiteral"
    }
  }
  module ClassificationTypeNames = {
    open ClassificationTypeNames
    type t = t
    type t_0 = t
    module Comment = {
      open Comment
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "comment"
    }
    module Identifier = {
      open Identifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "identifier"
    }
    module Keyword = {
      open Keyword
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "keyword"
    }
    module NumericLiteral = {
      open NumericLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "numericLiteral"
    }
    module BigintLiteral = {
      open BigintLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "bigintLiteral"
    }
    module Operator = {
      open Operator
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "operator"
    }
    module StringLiteral = {
      open StringLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "stringLiteral"
    }
    module WhiteSpace = {
      open WhiteSpace
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "whiteSpace"
    }
    module Text = {
      open Text
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "text"
    }
    module Punctuation = {
      open Punctuation
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "punctuation"
    }
    module ClassName = {
      open ClassName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "className"
    }
    module EnumName = {
      open EnumName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "enumName"
    }
    module InterfaceName = {
      open InterfaceName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "interfaceName"
    }
    module ModuleName = {
      open ModuleName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "moduleName"
    }
    module TypeParameterName = {
      open TypeParameterName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "typeParameterName"
    }
    module TypeAliasName = {
      open TypeAliasName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "typeAliasName"
    }
    module ParameterName = {
      open ParameterName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "parameterName"
    }
    module DocCommentTagName = {
      open DocCommentTagName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "docCommentTagName"
    }
    module JsxOpenTagName = {
      open JsxOpenTagName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "jsxOpenTagName"
    }
    module JsxCloseTagName = {
      open JsxCloseTagName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "jsxCloseTagName"
    }
    module JsxSelfClosingTagName = {
      open JsxSelfClosingTagName
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "jsxSelfClosingTagName"
    }
    module JsxAttribute = {
      open JsxAttribute
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "jsxAttribute"
    }
    module JsxText = {
      open JsxText
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "jsxText"
    }
    module JsxAttributeStringLiteralValue = {
      open JsxAttributeStringLiteralValue
      type t = t
      type t0 = t
      @module("typescript") @scope("ClassificationTypeNames") @val
      external value: t = "jsxAttributeStringLiteralValue"
    }
  }
  module Classifications = {
    open Classifications
    type t = t
    type t0 = t
    type tags = [#Ts_Classifications]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Classifications ]
    @get
    external getSpans: this<'tags, 'base> => array<float> = "spans"
    @set
    external setSpans: (this<'tags, 'base>, array<float>) => unit = "spans"
    @get
    external getEndOfLineState: this<'tags, 'base> => EndOfLineState.t = "endOfLineState"
    @set
    external setEndOfLineState: (this<'tags, 'base>, EndOfLineState.t) => unit = "endOfLineState"
    @obj
    external make: (~spans: array<float>, ~endOfLineState: EndOfLineState.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ClassifiedSpan = {
    open ClassifiedSpan
    type t = t
    type t0 = t
    type tags = [#Ts_ClassifiedSpan]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ClassifiedSpan ]
    @get
    external getTextSpan: this<'tags, 'base> => TextSpan.t = "textSpan"
    @set
    external setTextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "textSpan"
    @get
    external getClassificationType: this<'tags, 'base> => ClassificationTypeNames.t = "classificationType"
    @set
    external setClassificationType: (this<'tags, 'base>, ClassificationTypeNames.t) => unit = "classificationType"
    @obj
    external make: (~textSpan: TextSpan.t, ~classificationType: ClassificationTypeNames.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ClassifiedSpan2020 = {
    open ClassifiedSpan2020
    type t = t
    type t0 = t
    type tags = [#Ts_ClassifiedSpan2020]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ClassifiedSpan2020 ]
    @get
    external getTextSpan: this<'tags, 'base> => TextSpan.t = "textSpan"
    @set
    external setTextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "textSpan"
    @get
    external getClassificationType: this<'tags, 'base> => float = "classificationType"
    @set
    external setClassificationType: (this<'tags, 'base>, float) => unit = "classificationType"
    @obj
    external make: (~textSpan: TextSpan.t, ~classificationType: float) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module Classifier = {
    open Classifier
    type t = t
    type t0 = t
    type tags = [#Ts_Classifier]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Classifier ]
    @send
    external getClassificationsForLine: (this<'tags, 'base>, ~text:string, ~lexState:EndOfLineState.t, ~syntacticClassifierAbsent:bool) => ClassificationResult.t = "getClassificationsForLine"
    @send
    external getEncodedLexicalClassifications: (this<'tags, 'base>, ~text:string, ~endOfLineState:EndOfLineState.t, ~syntacticClassifierAbsent:bool) => Classifications.t = "getEncodedLexicalClassifications"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CodeAction = {
    open CodeAction
    type t = t
    type t0 = t
    type tags = [#Ts_CodeAction]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CodeAction ]
    @get
    external getDescription: this<'tags, 'base> => string = "description"
    @set
    external setDescription: (this<'tags, 'base>, string) => unit = "description"
    @get
    external getChanges: this<'tags, 'base> => array<FileTextChanges.t> = "changes"
    @set
    external setChanges: (this<'tags, 'base>, array<FileTextChanges.t>) => unit = "changes"
    @get
    external getCommands: this<'tags, 'base> => array<CodeActionCommand.t> = "commands"
    @set
    external setCommands: (this<'tags, 'base>, array<CodeActionCommand.t>) => unit = "commands"
    @obj
    external make: (~description: string, ~changes: array<FileTextChanges.t>, ~commands: array<CodeActionCommand.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CodeActionCommand = {
    open CodeActionCommand
    type t = InstallPackageAction.t
    type t0 = t
  }
  module CodeFixAction = {
    open CodeFixAction
    type t = t
    type t0 = t
    type tags = [#Ts_CodeAction | #Ts_CodeFixAction]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CodeFixAction ]
    @get
    external getFixName: this<'tags, 'base> => string = "fixName"
    @set
    external setFixName: (this<'tags, 'base>, string) => unit = "fixName"
    @get
    external getFixId: this<'tags, 'base> => untyped_object = "fixId"
    @set
    external setFixId: (this<'tags, 'base>, untyped_object) => unit = "fixId"
    @get
    external getFixAllDescription: this<'tags, 'base> => string = "fixAllDescription"
    @set
    external setFixAllDescription: (this<'tags, 'base>, string) => unit = "fixAllDescription"
    @obj
    external make: (~fixName: string, ~fixId: untyped_object, ~fixAllDescription: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asCodeAction: t => CodeAction.t = "%identity"
  }
  module Collection = {
    open Collection
    type t<'K> = t<'K>
    type t1<'K> = t<'K>
    type tags<'K> = [#Ts_Collection('K) | #Ts_ReadonlyCollection('K)]
    type tags1<'K> = tags<'K>
    type this<'tags, 'base, 'K> = intf<'tags, 'base> constraint 'tags = [> #Ts_Collection('K) ]
    @send
    external delete: (this<'tags, 'base, 'K>, ~key:'K) => bool = "delete"
    @send
    external clear: this<'tags, 'base, 'K> => unit = "clear"
    external castFrom: this<'tags, 'base, 'K> => t<'K> = "%identity"
    external asReadonlyCollection: t<'K> => ReadonlyCollection.t<'K> = "%identity"
  }
  module ColonToken = {
    open ColonToken
    type t = PunctuationToken.t<SyntaxKind.ColonToken.t>
    type t0 = t
  }
  module CombinedCodeActions = {
    open CombinedCodeActions
    type t = t
    type t0 = t
    type tags = [#Ts_CombinedCodeActions]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CombinedCodeActions ]
    @get
    external getChanges: this<'tags, 'base> => array<FileTextChanges.t> = "changes"
    @set
    external setChanges: (this<'tags, 'base>, array<FileTextChanges.t>) => unit = "changes"
    @get
    external getCommands: this<'tags, 'base> => array<CodeActionCommand.t> = "commands"
    @set
    external setCommands: (this<'tags, 'base>, array<CodeActionCommand.t>) => unit = "commands"
    @obj
    external make: (~changes: array<FileTextChanges.t>, ~commands: array<CodeActionCommand.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CombinedCodeFixScope = {
    open CombinedCodeFixScope
    type t = t
    type t0 = t
    type tags = [#Ts_CombinedCodeFixScope]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CombinedCodeFixScope ]
    @get
    external getType: this<'tags, 'base> => [#file] = "type"
    @set
    external setType: (this<'tags, 'base>, [#file]) => unit = "type"
    @get
    external getFileName: this<'tags, 'base> => string = "fileName"
    @set
    external setFileName: (this<'tags, 'base>, string) => unit = "fileName"
    @obj
    external make: (~\"type": [#file], ~fileName: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CommaListExpression = {
    open CommaListExpression
    type t = t
    type t0 = t
    type tags = [#Ts_CommaListExpression | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CommaListExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.CommaListExpression.t = "kind"
    @get
    external elements: this<'tags, 'base> => NodeArray.t<Expression.t> = "elements"
    @obj
    external make: (~kind: SyntaxKind.CommaListExpression.t, ~elements: NodeArray.t<Expression.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asExpression: t => Expression.t = "%identity"
  }
  module CommentKind = {
    open CommentKind
    type t = Union.t2<SyntaxKind.SingleLineCommentTrivia.t, SyntaxKind.MultiLineCommentTrivia.t>
    type t0 = t
  }
  module CommentRange = {
    open CommentRange
    type t = t
    type t0 = t
    type tags = [#Ts_CommentRange | #Ts_TextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CommentRange ]
    @get
    external getHasTrailingNewLine: this<'tags, 'base> => bool = "hasTrailingNewLine"
    @set
    external setHasTrailingNewLine: (this<'tags, 'base>, bool) => unit = "hasTrailingNewLine"
    @get
    external getKind: this<'tags, 'base> => CommentKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, CommentKind.t) => unit = "kind"
    @obj
    external make: (~hasTrailingNewLine: bool, ~kind: CommentKind.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTextRange: t => TextRange.t = "%identity"
  }
  module CompilerHost = {
    open CompilerHost
    type t = t
    type t0 = t
    type tags = [#Ts_CompilerHost | #Ts_ModuleResolutionHost]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CompilerHost ]
    @send @return(nullable)
    external getSourceFile: (this<'tags, 'base>, ~fileName:string, ~languageVersion:ScriptTarget.t, ~onError:(@uncurry string => unit)=?, ~shouldCreateNewSourceFile:bool=?, unit) => option<SourceFile.t> = "getSourceFile"
    @send @return(nullable)
    external getSourceFileByPath: (this<'tags, 'base>, ~fileName:string, ~path:Path.t, ~languageVersion:ScriptTarget.t, ~onError:(@uncurry string => unit)=?, ~shouldCreateNewSourceFile:bool=?, unit) => option<SourceFile.t> = "getSourceFileByPath"
    @send
    external getCancellationToken: this<'tags, 'base> => CancellationToken.t = "getCancellationToken"
    @send
    external getDefaultLibFileName: (this<'tags, 'base>, ~options:CompilerOptions.t) => string = "getDefaultLibFileName"
    @send
    external getDefaultLibLocation: this<'tags, 'base> => string = "getDefaultLibLocation"
    @get
    external getWriteFile: this<'tags, 'base> => WriteFileCallback.t = "writeFile"
    @set
    external setWriteFile: (this<'tags, 'base>, WriteFileCallback.t) => unit = "writeFile"
    @send
    external getCurrentDirectory: this<'tags, 'base> => string = "getCurrentDirectory"
    @send
    external getCanonicalFileName: (this<'tags, 'base>, ~fileName:string) => string = "getCanonicalFileName"
    @send
    external useCaseSensitiveFileNames: this<'tags, 'base> => bool = "useCaseSensitiveFileNames"
    @send
    external getNewLine: this<'tags, 'base> => string = "getNewLine"
    @send
    external readDirectory: (this<'tags, 'base>, ~rootDir:string, ~extensions:array<string>, ~excludes:undefined<array<string>>, ~includes:array<string>, ~depth:float=?, unit) => array<string> = "readDirectory"
    @send
    external resolveModuleNames: (this<'tags, 'base>, ~moduleNames:array<string>, ~containingFile:string, ~reusedNames:undefined<array<string>>, ~redirectedReference:undefined<ResolvedProjectReference.t>, ~options:CompilerOptions.t, ~containingSourceFile:SourceFile.t=?, unit) => array<undefined<ResolvedModule.t>> = "resolveModuleNames"
    @send @return(nullable)
    external getModuleResolutionCache: this<'tags, 'base> => option<ModuleResolutionCache.t> = "getModuleResolutionCache"
    @send
    external resolveTypeReferenceDirectives: (this<'tags, 'base>, ~typeReferenceDirectiveNames:array<string>, ~containingFile:string, ~redirectedReference:undefined<ResolvedProjectReference.t>, ~options:CompilerOptions.t) => array<undefined<ResolvedTypeReferenceDirective.t>> = "resolveTypeReferenceDirectives"
    @send @return(nullable)
    external getEnvironmentVariable: (this<'tags, 'base>, ~name:string) => option<string> = "getEnvironmentVariable"
    @send
    external createHash: (this<'tags, 'base>, ~data:string) => string = "createHash"
    @send @return(nullable)
    external getParsedCommandLine: (this<'tags, 'base>, ~fileName:string) => option<ParsedCommandLine.t> = "getParsedCommandLine"
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asModuleResolutionHost: t => ModuleResolutionHost.t = "%identity"
  }
  module CompilerOptions = {
    open CompilerOptions
    type t = t
    type t0 = t
    type tags = [#Ts_CompilerOptions]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CompilerOptions ]
    @get
    external getAllowJs: this<'tags, 'base> => bool = "allowJs"
    @set
    external setAllowJs: (this<'tags, 'base>, bool) => unit = "allowJs"
    @get
    external getAllowSyntheticDefaultImports: this<'tags, 'base> => bool = "allowSyntheticDefaultImports"
    @set
    external setAllowSyntheticDefaultImports: (this<'tags, 'base>, bool) => unit = "allowSyntheticDefaultImports"
    @get
    external getAllowUmdGlobalAccess: this<'tags, 'base> => bool = "allowUmdGlobalAccess"
    @set
    external setAllowUmdGlobalAccess: (this<'tags, 'base>, bool) => unit = "allowUmdGlobalAccess"
    @get
    external getAllowUnreachableCode: this<'tags, 'base> => bool = "allowUnreachableCode"
    @set
    external setAllowUnreachableCode: (this<'tags, 'base>, bool) => unit = "allowUnreachableCode"
    @get
    external getAllowUnusedLabels: this<'tags, 'base> => bool = "allowUnusedLabels"
    @set
    external setAllowUnusedLabels: (this<'tags, 'base>, bool) => unit = "allowUnusedLabels"
    @get
    external getAlwaysStrict: this<'tags, 'base> => bool = "alwaysStrict"
    @set
    external setAlwaysStrict: (this<'tags, 'base>, bool) => unit = "alwaysStrict"
    @get
    external getBaseUrl: this<'tags, 'base> => string = "baseUrl"
    @set
    external setBaseUrl: (this<'tags, 'base>, string) => unit = "baseUrl"
    @get
    external getCharset: this<'tags, 'base> => string = "charset"
    @set
    external setCharset: (this<'tags, 'base>, string) => unit = "charset"
    @get
    external getCheckJs: this<'tags, 'base> => bool = "checkJs"
    @set
    external setCheckJs: (this<'tags, 'base>, bool) => unit = "checkJs"
    @get
    external getDeclaration: this<'tags, 'base> => bool = "declaration"
    @set
    external setDeclaration: (this<'tags, 'base>, bool) => unit = "declaration"
    @get
    external getDeclarationMap: this<'tags, 'base> => bool = "declarationMap"
    @set
    external setDeclarationMap: (this<'tags, 'base>, bool) => unit = "declarationMap"
    @get
    external getEmitDeclarationOnly: this<'tags, 'base> => bool = "emitDeclarationOnly"
    @set
    external setEmitDeclarationOnly: (this<'tags, 'base>, bool) => unit = "emitDeclarationOnly"
    @get
    external getDeclarationDir: this<'tags, 'base> => string = "declarationDir"
    @set
    external setDeclarationDir: (this<'tags, 'base>, string) => unit = "declarationDir"
    @get
    external getDisableSizeLimit: this<'tags, 'base> => bool = "disableSizeLimit"
    @set
    external setDisableSizeLimit: (this<'tags, 'base>, bool) => unit = "disableSizeLimit"
    @get
    external getDisableSourceOfProjectReferenceRedirect: this<'tags, 'base> => bool = "disableSourceOfProjectReferenceRedirect"
    @set
    external setDisableSourceOfProjectReferenceRedirect: (this<'tags, 'base>, bool) => unit = "disableSourceOfProjectReferenceRedirect"
    @get
    external getDisableSolutionSearching: this<'tags, 'base> => bool = "disableSolutionSearching"
    @set
    external setDisableSolutionSearching: (this<'tags, 'base>, bool) => unit = "disableSolutionSearching"
    @get
    external getDisableReferencedProjectLoad: this<'tags, 'base> => bool = "disableReferencedProjectLoad"
    @set
    external setDisableReferencedProjectLoad: (this<'tags, 'base>, bool) => unit = "disableReferencedProjectLoad"
    @get
    external getDownlevelIteration: this<'tags, 'base> => bool = "downlevelIteration"
    @set
    external setDownlevelIteration: (this<'tags, 'base>, bool) => unit = "downlevelIteration"
    @get
    external getEmitBOM: this<'tags, 'base> => bool = "emitBOM"
    @set
    external setEmitBOM: (this<'tags, 'base>, bool) => unit = "emitBOM"
    @get
    external getEmitDecoratorMetadata: this<'tags, 'base> => bool = "emitDecoratorMetadata"
    @set
    external setEmitDecoratorMetadata: (this<'tags, 'base>, bool) => unit = "emitDecoratorMetadata"
    @get
    external getExactOptionalPropertyTypes: this<'tags, 'base> => bool = "exactOptionalPropertyTypes"
    @set
    external setExactOptionalPropertyTypes: (this<'tags, 'base>, bool) => unit = "exactOptionalPropertyTypes"
    @get
    external getExperimentalDecorators: this<'tags, 'base> => bool = "experimentalDecorators"
    @set
    external setExperimentalDecorators: (this<'tags, 'base>, bool) => unit = "experimentalDecorators"
    @get
    external getForceConsistentCasingInFileNames: this<'tags, 'base> => bool = "forceConsistentCasingInFileNames"
    @set
    external setForceConsistentCasingInFileNames: (this<'tags, 'base>, bool) => unit = "forceConsistentCasingInFileNames"
    @get
    external getImportHelpers: this<'tags, 'base> => bool = "importHelpers"
    @set
    external setImportHelpers: (this<'tags, 'base>, bool) => unit = "importHelpers"
    @get
    external getImportsNotUsedAsValues: this<'tags, 'base> => ImportsNotUsedAsValues.t = "importsNotUsedAsValues"
    @set
    external setImportsNotUsedAsValues: (this<'tags, 'base>, ImportsNotUsedAsValues.t) => unit = "importsNotUsedAsValues"
    @get
    external getInlineSourceMap: this<'tags, 'base> => bool = "inlineSourceMap"
    @set
    external setInlineSourceMap: (this<'tags, 'base>, bool) => unit = "inlineSourceMap"
    @get
    external getInlineSources: this<'tags, 'base> => bool = "inlineSources"
    @set
    external setInlineSources: (this<'tags, 'base>, bool) => unit = "inlineSources"
    @get
    external getIsolatedModules: this<'tags, 'base> => bool = "isolatedModules"
    @set
    external setIsolatedModules: (this<'tags, 'base>, bool) => unit = "isolatedModules"
    @get
    external getJsx: this<'tags, 'base> => JsxEmit.t = "jsx"
    @set
    external setJsx: (this<'tags, 'base>, JsxEmit.t) => unit = "jsx"
    @get
    external getKeyofStringsOnly: this<'tags, 'base> => bool = "keyofStringsOnly"
    @set
    external setKeyofStringsOnly: (this<'tags, 'base>, bool) => unit = "keyofStringsOnly"
    @get
    external getLib: this<'tags, 'base> => array<string> = "lib"
    @set
    external setLib: (this<'tags, 'base>, array<string>) => unit = "lib"
    @get
    external getLocale: this<'tags, 'base> => string = "locale"
    @set
    external setLocale: (this<'tags, 'base>, string) => unit = "locale"
    @get
    external getMapRoot: this<'tags, 'base> => string = "mapRoot"
    @set
    external setMapRoot: (this<'tags, 'base>, string) => unit = "mapRoot"
    @get
    external getMaxNodeModuleJsDepth: this<'tags, 'base> => float = "maxNodeModuleJsDepth"
    @set
    external setMaxNodeModuleJsDepth: (this<'tags, 'base>, float) => unit = "maxNodeModuleJsDepth"
    @get
    external getModule: this<'tags, 'base> => ModuleKind.t = "module"
    @set
    external setModule: (this<'tags, 'base>, ModuleKind.t) => unit = "module"
    @get
    external getModuleResolution: this<'tags, 'base> => ModuleResolutionKind.t = "moduleResolution"
    @set
    external setModuleResolution: (this<'tags, 'base>, ModuleResolutionKind.t) => unit = "moduleResolution"
    @get
    external getNewLine: this<'tags, 'base> => NewLineKind.t = "newLine"
    @set
    external setNewLine: (this<'tags, 'base>, NewLineKind.t) => unit = "newLine"
    @get
    external getNoEmit: this<'tags, 'base> => bool = "noEmit"
    @set
    external setNoEmit: (this<'tags, 'base>, bool) => unit = "noEmit"
    @get
    external getNoEmitHelpers: this<'tags, 'base> => bool = "noEmitHelpers"
    @set
    external setNoEmitHelpers: (this<'tags, 'base>, bool) => unit = "noEmitHelpers"
    @get
    external getNoEmitOnError: this<'tags, 'base> => bool = "noEmitOnError"
    @set
    external setNoEmitOnError: (this<'tags, 'base>, bool) => unit = "noEmitOnError"
    @get
    external getNoErrorTruncation: this<'tags, 'base> => bool = "noErrorTruncation"
    @set
    external setNoErrorTruncation: (this<'tags, 'base>, bool) => unit = "noErrorTruncation"
    @get
    external getNoFallthroughCasesInSwitch: this<'tags, 'base> => bool = "noFallthroughCasesInSwitch"
    @set
    external setNoFallthroughCasesInSwitch: (this<'tags, 'base>, bool) => unit = "noFallthroughCasesInSwitch"
    @get
    external getNoImplicitAny: this<'tags, 'base> => bool = "noImplicitAny"
    @set
    external setNoImplicitAny: (this<'tags, 'base>, bool) => unit = "noImplicitAny"
    @get
    external getNoImplicitReturns: this<'tags, 'base> => bool = "noImplicitReturns"
    @set
    external setNoImplicitReturns: (this<'tags, 'base>, bool) => unit = "noImplicitReturns"
    @get
    external getNoImplicitThis: this<'tags, 'base> => bool = "noImplicitThis"
    @set
    external setNoImplicitThis: (this<'tags, 'base>, bool) => unit = "noImplicitThis"
    @get
    external getNoStrictGenericChecks: this<'tags, 'base> => bool = "noStrictGenericChecks"
    @set
    external setNoStrictGenericChecks: (this<'tags, 'base>, bool) => unit = "noStrictGenericChecks"
    @get
    external getNoUnusedLocals: this<'tags, 'base> => bool = "noUnusedLocals"
    @set
    external setNoUnusedLocals: (this<'tags, 'base>, bool) => unit = "noUnusedLocals"
    @get
    external getNoUnusedParameters: this<'tags, 'base> => bool = "noUnusedParameters"
    @set
    external setNoUnusedParameters: (this<'tags, 'base>, bool) => unit = "noUnusedParameters"
    @get
    external getNoImplicitUseStrict: this<'tags, 'base> => bool = "noImplicitUseStrict"
    @set
    external setNoImplicitUseStrict: (this<'tags, 'base>, bool) => unit = "noImplicitUseStrict"
    @get
    external getNoPropertyAccessFromIndexSignature: this<'tags, 'base> => bool = "noPropertyAccessFromIndexSignature"
    @set
    external setNoPropertyAccessFromIndexSignature: (this<'tags, 'base>, bool) => unit = "noPropertyAccessFromIndexSignature"
    @get
    external getAssumeChangesOnlyAffectDirectDependencies: this<'tags, 'base> => bool = "assumeChangesOnlyAffectDirectDependencies"
    @set
    external setAssumeChangesOnlyAffectDirectDependencies: (this<'tags, 'base>, bool) => unit = "assumeChangesOnlyAffectDirectDependencies"
    @get
    external getNoLib: this<'tags, 'base> => bool = "noLib"
    @set
    external setNoLib: (this<'tags, 'base>, bool) => unit = "noLib"
    @get
    external getNoResolve: this<'tags, 'base> => bool = "noResolve"
    @set
    external setNoResolve: (this<'tags, 'base>, bool) => unit = "noResolve"
    @get
    external getNoUncheckedIndexedAccess: this<'tags, 'base> => bool = "noUncheckedIndexedAccess"
    @set
    external setNoUncheckedIndexedAccess: (this<'tags, 'base>, bool) => unit = "noUncheckedIndexedAccess"
    @get
    external getOut: this<'tags, 'base> => string = "out"
    @set
    external setOut: (this<'tags, 'base>, string) => unit = "out"
    @get
    external getOutDir: this<'tags, 'base> => string = "outDir"
    @set
    external setOutDir: (this<'tags, 'base>, string) => unit = "outDir"
    @get
    external getOutFile: this<'tags, 'base> => string = "outFile"
    @set
    external setOutFile: (this<'tags, 'base>, string) => unit = "outFile"
    @get
    external getPaths: this<'tags, 'base> => MapLike.t<array<string>> = "paths"
    @set
    external setPaths: (this<'tags, 'base>, MapLike.t<array<string>>) => unit = "paths"
    @get
    external getPreserveConstEnums: this<'tags, 'base> => bool = "preserveConstEnums"
    @set
    external setPreserveConstEnums: (this<'tags, 'base>, bool) => unit = "preserveConstEnums"
    @get
    external getNoImplicitOverride: this<'tags, 'base> => bool = "noImplicitOverride"
    @set
    external setNoImplicitOverride: (this<'tags, 'base>, bool) => unit = "noImplicitOverride"
    @get
    external getPreserveSymlinks: this<'tags, 'base> => bool = "preserveSymlinks"
    @set
    external setPreserveSymlinks: (this<'tags, 'base>, bool) => unit = "preserveSymlinks"
    @get
    external getPreserveValueImports: this<'tags, 'base> => bool = "preserveValueImports"
    @set
    external setPreserveValueImports: (this<'tags, 'base>, bool) => unit = "preserveValueImports"
    @get
    external getProject: this<'tags, 'base> => string = "project"
    @set
    external setProject: (this<'tags, 'base>, string) => unit = "project"
    @get
    external getReactNamespace: this<'tags, 'base> => string = "reactNamespace"
    @set
    external setReactNamespace: (this<'tags, 'base>, string) => unit = "reactNamespace"
    @get
    external getJsxFactory: this<'tags, 'base> => string = "jsxFactory"
    @set
    external setJsxFactory: (this<'tags, 'base>, string) => unit = "jsxFactory"
    @get
    external getJsxFragmentFactory: this<'tags, 'base> => string = "jsxFragmentFactory"
    @set
    external setJsxFragmentFactory: (this<'tags, 'base>, string) => unit = "jsxFragmentFactory"
    @get
    external getJsxImportSource: this<'tags, 'base> => string = "jsxImportSource"
    @set
    external setJsxImportSource: (this<'tags, 'base>, string) => unit = "jsxImportSource"
    @get
    external getComposite: this<'tags, 'base> => bool = "composite"
    @set
    external setComposite: (this<'tags, 'base>, bool) => unit = "composite"
    @get
    external getIncremental: this<'tags, 'base> => bool = "incremental"
    @set
    external setIncremental: (this<'tags, 'base>, bool) => unit = "incremental"
    @get
    external getTsBuildInfoFile: this<'tags, 'base> => string = "tsBuildInfoFile"
    @set
    external setTsBuildInfoFile: (this<'tags, 'base>, string) => unit = "tsBuildInfoFile"
    @get
    external getRemoveComments: this<'tags, 'base> => bool = "removeComments"
    @set
    external setRemoveComments: (this<'tags, 'base>, bool) => unit = "removeComments"
    @get
    external getRootDir: this<'tags, 'base> => string = "rootDir"
    @set
    external setRootDir: (this<'tags, 'base>, string) => unit = "rootDir"
    @get
    external getRootDirs: this<'tags, 'base> => array<string> = "rootDirs"
    @set
    external setRootDirs: (this<'tags, 'base>, array<string>) => unit = "rootDirs"
    @get
    external getSkipLibCheck: this<'tags, 'base> => bool = "skipLibCheck"
    @set
    external setSkipLibCheck: (this<'tags, 'base>, bool) => unit = "skipLibCheck"
    @get
    external getSkipDefaultLibCheck: this<'tags, 'base> => bool = "skipDefaultLibCheck"
    @set
    external setSkipDefaultLibCheck: (this<'tags, 'base>, bool) => unit = "skipDefaultLibCheck"
    @get
    external getSourceMap: this<'tags, 'base> => bool = "sourceMap"
    @set
    external setSourceMap: (this<'tags, 'base>, bool) => unit = "sourceMap"
    @get
    external getSourceRoot: this<'tags, 'base> => string = "sourceRoot"
    @set
    external setSourceRoot: (this<'tags, 'base>, string) => unit = "sourceRoot"
    @get
    external getStrict: this<'tags, 'base> => bool = "strict"
    @set
    external setStrict: (this<'tags, 'base>, bool) => unit = "strict"
    @get
    external getStrictFunctionTypes: this<'tags, 'base> => bool = "strictFunctionTypes"
    @set
    external setStrictFunctionTypes: (this<'tags, 'base>, bool) => unit = "strictFunctionTypes"
    @get
    external getStrictBindCallApply: this<'tags, 'base> => bool = "strictBindCallApply"
    @set
    external setStrictBindCallApply: (this<'tags, 'base>, bool) => unit = "strictBindCallApply"
    @get
    external getStrictNullChecks: this<'tags, 'base> => bool = "strictNullChecks"
    @set
    external setStrictNullChecks: (this<'tags, 'base>, bool) => unit = "strictNullChecks"
    @get
    external getStrictPropertyInitialization: this<'tags, 'base> => bool = "strictPropertyInitialization"
    @set
    external setStrictPropertyInitialization: (this<'tags, 'base>, bool) => unit = "strictPropertyInitialization"
    @get
    external getStripInternal: this<'tags, 'base> => bool = "stripInternal"
    @set
    external setStripInternal: (this<'tags, 'base>, bool) => unit = "stripInternal"
    @get
    external getSuppressExcessPropertyErrors: this<'tags, 'base> => bool = "suppressExcessPropertyErrors"
    @set
    external setSuppressExcessPropertyErrors: (this<'tags, 'base>, bool) => unit = "suppressExcessPropertyErrors"
    @get
    external getSuppressImplicitAnyIndexErrors: this<'tags, 'base> => bool = "suppressImplicitAnyIndexErrors"
    @set
    external setSuppressImplicitAnyIndexErrors: (this<'tags, 'base>, bool) => unit = "suppressImplicitAnyIndexErrors"
    @get
    external getTarget: this<'tags, 'base> => ScriptTarget.t = "target"
    @set
    external setTarget: (this<'tags, 'base>, ScriptTarget.t) => unit = "target"
    @get
    external getTraceResolution: this<'tags, 'base> => bool = "traceResolution"
    @set
    external setTraceResolution: (this<'tags, 'base>, bool) => unit = "traceResolution"
    @get
    external getUseUnknownInCatchVariables: this<'tags, 'base> => bool = "useUnknownInCatchVariables"
    @set
    external setUseUnknownInCatchVariables: (this<'tags, 'base>, bool) => unit = "useUnknownInCatchVariables"
    @get
    external getResolveJsonModule: this<'tags, 'base> => bool = "resolveJsonModule"
    @set
    external setResolveJsonModule: (this<'tags, 'base>, bool) => unit = "resolveJsonModule"
    @get
    external getTypes: this<'tags, 'base> => array<string> = "types"
    @set
    external setTypes: (this<'tags, 'base>, array<string>) => unit = "types"
    @get
    external getTypeRoots: this<'tags, 'base> => array<string> = "typeRoots"
    @set
    external setTypeRoots: (this<'tags, 'base>, array<string>) => unit = "typeRoots"
    @get
    external getEsModuleInterop: this<'tags, 'base> => bool = "esModuleInterop"
    @set
    external setEsModuleInterop: (this<'tags, 'base>, bool) => unit = "esModuleInterop"
    @get
    external getUseDefineForClassFields: this<'tags, 'base> => bool = "useDefineForClassFields"
    @set
    external setUseDefineForClassFields: (this<'tags, 'base>, bool) => unit = "useDefineForClassFields"
    @get_index @return(nullable)
    external get: (this<'tags, 'base>, string) => option<Union.t2<CompilerOptionsValue.t, TsConfigSourceFile.t>> = ""
    @set_index
    external set: (this<'tags, 'base>, string, undefined<Union.t2<CompilerOptionsValue.t, TsConfigSourceFile.t>>) => unit = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CompilerOptionsValue = {
    open CompilerOptionsValue
    type t = nullable<Union.t8<string, float, bool, array<Union.t2<string, float>>, array<string>, MapLike.t<array<string>>, array<PluginImport.t>, array<ProjectReference.t>>>
    type t0 = t
  }
  module CompletionEntry = {
    open CompletionEntry
    type t = t
    type t0 = t
    type tags = [#Ts_CompletionEntry]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CompletionEntry ]
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @get
    external getKind: this<'tags, 'base> => ScriptElementKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, ScriptElementKind.t) => unit = "kind"
    @get
    external getKindModifiers: this<'tags, 'base> => string = "kindModifiers"
    @set
    external setKindModifiers: (this<'tags, 'base>, string) => unit = "kindModifiers"
    @get
    external getSortText: this<'tags, 'base> => string = "sortText"
    @set
    external setSortText: (this<'tags, 'base>, string) => unit = "sortText"
    @get
    external getInsertText: this<'tags, 'base> => string = "insertText"
    @set
    external setInsertText: (this<'tags, 'base>, string) => unit = "insertText"
    @get
    external getIsSnippet: this<'tags, 'base> => \"true" = "isSnippet"
    @set
    external setIsSnippet: (this<'tags, 'base>, \"true") => unit = "isSnippet"
    @get
    external getReplacementSpan: this<'tags, 'base> => TextSpan.t = "replacementSpan"
    @set
    external setReplacementSpan: (this<'tags, 'base>, TextSpan.t) => unit = "replacementSpan"
    @get
    external getHasAction: this<'tags, 'base> => \"true" = "hasAction"
    @set
    external setHasAction: (this<'tags, 'base>, \"true") => unit = "hasAction"
    @get
    external getSource: this<'tags, 'base> => string = "source"
    @set
    external setSource: (this<'tags, 'base>, string) => unit = "source"
    @get
    external getSourceDisplay: this<'tags, 'base> => array<SymbolDisplayPart.t> = "sourceDisplay"
    @set
    external setSourceDisplay: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "sourceDisplay"
    @get
    external getIsRecommended: this<'tags, 'base> => \"true" = "isRecommended"
    @set
    external setIsRecommended: (this<'tags, 'base>, \"true") => unit = "isRecommended"
    @get
    external getIsFromUncheckedFile: this<'tags, 'base> => \"true" = "isFromUncheckedFile"
    @set
    external setIsFromUncheckedFile: (this<'tags, 'base>, \"true") => unit = "isFromUncheckedFile"
    @get
    external getIsPackageJsonImport: this<'tags, 'base> => \"true" = "isPackageJsonImport"
    @set
    external setIsPackageJsonImport: (this<'tags, 'base>, \"true") => unit = "isPackageJsonImport"
    @get
    external getIsImportStatementCompletion: this<'tags, 'base> => \"true" = "isImportStatementCompletion"
    @set
    external setIsImportStatementCompletion: (this<'tags, 'base>, \"true") => unit = "isImportStatementCompletion"
    @get
    external getData: this<'tags, 'base> => CompletionEntryData.t = "data"
    @set
    external setData: (this<'tags, 'base>, CompletionEntryData.t) => unit = "data"
    @obj
    external make: (~name: string, ~kind: ScriptElementKind.t, ~kindModifiers: string, ~sortText: string, ~insertText: string, ~isSnippet: \"true", ~replacementSpan: TextSpan.t, ~hasAction: \"true", ~source: string, ~sourceDisplay: array<SymbolDisplayPart.t>, ~isRecommended: \"true", ~isFromUncheckedFile: \"true", ~isPackageJsonImport: \"true", ~isImportStatementCompletion: \"true", ~data: CompletionEntryData.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CompletionEntryData = {
    open CompletionEntryData
    type t = Union.t2<CompletionEntryDataUnresolved.t, CompletionEntryDataResolved.t>
    type t0 = t
  }
  module CompletionEntryDataAutoImport = {
    open CompletionEntryDataAutoImport
    type t = t
    type t0 = t
    type tags = [#Ts_CompletionEntryDataAutoImport]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CompletionEntryDataAutoImport ]
    @get
    external getExportName: this<'tags, 'base> => string = "exportName"
    @set
    external setExportName: (this<'tags, 'base>, string) => unit = "exportName"
    @get
    external getModuleSpecifier: this<'tags, 'base> => string = "moduleSpecifier"
    @set
    external setModuleSpecifier: (this<'tags, 'base>, string) => unit = "moduleSpecifier"
    @get
    external getFileName: this<'tags, 'base> => string = "fileName"
    @set
    external setFileName: (this<'tags, 'base>, string) => unit = "fileName"
    @get
    external getAmbientModuleName: this<'tags, 'base> => string = "ambientModuleName"
    @set
    external setAmbientModuleName: (this<'tags, 'base>, string) => unit = "ambientModuleName"
    @get
    external getIsPackageJsonImport: this<'tags, 'base> => \"true" = "isPackageJsonImport"
    @set
    external setIsPackageJsonImport: (this<'tags, 'base>, \"true") => unit = "isPackageJsonImport"
    @obj
    external make: (~exportName: string, ~moduleSpecifier: string, ~fileName: string, ~ambientModuleName: string, ~isPackageJsonImport: \"true") => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CompletionEntryDataResolved = {
    open CompletionEntryDataResolved
    type t = t
    type t0 = t
    type tags = [#Ts_CompletionEntryDataAutoImport | #Ts_CompletionEntryDataResolved]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CompletionEntryDataResolved ]
    @get
    external getModuleSpecifier: this<'tags, 'base> => string = "moduleSpecifier"
    @set
    external setModuleSpecifier: (this<'tags, 'base>, string) => unit = "moduleSpecifier"
    @obj
    external make: ~moduleSpecifier: string => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asCompletionEntryDataAutoImport: t => CompletionEntryDataAutoImport.t = "%identity"
  }
  module CompletionEntryDataUnresolved = {
    open CompletionEntryDataUnresolved
    type t = t
    type t0 = t
    type tags = [#Ts_CompletionEntryDataAutoImport | #Ts_CompletionEntryDataUnresolved]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CompletionEntryDataUnresolved ]
    @get
    external getExportMapKey: this<'tags, 'base> => string = "exportMapKey"
    @set
    external setExportMapKey: (this<'tags, 'base>, string) => unit = "exportMapKey"
    @obj
    external make: ~exportMapKey: string => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asCompletionEntryDataAutoImport: t => CompletionEntryDataAutoImport.t = "%identity"
  }
  module CompletionEntryDetails = {
    open CompletionEntryDetails
    type t = t
    type t0 = t
    type tags = [#Ts_CompletionEntryDetails]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CompletionEntryDetails ]
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @get
    external getKind: this<'tags, 'base> => ScriptElementKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, ScriptElementKind.t) => unit = "kind"
    @get
    external getKindModifiers: this<'tags, 'base> => string = "kindModifiers"
    @set
    external setKindModifiers: (this<'tags, 'base>, string) => unit = "kindModifiers"
    @get
    external getDisplayParts: this<'tags, 'base> => array<SymbolDisplayPart.t> = "displayParts"
    @set
    external setDisplayParts: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "displayParts"
    @get
    external getDocumentation: this<'tags, 'base> => array<SymbolDisplayPart.t> = "documentation"
    @set
    external setDocumentation: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "documentation"
    @get
    external getTags: this<'tags, 'base> => array<JSDocTagInfo.t> = "tags"
    @set
    external setTags: (this<'tags, 'base>, array<JSDocTagInfo.t>) => unit = "tags"
    @get
    external getCodeActions: this<'tags, 'base> => array<CodeAction.t> = "codeActions"
    @set
    external setCodeActions: (this<'tags, 'base>, array<CodeAction.t>) => unit = "codeActions"
    @get
    external getSource: this<'tags, 'base> => array<SymbolDisplayPart.t> = "source"
    @set
    external setSource: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "source"
    @get
    external getSourceDisplay: this<'tags, 'base> => array<SymbolDisplayPart.t> = "sourceDisplay"
    @set
    external setSourceDisplay: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "sourceDisplay"
    @obj
    external make: (~name: string, ~kind: ScriptElementKind.t, ~kindModifiers: string, ~displayParts: array<SymbolDisplayPart.t>, ~documentation: array<SymbolDisplayPart.t>, ~tags: array<JSDocTagInfo.t>, ~codeActions: array<CodeAction.t>, ~source: array<SymbolDisplayPart.t>, ~sourceDisplay: array<SymbolDisplayPart.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CompletionInfo = {
    open CompletionInfo
    type t = t
    type t0 = t
    type tags = [#Ts_CompletionInfo]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CompletionInfo ]
    @get
    external getIsGlobalCompletion: this<'tags, 'base> => bool = "isGlobalCompletion"
    @set
    external setIsGlobalCompletion: (this<'tags, 'base>, bool) => unit = "isGlobalCompletion"
    @get
    external getIsMemberCompletion: this<'tags, 'base> => bool = "isMemberCompletion"
    @set
    external setIsMemberCompletion: (this<'tags, 'base>, bool) => unit = "isMemberCompletion"
    @get
    external getOptionalReplacementSpan: this<'tags, 'base> => TextSpan.t = "optionalReplacementSpan"
    @set
    external setOptionalReplacementSpan: (this<'tags, 'base>, TextSpan.t) => unit = "optionalReplacementSpan"
    @get
    external getIsNewIdentifierLocation: this<'tags, 'base> => bool = "isNewIdentifierLocation"
    @set
    external setIsNewIdentifierLocation: (this<'tags, 'base>, bool) => unit = "isNewIdentifierLocation"
    @get
    external getIsIncomplete: this<'tags, 'base> => \"true" = "isIncomplete"
    @set
    external setIsIncomplete: (this<'tags, 'base>, \"true") => unit = "isIncomplete"
    @get
    external getEntries: this<'tags, 'base> => array<CompletionEntry.t> = "entries"
    @set
    external setEntries: (this<'tags, 'base>, array<CompletionEntry.t>) => unit = "entries"
    @obj
    external make: (~isGlobalCompletion: bool, ~isMemberCompletion: bool, ~optionalReplacementSpan: TextSpan.t, ~isNewIdentifierLocation: bool, ~isIncomplete: \"true", ~entries: array<CompletionEntry.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CompletionTriggerKind = {
    open CompletionTriggerKind
    type t = t
    type t_0 = t
    module Invoked = {
      open Invoked
      type t = t
      type t0 = t
      @module("typescript") @scope("CompletionTriggerKind") @val
      external value: t = "Invoked"
    }
    module TriggerCharacter = {
      open TriggerCharacter
      type t = t
      type t0 = t
      @module("typescript") @scope("CompletionTriggerKind") @val
      external value: t = "TriggerCharacter"
    }
    module TriggerForIncompleteCompletions = {
      open TriggerForIncompleteCompletions
      type t = t
      type t0 = t
      @module("typescript") @scope("CompletionTriggerKind") @val
      external value: t = "TriggerForIncompleteCompletions"
    }
  }
  module CompletionsTriggerCharacter = {
    open CompletionsTriggerCharacter
    type t = Union.t8<[#"."], [#"\""], [#"'"], [#"`"], [#"/"], [#"@"], [#"<"], Union.t2<[#"#"], [#" "]>>
    type t0 = t
  }
  module CompoundAssignmentOperator = {
    open CompoundAssignmentOperator
    type t = Union.t8<SyntaxKind.PlusEqualsToken.t, SyntaxKind.MinusEqualsToken.t, SyntaxKind.AsteriskAsteriskEqualsToken.t, SyntaxKind.AsteriskEqualsToken.t, SyntaxKind.SlashEqualsToken.t, SyntaxKind.PercentEqualsToken.t, SyntaxKind.AmpersandEqualsToken.t, Union.t8<SyntaxKind.BarEqualsToken.t, SyntaxKind.CaretEqualsToken.t, SyntaxKind.LessThanLessThanEqualsToken.t, SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken.t, SyntaxKind.GreaterThanGreaterThanEqualsToken.t, SyntaxKind.BarBarEqualsToken.t, SyntaxKind.AmpersandAmpersandEqualsToken.t, SyntaxKind.QuestionQuestionEqualsToken.t>>
    type t0 = t
  }
  module ComputedPropertyName = {
    open ComputedPropertyName
    type t = t
    type t0 = t
    type tags = [#Ts_ComputedPropertyName | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ComputedPropertyName ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ComputedPropertyName.t = "kind"
    @get
    external parent: this<'tags, 'base> => Declaration.t = "parent"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.ComputedPropertyName.t, ~parent: Declaration.t, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module ConciseBody = {
    open ConciseBody
    type t = Union.t2<FunctionBody.t, Expression.t>
    type t0 = t
  }
  module ConditionalExpression = {
    open ConditionalExpression
    type t = t
    type t0 = t
    type tags = [#Ts_ConditionalExpression | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ConditionalExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ConditionalExpression.t = "kind"
    @get
    external condition: this<'tags, 'base> => Expression.t = "condition"
    @get
    external questionToken: this<'tags, 'base> => QuestionToken.t = "questionToken"
    @get
    external whenTrue: this<'tags, 'base> => Expression.t = "whenTrue"
    @get
    external colonToken: this<'tags, 'base> => ColonToken.t = "colonToken"
    @get
    external whenFalse: this<'tags, 'base> => Expression.t = "whenFalse"
    @obj
    external make: (~kind: SyntaxKind.ConditionalExpression.t, ~condition: Expression.t, ~questionToken: QuestionToken.t, ~whenTrue: Expression.t, ~colonToken: ColonToken.t, ~whenFalse: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asExpression: t => Expression.t = "%identity"
  }
  module ConditionalRoot = {
    open ConditionalRoot
    type t = t
    type t0 = t
    type tags = [#Ts_ConditionalRoot]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ConditionalRoot ]
    @get
    external getNode: this<'tags, 'base> => ConditionalTypeNode.t = "node"
    @set
    external setNode: (this<'tags, 'base>, ConditionalTypeNode.t) => unit = "node"
    @get
    external getCheckType: this<'tags, 'base> => Type.t = "checkType"
    @set
    external setCheckType: (this<'tags, 'base>, Type.t) => unit = "checkType"
    @get
    external getExtendsType: this<'tags, 'base> => Type.t = "extendsType"
    @set
    external setExtendsType: (this<'tags, 'base>, Type.t) => unit = "extendsType"
    @get
    external getIsDistributive: this<'tags, 'base> => bool = "isDistributive"
    @set
    external setIsDistributive: (this<'tags, 'base>, bool) => unit = "isDistributive"
    @get
    external getInferTypeParameters: this<'tags, 'base> => array<TypeParameter.t> = "inferTypeParameters"
    @set
    external setInferTypeParameters: (this<'tags, 'base>, array<TypeParameter.t>) => unit = "inferTypeParameters"
    @get
    external getOuterTypeParameters: this<'tags, 'base> => array<TypeParameter.t> = "outerTypeParameters"
    @set
    external setOuterTypeParameters: (this<'tags, 'base>, array<TypeParameter.t>) => unit = "outerTypeParameters"
    @get
    external getInstantiations: this<'tags, 'base> => Map.t<Type.t> = "instantiations"
    @set
    external setInstantiations: (this<'tags, 'base>, Map.t<Type.t>) => unit = "instantiations"
    @get
    external getAliasSymbol: this<'tags, 'base> => Symbol.t = "aliasSymbol"
    @set
    external setAliasSymbol: (this<'tags, 'base>, Symbol.t) => unit = "aliasSymbol"
    @get
    external getAliasTypeArguments: this<'tags, 'base> => array<Type.t> = "aliasTypeArguments"
    @set
    external setAliasTypeArguments: (this<'tags, 'base>, array<Type.t>) => unit = "aliasTypeArguments"
    @obj
    external make: (~node: ConditionalTypeNode.t, ~checkType: Type.t, ~extendsType: Type.t, ~isDistributive: bool, ~inferTypeParameters: array<TypeParameter.t>, ~outerTypeParameters: array<TypeParameter.t>, ~instantiations: Map.t<Type.t>, ~aliasSymbol: Symbol.t, ~aliasTypeArguments: array<Type.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ConditionalType = {
    open ConditionalType
    type t = t
    type t0 = t
    type tags = [#Ts_ConditionalType | #Ts_InstantiableType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ConditionalType ]
    @get
    external getRoot: this<'tags, 'base> => ConditionalRoot.t = "root"
    @set
    external setRoot: (this<'tags, 'base>, ConditionalRoot.t) => unit = "root"
    @get
    external getCheckType: this<'tags, 'base> => Type.t = "checkType"
    @set
    external setCheckType: (this<'tags, 'base>, Type.t) => unit = "checkType"
    @get
    external getExtendsType: this<'tags, 'base> => Type.t = "extendsType"
    @set
    external setExtendsType: (this<'tags, 'base>, Type.t) => unit = "extendsType"
    @get
    external getResolvedTrueType: this<'tags, 'base> => Type.t = "resolvedTrueType"
    @set
    external setResolvedTrueType: (this<'tags, 'base>, Type.t) => unit = "resolvedTrueType"
    @get
    external getResolvedFalseType: this<'tags, 'base> => Type.t = "resolvedFalseType"
    @set
    external setResolvedFalseType: (this<'tags, 'base>, Type.t) => unit = "resolvedFalseType"
    @obj
    external make: (~root: ConditionalRoot.t, ~checkType: Type.t, ~extendsType: Type.t, ~resolvedTrueType: Type.t, ~resolvedFalseType: Type.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asInstantiableType: t => InstantiableType.t = "%identity"
  }
  module ConditionalTypeNode = {
    open ConditionalTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_ConditionalTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ConditionalTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ConditionalType.t = "kind"
    @get
    external checkType: this<'tags, 'base> => TypeNode.t = "checkType"
    @get
    external extendsType: this<'tags, 'base> => TypeNode.t = "extendsType"
    @get
    external trueType: this<'tags, 'base> => TypeNode.t = "trueType"
    @get
    external falseType: this<'tags, 'base> => TypeNode.t = "falseType"
    @obj
    external make: (~kind: SyntaxKind.ConditionalType.t, ~checkType: TypeNode.t, ~extendsType: TypeNode.t, ~trueType: TypeNode.t, ~falseType: TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
  }
  module ConfigFileDiagnosticsReporter = {
    open ConfigFileDiagnosticsReporter
    type t = t
    type t0 = t
    type tags = [#Ts_ConfigFileDiagnosticsReporter]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ConfigFileDiagnosticsReporter ]
    @get
    external getOnUnRecoverableConfigFileDiagnostic: this<'tags, 'base> => DiagnosticReporter.t = "onUnRecoverableConfigFileDiagnostic"
    @set
    external setOnUnRecoverableConfigFileDiagnostic: (this<'tags, 'base>, DiagnosticReporter.t) => unit = "onUnRecoverableConfigFileDiagnostic"
    @obj
    external make: ~onUnRecoverableConfigFileDiagnostic: DiagnosticReporter.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ConstKeyword = {
    open ConstKeyword
    type t = ModifierToken.t<SyntaxKind.ConstKeyword.t>
    type t0 = t
  }
  module ConstructSignatureDeclaration = {
    open ConstructSignatureDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_ConstructSignatureDeclaration | #Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeElement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ConstructSignatureDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ConstructSignature.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.ConstructSignature.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asSignatureDeclarationBase: t => SignatureDeclarationBase.t = "%identity"
    external asTypeElement: t => TypeElement.t = "%identity"
  }
  module ConstructorDeclaration = {
    open ConstructorDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_ClassElement | #Ts_ConstructorDeclaration | #Ts_Declaration | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ConstructorDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.Constructor.t = "kind"
    @get
    external parent: this<'tags, 'base> => ClassLikeDeclaration.t = "parent"
    @get
    external body: this<'tags, 'base> => FunctionBody.t = "body"
    @obj
    external make: (~kind: SyntaxKind.Constructor.t, ~parent: ClassLikeDeclaration.t, ~body: FunctionBody.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFunctionLikeDeclarationBase: t => FunctionLikeDeclarationBase.t = "%identity"
    external asClassElement: t => ClassElement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module ConstructorTypeNode = {
    open ConstructorTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_ConstructorTypeNode | #Ts_Declaration | #Ts_FunctionOrConstructorTypeNodeBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ConstructorTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ConstructorType.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.ConstructorType.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFunctionOrConstructorTypeNodeBase: t => FunctionOrConstructorTypeNodeBase.t = "%identity"
  }
  module ContinueStatement = {
    open ContinueStatement
    type t = t
    type t0 = t
    type tags = [#Ts_ContinueStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ContinueStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ContinueStatement.t = "kind"
    @get
    external label: this<'tags, 'base> => Identifier.t = "label"
    @obj
    external make: (~kind: SyntaxKind.ContinueStatement.t, ~label: Identifier.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module CoreTransformationContext = {
    open CoreTransformationContext
    type t = t
    type t0 = t
    type tags = [#Ts_CoreTransformationContext]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CoreTransformationContext ]
    @get
    external factory: this<'tags, 'base> => NodeFactory.t = "factory"
    @send
    external getCompilerOptions: this<'tags, 'base> => CompilerOptions.t = "getCompilerOptions"
    @send
    external startLexicalEnvironment: this<'tags, 'base> => unit = "startLexicalEnvironment"
    @send
    external suspendLexicalEnvironment: this<'tags, 'base> => unit = "suspendLexicalEnvironment"
    @send
    external resumeLexicalEnvironment: this<'tags, 'base> => unit = "resumeLexicalEnvironment"
    @send @return(nullable)
    external endLexicalEnvironment: this<'tags, 'base> => option<array<Statement.t>> = "endLexicalEnvironment"
    @send
    external hoistFunctionDeclaration: (this<'tags, 'base>, ~node:FunctionDeclaration.t) => unit = "hoistFunctionDeclaration"
    @send
    external hoistVariableDeclaration: (this<'tags, 'base>, ~node:Identifier.t) => unit = "hoistVariableDeclaration"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CreateProgram = {
    open CreateProgram
    type t<'T> = (~rootNames:undefined<array<string>>, ~options:undefined<CompilerOptions.t>, ~host:CompilerHost.t=?, ~oldProgram:'T=?, ~configFileParsingDiagnostics:array<Diagnostic.t>=?, ~projectReferences:undefined<array<ProjectReference.t>>=?, unit) => 'T
    type t1<'T> = t<'T>
  }
  module CreateProgramOptions = {
    open CreateProgramOptions
    type t = t
    type t0 = t
    type tags = [#Ts_CreateProgramOptions]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CreateProgramOptions ]
    @get
    external getRootNames: this<'tags, 'base> => array<string> = "rootNames"
    @set
    external setRootNames: (this<'tags, 'base>, array<string>) => unit = "rootNames"
    @get
    external getOptions: this<'tags, 'base> => CompilerOptions.t = "options"
    @set
    external setOptions: (this<'tags, 'base>, CompilerOptions.t) => unit = "options"
    @get
    external getProjectReferences: this<'tags, 'base> => array<ProjectReference.t> = "projectReferences"
    @set
    external setProjectReferences: (this<'tags, 'base>, array<ProjectReference.t>) => unit = "projectReferences"
    @get
    external getHost: this<'tags, 'base> => CompilerHost.t = "host"
    @set
    external setHost: (this<'tags, 'base>, CompilerHost.t) => unit = "host"
    @get
    external getOldProgram: this<'tags, 'base> => Program.t = "oldProgram"
    @set
    external setOldProgram: (this<'tags, 'base>, Program.t) => unit = "oldProgram"
    @get
    external getConfigFileParsingDiagnostics: this<'tags, 'base> => array<Diagnostic.t> = "configFileParsingDiagnostics"
    @set
    external setConfigFileParsingDiagnostics: (this<'tags, 'base>, array<Diagnostic.t>) => unit = "configFileParsingDiagnostics"
    @obj
    external make: (~rootNames: array<string>, ~options: CompilerOptions.t, ~projectReferences: array<ProjectReference.t>, ~host: CompilerHost.t, ~oldProgram: Program.t, ~configFileParsingDiagnostics: array<Diagnostic.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CustomTransformer = {
    open CustomTransformer
    type t = t
    type t0 = t
    type tags = [#Ts_CustomTransformer]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CustomTransformer ]
    @send
    external transformSourceFile: (this<'tags, 'base>, ~node:SourceFile.t) => SourceFile.t = "transformSourceFile"
    @send
    external transformBundle: (this<'tags, 'base>, ~node:Bundle.t) => Bundle.t = "transformBundle"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module CustomTransformerFactory = {
    open CustomTransformerFactory
    type t = TransformationContext.t => CustomTransformer.t
    type t0 = t
  }
  module CustomTransformers = {
    open CustomTransformers
    type t = t
    type t0 = t
    type tags = [#Ts_CustomTransformers]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_CustomTransformers ]
    @get
    external getBefore: this<'tags, 'base> => array<Union.t2<TransformerFactory.t<SourceFile.t>, CustomTransformerFactory.t>> = "before"
    @set
    external setBefore: (this<'tags, 'base>, array<Union.t2<TransformerFactory.t<SourceFile.t>, CustomTransformerFactory.t>>) => unit = "before"
    @get
    external getAfter: this<'tags, 'base> => array<Union.t2<TransformerFactory.t<SourceFile.t>, CustomTransformerFactory.t>> = "after"
    @set
    external setAfter: (this<'tags, 'base>, array<Union.t2<TransformerFactory.t<SourceFile.t>, CustomTransformerFactory.t>>) => unit = "after"
    @get
    external getAfterDeclarations: this<'tags, 'base> => array<Union.t2<TransformerFactory.t<Union.t2<Bundle.t, SourceFile.t>>, CustomTransformerFactory.t>> = "afterDeclarations"
    @set
    external setAfterDeclarations: (this<'tags, 'base>, array<Union.t2<TransformerFactory.t<Union.t2<Bundle.t, SourceFile.t>>, CustomTransformerFactory.t>>) => unit = "afterDeclarations"
    @obj
    external make: (~before: array<Union.t2<TransformerFactory.t<SourceFile.t>, CustomTransformerFactory.t>>, ~after: array<Union.t2<TransformerFactory.t<SourceFile.t>, CustomTransformerFactory.t>>, ~afterDeclarations: array<Union.t2<TransformerFactory.t<Union.t2<Bundle.t, SourceFile.t>>, CustomTransformerFactory.t>>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module DebuggerStatement = {
    open DebuggerStatement
    type t = t
    type t0 = t
    type tags = [#Ts_DebuggerStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DebuggerStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.DebuggerStatement.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.DebuggerStatement.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module Declaration = {
    open Declaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Declaration ]
    @get
    external get_declarationBrand: this<'tags, 'base> => any = "_declarationBrand"
    @set
    external set_declarationBrand: (this<'tags, 'base>, any) => unit = "_declarationBrand"
    @obj
    external make: ~\"_declarationBrand": any => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module DeclarationName = {
    open DeclarationName
    type t = Union.t8<Identifier.t, PrivateIdentifier.t, StringLiteralLike.t, NumericLiteral.t, ComputedPropertyName.t, ElementAccessExpression.t, BindingPattern.t, EntityNameExpression.t>
    type t0 = t
  }
  module DeclarationStatement = {
    open DeclarationStatement
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DeclarationStatement ]
    @get
    external name: this<'tags, 'base> => Union.t3<Identifier.t, StringLiteral.t, NumericLiteral.t> = "name"
    @obj
    external make: ~name: Union.t3<Identifier.t, StringLiteral.t, NumericLiteral.t> => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module DeclarationWithTypeParameterChildren = {
    open DeclarationWithTypeParameterChildren
    type t = Union.t5<SignatureDeclaration.t, ClassLikeDeclaration.t, InterfaceDeclaration.t, TypeAliasDeclaration.t, JSDocTemplateTag.t>
    type t0 = t
  }
  module DeclarationWithTypeParameters = {
    open DeclarationWithTypeParameters
    type t = Union.t4<DeclarationWithTypeParameterChildren.t, JSDocTypedefTag.t, JSDocCallbackTag.t, JSDocSignature.t>
    type t0 = t
  }
  module DeclareKeyword = {
    open DeclareKeyword
    type t = ModifierToken.t<SyntaxKind.DeclareKeyword.t>
    type t0 = t
  }
  module Decorator = {
    open Decorator
    type t = t
    type t0 = t
    type tags = [#Ts_Decorator | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Decorator ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.Decorator.t = "kind"
    @get
    external parent: this<'tags, 'base> => NamedDeclaration.t = "parent"
    @get
    external expression: this<'tags, 'base> => LeftHandSideExpression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.Decorator.t, ~parent: NamedDeclaration.t, ~expression: LeftHandSideExpression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module DefaultClause = {
    open DefaultClause
    type t = t
    type t0 = t
    type tags = [#Ts_DefaultClause | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DefaultClause ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.DefaultClause.t = "kind"
    @get
    external parent: this<'tags, 'base> => CaseBlock.t = "parent"
    @get
    external statements: this<'tags, 'base> => NodeArray.t<Statement.t> = "statements"
    @obj
    external make: (~kind: SyntaxKind.DefaultClause.t, ~parent: CaseBlock.t, ~statements: NodeArray.t<Statement.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module DefaultKeyword = {
    open DefaultKeyword
    type t = ModifierToken.t<SyntaxKind.DefaultKeyword.t>
    type t0 = t
  }
  module DeferredTypeReference = {
    open DeferredTypeReference
    type t = t
    type t0 = t
    type tags = [#Ts_DeferredTypeReference | #Ts_ObjectType | #Ts_Type | #Ts_TypeReference]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DeferredTypeReference ]
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeReference: t => TypeReference.t = "%identity"
  }
  module DefinitionInfo = {
    open DefinitionInfo
    type t = t
    type t0 = t
    type tags = [#Ts_DefinitionInfo | #Ts_DocumentSpan]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DefinitionInfo ]
    @get
    external getKind: this<'tags, 'base> => ScriptElementKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, ScriptElementKind.t) => unit = "kind"
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @get
    external getContainerKind: this<'tags, 'base> => ScriptElementKind.t = "containerKind"
    @set
    external setContainerKind: (this<'tags, 'base>, ScriptElementKind.t) => unit = "containerKind"
    @get
    external getContainerName: this<'tags, 'base> => string = "containerName"
    @set
    external setContainerName: (this<'tags, 'base>, string) => unit = "containerName"
    @get
    external getUnverified: this<'tags, 'base> => bool = "unverified"
    @set
    external setUnverified: (this<'tags, 'base>, bool) => unit = "unverified"
    @obj
    external make: (~kind: ScriptElementKind.t, ~name: string, ~containerKind: ScriptElementKind.t, ~containerName: string, ~unverified: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDocumentSpan: t => DocumentSpan.t = "%identity"
  }
  module DefinitionInfoAndBoundSpan = {
    open DefinitionInfoAndBoundSpan
    type t = t
    type t0 = t
    type tags = [#Ts_DefinitionInfoAndBoundSpan]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DefinitionInfoAndBoundSpan ]
    @get
    external getDefinitions: this<'tags, 'base> => array<DefinitionInfo.t> = "definitions"
    @set
    external setDefinitions: (this<'tags, 'base>, array<DefinitionInfo.t>) => unit = "definitions"
    @get
    external getTextSpan: this<'tags, 'base> => TextSpan.t = "textSpan"
    @set
    external setTextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "textSpan"
    @obj
    external make: (~definitions: array<DefinitionInfo.t>, ~textSpan: TextSpan.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module DeleteExpression = {
    open DeleteExpression
    type t = t
    type t0 = t
    type tags = [#Ts_DeleteExpression | #Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DeleteExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.DeleteExpression.t = "kind"
    @get
    external expression: this<'tags, 'base> => UnaryExpression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.DeleteExpression.t, ~expression: UnaryExpression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asUnaryExpression: t => UnaryExpression.t = "%identity"
  }
  module DestructuringAssignment = {
    open DestructuringAssignment
    type t = Union.t2<ObjectDestructuringAssignment.t, ArrayDestructuringAssignment.t>
    type t0 = t
  }
  module DestructuringPattern = {
    open DestructuringPattern
    type t = Union.t3<BindingPattern.t, ObjectLiteralExpression.t, ArrayLiteralExpression.t>
    type t0 = t
  }
  module Diagnostic = {
    open Diagnostic
    type t = t
    type t0 = t
    type tags = [#Ts_Diagnostic | #Ts_DiagnosticRelatedInformation]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Diagnostic ]
    @get
    external getReportsUnnecessary: this<'tags, 'base> => untyped_object = "reportsUnnecessary"
    @set
    external setReportsUnnecessary: (this<'tags, 'base>, untyped_object) => unit = "reportsUnnecessary"
    @get
    external getReportsDeprecated: this<'tags, 'base> => untyped_object = "reportsDeprecated"
    @set
    external setReportsDeprecated: (this<'tags, 'base>, untyped_object) => unit = "reportsDeprecated"
    @get
    external getSource: this<'tags, 'base> => string = "source"
    @set
    external setSource: (this<'tags, 'base>, string) => unit = "source"
    @get
    external getRelatedInformation: this<'tags, 'base> => array<DiagnosticRelatedInformation.t> = "relatedInformation"
    @set
    external setRelatedInformation: (this<'tags, 'base>, array<DiagnosticRelatedInformation.t>) => unit = "relatedInformation"
    @obj
    external make: (~reportsUnnecessary: untyped_object, ~reportsDeprecated: untyped_object, ~source: string, ~relatedInformation: array<DiagnosticRelatedInformation.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDiagnosticRelatedInformation: t => DiagnosticRelatedInformation.t = "%identity"
  }
  module DiagnosticCategory = {
    open DiagnosticCategory
    type t = t = Warning | Error | Suggestion | Message
    type t_0 = t
    module Warning = {
      open Warning
      type t = t
      type t0 = t
      @module("typescript") @scope("DiagnosticCategory") @val
      external value: t = "Warning"
    }
    module Error = {
      open Error
      type t = t
      type t0 = t
      @module("typescript") @scope("DiagnosticCategory") @val
      external value: t = "Error"
    }
    module Suggestion = {
      open Suggestion
      type t = t
      type t0 = t
      @module("typescript") @scope("DiagnosticCategory") @val
      external value: t = "Suggestion"
    }
    module Message = {
      open Message
      type t = t
      type t0 = t
      @module("typescript") @scope("DiagnosticCategory") @val
      external value: t = "Message"
    }
  }
  module DiagnosticMessage = {
    open DiagnosticMessage
    type t = t
    type t0 = t
    type tags = [#Ts_DiagnosticMessage]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DiagnosticMessage ]
    @get
    external getKey: this<'tags, 'base> => string = "key"
    @set
    external setKey: (this<'tags, 'base>, string) => unit = "key"
    @get
    external getCategory: this<'tags, 'base> => DiagnosticCategory.t = "category"
    @set
    external setCategory: (this<'tags, 'base>, DiagnosticCategory.t) => unit = "category"
    @get
    external getCode: this<'tags, 'base> => float = "code"
    @set
    external setCode: (this<'tags, 'base>, float) => unit = "code"
    @get
    external getMessage: this<'tags, 'base> => string = "message"
    @set
    external setMessage: (this<'tags, 'base>, string) => unit = "message"
    @get
    external getReportsUnnecessary: this<'tags, 'base> => untyped_object = "reportsUnnecessary"
    @set
    external setReportsUnnecessary: (this<'tags, 'base>, untyped_object) => unit = "reportsUnnecessary"
    @get
    external getReportsDeprecated: this<'tags, 'base> => untyped_object = "reportsDeprecated"
    @set
    external setReportsDeprecated: (this<'tags, 'base>, untyped_object) => unit = "reportsDeprecated"
    @obj
    external make: (~key: string, ~category: DiagnosticCategory.t, ~code: float, ~message: string, ~reportsUnnecessary: untyped_object, ~reportsDeprecated: untyped_object) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module DiagnosticMessageChain = {
    open DiagnosticMessageChain
    type t = t
    type t0 = t
    type tags = [#Ts_DiagnosticMessageChain]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DiagnosticMessageChain ]
    @get
    external getMessageText: this<'tags, 'base> => string = "messageText"
    @set
    external setMessageText: (this<'tags, 'base>, string) => unit = "messageText"
    @get
    external getCategory: this<'tags, 'base> => DiagnosticCategory.t = "category"
    @set
    external setCategory: (this<'tags, 'base>, DiagnosticCategory.t) => unit = "category"
    @get
    external getCode: this<'tags, 'base> => float = "code"
    @set
    external setCode: (this<'tags, 'base>, float) => unit = "code"
    @get
    external getNext: this<'tags, 'base> => array<t> = "next"
    @set
    external setNext: (this<'tags, 'base>, array<t>) => unit = "next"
    @obj
    external make: (~messageText: string, ~category: DiagnosticCategory.t, ~code: float, ~next: array<t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module DiagnosticRelatedInformation = {
    open DiagnosticRelatedInformation
    type t = t
    type t0 = t
    type tags = [#Ts_DiagnosticRelatedInformation]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DiagnosticRelatedInformation ]
    @get
    external getCategory: this<'tags, 'base> => DiagnosticCategory.t = "category"
    @set
    external setCategory: (this<'tags, 'base>, DiagnosticCategory.t) => unit = "category"
    @get
    external getCode: this<'tags, 'base> => float = "code"
    @set
    external setCode: (this<'tags, 'base>, float) => unit = "code"
    @get @return(nullable)
    external getFile: this<'tags, 'base> => option<SourceFile.t> = "file"
    @set
    external setFile: (this<'tags, 'base>, undefined<SourceFile.t>) => unit = "file"
    @get @return(nullable)
    external getStart: this<'tags, 'base> => option<float> = "start"
    @set
    external setStart: (this<'tags, 'base>, undefined<float>) => unit = "start"
    @get @return(nullable)
    external getLength: this<'tags, 'base> => option<float> = "length"
    @set
    external setLength: (this<'tags, 'base>, undefined<float>) => unit = "length"
    @get
    external getMessageText: this<'tags, 'base> => Union.t2<string, DiagnosticMessageChain.t> = "messageText"
    @set
    external setMessageText: (this<'tags, 'base>, Union.t2<string, DiagnosticMessageChain.t>) => unit = "messageText"
    @obj
    external make: (~category: DiagnosticCategory.t, ~code: float, ~file: SourceFile.t=?, ~start: float=?, ~length: float=?, ~messageText: Union.t2<string, DiagnosticMessageChain.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module DiagnosticReporter = {
    open DiagnosticReporter
    type t = Diagnostic.t => unit
    type t0 = t
  }
  module DiagnosticWithLocation = {
    open DiagnosticWithLocation
    type t = t
    type t0 = t
    type tags = [#Ts_Diagnostic | #Ts_DiagnosticRelatedInformation | #Ts_DiagnosticWithLocation]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DiagnosticWithLocation ]
    @get
    external getFile: this<'tags, 'base> => SourceFile.t = "file"
    @set
    external setFile: (this<'tags, 'base>, SourceFile.t) => unit = "file"
    @get
    external getStart: this<'tags, 'base> => float = "start"
    @set
    external setStart: (this<'tags, 'base>, float) => unit = "start"
    @get
    external getLength: this<'tags, 'base> => float = "length"
    @set
    external setLength: (this<'tags, 'base>, float) => unit = "length"
    @obj
    external make: (~file: SourceFile.t, ~start: float, ~length: float) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDiagnostic: t => Diagnostic.t = "%identity"
  }
  module DirectoryWatcherCallback = {
    open DirectoryWatcherCallback
    type t = string => unit
    type t0 = t
  }
  module DoStatement = {
    open DoStatement
    type t = t
    type t0 = t
    type tags = [#Ts_DoStatement | #Ts_IterationStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DoStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.DoStatement.t = "kind"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.DoStatement.t, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asIterationStatement: t => IterationStatement.t = "%identity"
  }
  module DocCommentTemplateOptions = {
    open DocCommentTemplateOptions
    type t = t
    type t0 = t
    type tags = [#Ts_DocCommentTemplateOptions]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DocCommentTemplateOptions ]
    @get
    external generateReturnInDocTemplate: this<'tags, 'base> => bool = "generateReturnInDocTemplate"
    @obj
    external make: ~generateReturnInDocTemplate: bool => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module DocumentHighlights = {
    open DocumentHighlights
    type t = t
    type t0 = t
    type tags = [#Ts_DocumentHighlights]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DocumentHighlights ]
    @get
    external getFileName: this<'tags, 'base> => string = "fileName"
    @set
    external setFileName: (this<'tags, 'base>, string) => unit = "fileName"
    @get
    external getHighlightSpans: this<'tags, 'base> => array<HighlightSpan.t> = "highlightSpans"
    @set
    external setHighlightSpans: (this<'tags, 'base>, array<HighlightSpan.t>) => unit = "highlightSpans"
    @obj
    external make: (~fileName: string, ~highlightSpans: array<HighlightSpan.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module DocumentRegistry = {
    open DocumentRegistry
    type t = t
    type t0 = t
    type tags = [#Ts_DocumentRegistry]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DocumentRegistry ]
    @send
    external acquireDocument: (this<'tags, 'base>, ~fileName:string, ~compilationSettings:CompilerOptions.t, ~scriptSnapshot:IScriptSnapshot.t, ~version:string, ~scriptKind:ScriptKind.t=?, unit) => SourceFile.t = "acquireDocument"
    @send
    external acquireDocumentWithKey: (this<'tags, 'base>, ~fileName:string, ~path:Path.t, ~compilationSettings:CompilerOptions.t, ~key:DocumentRegistryBucketKey.t, ~scriptSnapshot:IScriptSnapshot.t, ~version:string, ~scriptKind:ScriptKind.t=?, unit) => SourceFile.t = "acquireDocumentWithKey"
    @send
    external updateDocument: (this<'tags, 'base>, ~fileName:string, ~compilationSettings:CompilerOptions.t, ~scriptSnapshot:IScriptSnapshot.t, ~version:string, ~scriptKind:ScriptKind.t=?, unit) => SourceFile.t = "updateDocument"
    @send
    external updateDocumentWithKey: (this<'tags, 'base>, ~fileName:string, ~path:Path.t, ~compilationSettings:CompilerOptions.t, ~key:DocumentRegistryBucketKey.t, ~scriptSnapshot:IScriptSnapshot.t, ~version:string, ~scriptKind:ScriptKind.t=?, unit) => SourceFile.t = "updateDocumentWithKey"
    @send
    external getKeyForCompilationSettings: (this<'tags, 'base>, ~settings:CompilerOptions.t) => DocumentRegistryBucketKey.t = "getKeyForCompilationSettings"
    @send
    external releaseDocument: (this<'tags, 'base>, ~fileName:string, ~compilationSettings:CompilerOptions.t) => unit = "releaseDocument"
    @send
    external releaseDocument': (this<'tags, 'base>, ~fileName:string, ~compilationSettings:CompilerOptions.t, ~scriptKind:ScriptKind.t) => unit = "releaseDocument"
    @send
    external releaseDocumentWithKey: (this<'tags, 'base>, ~path:Path.t, ~key:DocumentRegistryBucketKey.t) => unit = "releaseDocumentWithKey"
    @send
    external releaseDocumentWithKey': (this<'tags, 'base>, ~path:Path.t, ~key:DocumentRegistryBucketKey.t, ~scriptKind:ScriptKind.t) => unit = "releaseDocumentWithKey"
    @send
    external reportStats: this<'tags, 'base> => string = "reportStats"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module DocumentRegistryBucketKey = {
    open DocumentRegistryBucketKey
    module AnonymousInterface0 = {
      open AnonymousInterface0
      type t = t
      @get
      external get__bucketKey: t => any = "__bucketKey"
      @set
      external set__bucketKey: (t, any) => unit = "__bucketKey"
      @obj
      external make: ~\"__bucketKey": any => t = ""
    }
    type t = Intersection.t2<string, AnonymousInterface0.t>
    type t0 = t
  }
  module DocumentSpan = {
    open DocumentSpan
    type t = t
    type t0 = t
    type tags = [#Ts_DocumentSpan]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_DocumentSpan ]
    @get
    external getTextSpan: this<'tags, 'base> => TextSpan.t = "textSpan"
    @set
    external setTextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "textSpan"
    @get
    external getFileName: this<'tags, 'base> => string = "fileName"
    @set
    external setFileName: (this<'tags, 'base>, string) => unit = "fileName"
    @get
    external getOriginalTextSpan: this<'tags, 'base> => TextSpan.t = "originalTextSpan"
    @set
    external setOriginalTextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "originalTextSpan"
    @get
    external getOriginalFileName: this<'tags, 'base> => string = "originalFileName"
    @set
    external setOriginalFileName: (this<'tags, 'base>, string) => unit = "originalFileName"
    @get
    external getContextSpan: this<'tags, 'base> => TextSpan.t = "contextSpan"
    @set
    external setContextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "contextSpan"
    @get
    external getOriginalContextSpan: this<'tags, 'base> => TextSpan.t = "originalContextSpan"
    @set
    external setOriginalContextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "originalContextSpan"
    @obj
    external make: (~textSpan: TextSpan.t, ~fileName: string, ~originalTextSpan: TextSpan.t, ~originalFileName: string, ~contextSpan: TextSpan.t, ~originalContextSpan: TextSpan.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module DotDotDotToken = {
    open DotDotDotToken
    type t = PunctuationToken.t<SyntaxKind.DotDotDotToken.t>
    type t0 = t
  }
  module DotToken = {
    open DotToken
    type t = PunctuationToken.t<SyntaxKind.DotToken.t>
    type t0 = t
  }
  module ESMap = {
    open ESMap
    type t<'K, 'V> = t<'K, 'V>
    type t2<'K, 'V> = t<'K, 'V>
    type tags<'K, 'V> = [#Ts_Collection('K) | #Ts_ReadonlyCollection('K) | #Ts_ESMap('K, 'V) | #Ts_ReadonlyESMap('K, 'V)]
    type tags2<'K, 'V> = tags<'K, 'V>
    type this<'tags, 'base, 'K, 'V> = intf<'tags, 'base> constraint 'tags = [> #Ts_ESMap('K, 'V) ]
    @send
    external set: (this<'tags, 'base, 'K, 'V>, ~key:'K, ~value:'V) => this<'tags, 'base, 'K, 'V> = "set"
    external castFrom: this<'tags, 'base, 'K, 'V> => t<'K, 'V> = "%identity"
    external asReadonlyESMap: t<'K, 'V> => ReadonlyESMap.t<'K, 'V> = "%identity"
    external asCollection: t<'K, 'V> => Collection.t<'K> = "%identity"
  }
  module EditorOptions = {
    open EditorOptions
    type t = t
    type t0 = t
    type tags = [#Ts_EditorOptions]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_EditorOptions ]
    @get
    external getBaseIndentSize: this<'tags, 'base> => float = "BaseIndentSize"
    @set
    external setBaseIndentSize: (this<'tags, 'base>, float) => unit = "BaseIndentSize"
    @get
    external getIndentSize: this<'tags, 'base> => float = "IndentSize"
    @set
    external setIndentSize: (this<'tags, 'base>, float) => unit = "IndentSize"
    @get
    external getTabSize: this<'tags, 'base> => float = "TabSize"
    @set
    external setTabSize: (this<'tags, 'base>, float) => unit = "TabSize"
    @get
    external getNewLineCharacter: this<'tags, 'base> => string = "NewLineCharacter"
    @set
    external setNewLineCharacter: (this<'tags, 'base>, string) => unit = "NewLineCharacter"
    @get
    external getConvertTabsToSpaces: this<'tags, 'base> => bool = "ConvertTabsToSpaces"
    @set
    external setConvertTabsToSpaces: (this<'tags, 'base>, bool) => unit = "ConvertTabsToSpaces"
    @get
    external getIndentStyle: this<'tags, 'base> => IndentStyle.t = "IndentStyle"
    @set
    external setIndentStyle: (this<'tags, 'base>, IndentStyle.t) => unit = "IndentStyle"
    @obj
    external make: (~baseIndentSize: float, ~indentSize: float, ~tabSize: float, ~newLineCharacter: string, ~convertTabsToSpaces: bool, ~indentStyle: IndentStyle.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module EditorSettings = {
    open EditorSettings
    type t = t
    type t0 = t
    type tags = [#Ts_EditorSettings]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_EditorSettings ]
    @get
    external getBaseIndentSize: this<'tags, 'base> => float = "baseIndentSize"
    @set
    external setBaseIndentSize: (this<'tags, 'base>, float) => unit = "baseIndentSize"
    @get
    external getIndentSize: this<'tags, 'base> => float = "indentSize"
    @set
    external setIndentSize: (this<'tags, 'base>, float) => unit = "indentSize"
    @get
    external getTabSize: this<'tags, 'base> => float = "tabSize"
    @set
    external setTabSize: (this<'tags, 'base>, float) => unit = "tabSize"
    @get
    external getNewLineCharacter: this<'tags, 'base> => string = "newLineCharacter"
    @set
    external setNewLineCharacter: (this<'tags, 'base>, string) => unit = "newLineCharacter"
    @get
    external getConvertTabsToSpaces: this<'tags, 'base> => bool = "convertTabsToSpaces"
    @set
    external setConvertTabsToSpaces: (this<'tags, 'base>, bool) => unit = "convertTabsToSpaces"
    @get
    external getIndentStyle: this<'tags, 'base> => IndentStyle.t = "indentStyle"
    @set
    external setIndentStyle: (this<'tags, 'base>, IndentStyle.t) => unit = "indentStyle"
    @get
    external getTrimTrailingWhitespace: this<'tags, 'base> => bool = "trimTrailingWhitespace"
    @set
    external setTrimTrailingWhitespace: (this<'tags, 'base>, bool) => unit = "trimTrailingWhitespace"
    @obj
    external make: (~baseIndentSize: float, ~indentSize: float, ~tabSize: float, ~newLineCharacter: string, ~convertTabsToSpaces: bool, ~indentStyle: IndentStyle.t, ~trimTrailingWhitespace: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ElementAccessChain = {
    open ElementAccessChain
    type t = t
    type t0 = t
    type tags = [#Ts_ElementAccessChain | #Ts_ElementAccessExpression | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ElementAccessChain ]
    @get
    external get_optionalChainBrand: this<'tags, 'base> => any = "_optionalChainBrand"
    @set
    external set_optionalChainBrand: (this<'tags, 'base>, any) => unit = "_optionalChainBrand"
    @obj
    external make: ~\"_optionalChainBrand": any => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asElementAccessExpression: t => ElementAccessExpression.t = "%identity"
  }
  module ElementAccessExpression = {
    open ElementAccessExpression
    type t = t
    type t0 = t
    type tags = [#Ts_ElementAccessExpression | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ElementAccessExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ElementAccessExpression.t = "kind"
    @get
    external expression: this<'tags, 'base> => LeftHandSideExpression.t = "expression"
    @get
    external questionDotToken: this<'tags, 'base> => QuestionDotToken.t = "questionDotToken"
    @get
    external argumentExpression: this<'tags, 'base> => Expression.t = "argumentExpression"
    @obj
    external make: (~kind: SyntaxKind.ElementAccessExpression.t, ~expression: LeftHandSideExpression.t, ~questionDotToken: QuestionDotToken.t, ~argumentExpression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asMemberExpression: t => MemberExpression.t = "%identity"
  }
  module ElementFlags = {
    open ElementFlags
    type t = t
    type t_0 = t
    module Required = {
      open Required
      type t = t
      type t0 = t
      @module("typescript") @scope("ElementFlags") @val
      external value: t = "Required"
    }
    module Optional = {
      open Optional
      type t = t
      type t0 = t
      @module("typescript") @scope("ElementFlags") @val
      external value: t = "Optional"
    }
    module Rest = {
      open Rest
      type t = t
      type t0 = t
      @module("typescript") @scope("ElementFlags") @val
      external value: t = "Rest"
    }
    module Variadic = {
      open Variadic
      type t = t
      type t0 = t
      @module("typescript") @scope("ElementFlags") @val
      external value: t = "Variadic"
    }
    module Fixed = {
      open Fixed
      type t = t
      type t0 = t
      @module("typescript") @scope("ElementFlags") @val
      external value: t = "Fixed"
    }
    module Variable = {
      open Variable
      type t = t
      type t0 = t
      @module("typescript") @scope("ElementFlags") @val
      external value: t = "Variable"
    }
    module NonRequired = {
      open NonRequired
      type t = t
      type t0 = t
      @module("typescript") @scope("ElementFlags") @val
      external value: t = "NonRequired"
    }
    module NonRest = {
      open NonRest
      type t = t
      type t0 = t
      @module("typescript") @scope("ElementFlags") @val
      external value: t = "NonRest"
    }
  }
  module EmitAndSemanticDiagnosticsBuilderProgram = {
    open EmitAndSemanticDiagnosticsBuilderProgram
    type t = t
    type t0 = t
    type tags = [#Ts_BuilderProgram | #Ts_EmitAndSemanticDiagnosticsBuilderProgram | #Ts_SemanticDiagnosticsBuilderProgram]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_EmitAndSemanticDiagnosticsBuilderProgram ]
    @send
    external emitNextAffectedFile: (this<'tags, 'base>, ~writeFile:WriteFileCallback.t=?, ~cancellationToken:CancellationToken.t=?, ~emitOnlyDtsFiles:bool=?, ~customTransformers:CustomTransformers.t=?, unit) => AffectedFileResult.t<EmitResult.t> = "emitNextAffectedFile"
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asSemanticDiagnosticsBuilderProgram: t => SemanticDiagnosticsBuilderProgram.t = "%identity"
  }
  module EmitFlags = {
    open EmitFlags
    type t = t
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "None"
    }
    module SingleLine = {
      open SingleLine
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "SingleLine"
    }
    module AdviseOnEmitNode = {
      open AdviseOnEmitNode
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "AdviseOnEmitNode"
    }
    module NoSubstitution = {
      open NoSubstitution
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoSubstitution"
    }
    module CapturesThis = {
      open CapturesThis
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "CapturesThis"
    }
    module NoLeadingSourceMap = {
      open NoLeadingSourceMap
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoLeadingSourceMap"
    }
    module NoTrailingSourceMap = {
      open NoTrailingSourceMap
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoTrailingSourceMap"
    }
    module NoSourceMap = {
      open NoSourceMap
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoSourceMap"
    }
    module NoNestedSourceMaps = {
      open NoNestedSourceMaps
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoNestedSourceMaps"
    }
    module NoTokenLeadingSourceMaps = {
      open NoTokenLeadingSourceMaps
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoTokenLeadingSourceMaps"
    }
    module NoTokenTrailingSourceMaps = {
      open NoTokenTrailingSourceMaps
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoTokenTrailingSourceMaps"
    }
    module NoTokenSourceMaps = {
      open NoTokenSourceMaps
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoTokenSourceMaps"
    }
    module NoLeadingComments = {
      open NoLeadingComments
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoLeadingComments"
    }
    module NoTrailingComments = {
      open NoTrailingComments
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoTrailingComments"
    }
    module NoComments = {
      open NoComments
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoComments"
    }
    module NoNestedComments = {
      open NoNestedComments
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoNestedComments"
    }
    module HelperName = {
      open HelperName
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "HelperName"
    }
    module ExportName = {
      open ExportName
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "ExportName"
    }
    module LocalName = {
      open LocalName
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "LocalName"
    }
    module InternalName = {
      open InternalName
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "InternalName"
    }
    module Indented = {
      open Indented
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "Indented"
    }
    module NoIndentation = {
      open NoIndentation
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoIndentation"
    }
    module AsyncFunctionBody = {
      open AsyncFunctionBody
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "AsyncFunctionBody"
    }
    module ReuseTempVariableScope = {
      open ReuseTempVariableScope
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "ReuseTempVariableScope"
    }
    module CustomPrologue = {
      open CustomPrologue
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "CustomPrologue"
    }
    module NoHoisting = {
      open NoHoisting
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoHoisting"
    }
    module HasEndOfDeclarationMarker = {
      open HasEndOfDeclarationMarker
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "HasEndOfDeclarationMarker"
    }
    module Iterator = {
      open Iterator
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "Iterator"
    }
    module NoAsciiEscaping = {
      open NoAsciiEscaping
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitFlags") @val
      external value: t = "NoAsciiEscaping"
    }
  }
  module EmitHelper = {
    open EmitHelper
    type t = Union.t2<ScopedEmitHelper.t, UnscopedEmitHelper.t>
    type t0 = t
  }
  module EmitHelperBase = {
    open EmitHelperBase
    type t = t
    type t0 = t
    type tags = [#Ts_EmitHelperBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_EmitHelperBase ]
    @get
    external name: this<'tags, 'base> => string = "name"
    @get
    external scoped: this<'tags, 'base> => bool = "scoped"
    @get
    external text: this<'tags, 'base> => Union.t2<string, (EmitHelperUniqueNameCallback.t => string)> = "text"
    @get
    external priority: this<'tags, 'base> => float = "priority"
    @get
    external dependencies: this<'tags, 'base> => array<EmitHelper.t> = "dependencies"
    @obj
    external make: (~name: string, ~scoped: bool, ~text: Union.t2<string, (EmitHelperUniqueNameCallback.t => string)>, ~priority: float, ~dependencies: array<EmitHelper.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module EmitHelperUniqueNameCallback = {
    open EmitHelperUniqueNameCallback
    type t = string => string
    type t0 = t
  }
  module EmitHint = {
    open EmitHint
    type t = t =   | SourceFile
      | Expression
      | IdentifierName
      | MappedTypeParameter
      | Unspecified
      | EmbeddedStatement
      | JsxAttributeValue
    type t_0 = t
    module SourceFile = {
      open SourceFile
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitHint") @val
      external value: t = "SourceFile"
    }
    module Expression = {
      open Expression
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitHint") @val
      external value: t = "Expression"
    }
    module IdentifierName = {
      open IdentifierName
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitHint") @val
      external value: t = "IdentifierName"
    }
    module MappedTypeParameter = {
      open MappedTypeParameter
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitHint") @val
      external value: t = "MappedTypeParameter"
    }
    module Unspecified = {
      open Unspecified
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitHint") @val
      external value: t = "Unspecified"
    }
    module EmbeddedStatement = {
      open EmbeddedStatement
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitHint") @val
      external value: t = "EmbeddedStatement"
    }
    module JsxAttributeValue = {
      open JsxAttributeValue
      type t = t
      type t0 = t
      @module("typescript") @scope("EmitHint") @val
      external value: t = "JsxAttributeValue"
    }
  }
  module EmitOutput = {
    open EmitOutput
    type t = t
    type t0 = t
    type tags = [#Ts_EmitOutput]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_EmitOutput ]
    @get
    external getOutputFiles: this<'tags, 'base> => array<OutputFile.t> = "outputFiles"
    @set
    external setOutputFiles: (this<'tags, 'base>, array<OutputFile.t>) => unit = "outputFiles"
    @get
    external getEmitSkipped: this<'tags, 'base> => bool = "emitSkipped"
    @set
    external setEmitSkipped: (this<'tags, 'base>, bool) => unit = "emitSkipped"
    @obj
    external make: (~outputFiles: array<OutputFile.t>, ~emitSkipped: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module EmitResult = {
    open EmitResult
    type t = t
    type t0 = t
    type tags = [#Ts_EmitResult]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_EmitResult ]
    @get
    external getEmitSkipped: this<'tags, 'base> => bool = "emitSkipped"
    @set
    external setEmitSkipped: (this<'tags, 'base>, bool) => unit = "emitSkipped"
    @get
    external getDiagnostics: this<'tags, 'base> => array<Diagnostic.t> = "diagnostics"
    @set
    external setDiagnostics: (this<'tags, 'base>, array<Diagnostic.t>) => unit = "diagnostics"
    @get
    external getEmittedFiles: this<'tags, 'base> => array<string> = "emittedFiles"
    @set
    external setEmittedFiles: (this<'tags, 'base>, array<string>) => unit = "emittedFiles"
    @obj
    external make: (~emitSkipped: bool, ~diagnostics: array<Diagnostic.t>, ~emittedFiles: array<string>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module EmptyStatement = {
    open EmptyStatement
    type t = t
    type t0 = t
    type tags = [#Ts_EmptyStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_EmptyStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.EmptyStatement.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.EmptyStatement.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module EndOfFileToken = {
    open EndOfFileToken
    type t = Intersection.t2<Token.t<SyntaxKind.EndOfFileToken.t>, JSDocContainer.t>
    type t0 = t
  }
  module EndOfLineState = {
    open EndOfLineState
    type t = t =   | None
      | InMultiLineCommentTrivia
      | InSingleQuoteStringLiteral
      | InDoubleQuoteStringLiteral
      | InTemplateHeadOrNoSubstitutionTemplate
      | InTemplateMiddleOrTail
      | InTemplateSubstitutionPosition
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("EndOfLineState") @val
      external value: t = "None"
    }
    module InMultiLineCommentTrivia = {
      open InMultiLineCommentTrivia
      type t = t
      type t0 = t
      @module("typescript") @scope("EndOfLineState") @val
      external value: t = "InMultiLineCommentTrivia"
    }
    module InSingleQuoteStringLiteral = {
      open InSingleQuoteStringLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("EndOfLineState") @val
      external value: t = "InSingleQuoteStringLiteral"
    }
    module InDoubleQuoteStringLiteral = {
      open InDoubleQuoteStringLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("EndOfLineState") @val
      external value: t = "InDoubleQuoteStringLiteral"
    }
    module InTemplateHeadOrNoSubstitutionTemplate = {
      open InTemplateHeadOrNoSubstitutionTemplate
      type t = t
      type t0 = t
      @module("typescript") @scope("EndOfLineState") @val
      external value: t = "InTemplateHeadOrNoSubstitutionTemplate"
    }
    module InTemplateMiddleOrTail = {
      open InTemplateMiddleOrTail
      type t = t
      type t0 = t
      @module("typescript") @scope("EndOfLineState") @val
      external value: t = "InTemplateMiddleOrTail"
    }
    module InTemplateSubstitutionPosition = {
      open InTemplateSubstitutionPosition
      type t = t
      type t0 = t
      @module("typescript") @scope("EndOfLineState") @val
      external value: t = "InTemplateSubstitutionPosition"
    }
  }
  module EntityName = {
    open EntityName
    type t = Union.t2<Identifier.t, QualifiedName.t>
    type t0 = t
  }
  module EntityNameExpression = {
    open EntityNameExpression
    type t = Union.t2<Identifier.t, PropertyAccessEntityNameExpression.t>
    type t0 = t
  }
  module EntityNameOrEntityNameExpression = {
    open EntityNameOrEntityNameExpression
    type t = Union.t2<EntityName.t, EntityNameExpression.t>
    type t0 = t
  }
  module EnumDeclaration = {
    open EnumDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_DeclarationStatement | #Ts_EnumDeclaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_EnumDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.EnumDeclaration.t = "kind"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external members: this<'tags, 'base> => NodeArray.t<EnumMember.t> = "members"
    @obj
    external make: (~kind: SyntaxKind.EnumDeclaration.t, ~name: Identifier.t, ~members: NodeArray.t<EnumMember.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDeclarationStatement: t => DeclarationStatement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module EnumMember = {
    open EnumMember
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_EnumMember | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_EnumMember ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.EnumMember.t = "kind"
    @get
    external parent: this<'tags, 'base> => EnumDeclaration.t = "parent"
    @get
    external name: this<'tags, 'base> => PropertyName.t = "name"
    @get
    external initializer: this<'tags, 'base> => Expression.t = "initializer"
    @obj
    external make: (~kind: SyntaxKind.EnumMember.t, ~parent: EnumDeclaration.t, ~name: PropertyName.t, ~initializer: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module EnumType = {
    open EnumType
    type t = t
    type t0 = t
    type tags = [#Ts_EnumType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_EnumType ]
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asType: t => Type.t = "%identity"
  }
  module EqualityOperator = {
    open EqualityOperator
    type t = Union.t4<SyntaxKind.EqualsEqualsToken.t, SyntaxKind.EqualsEqualsEqualsToken.t, SyntaxKind.ExclamationEqualsEqualsToken.t, SyntaxKind.ExclamationEqualsToken.t>
    type t0 = t
  }
  module EqualityOperatorOrHigher = {
    open EqualityOperatorOrHigher
    type t = Union.t2<RelationalOperatorOrHigher.t, EqualityOperator.t>
    type t0 = t
  }
  module EqualsGreaterThanToken = {
    open EqualsGreaterThanToken
    type t = PunctuationToken.t<SyntaxKind.EqualsGreaterThanToken.t>
    type t0 = t
  }
  module EqualsToken = {
    open EqualsToken
    type t = PunctuationToken.t<SyntaxKind.EqualsToken.t>
    type t0 = t
  }
  module ErrorCallback = {
    open ErrorCallback
    type t = (~message:DiagnosticMessage.t, ~length:float) => unit
    type t0 = t
  }
  module EvolvingArrayType = {
    open EvolvingArrayType
    type t = t
    type t0 = t
    type tags = [#Ts_EvolvingArrayType | #Ts_ObjectType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_EvolvingArrayType ]
    @get
    external getElementType: this<'tags, 'base> => Type.t = "elementType"
    @set
    external setElementType: (this<'tags, 'base>, Type.t) => unit = "elementType"
    @get
    external getFinalArrayType: this<'tags, 'base> => Type.t = "finalArrayType"
    @set
    external setFinalArrayType: (this<'tags, 'base>, Type.t) => unit = "finalArrayType"
    @obj
    external make: (~elementType: Type.t, ~finalArrayType: Type.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asObjectType: t => ObjectType.t = "%identity"
  }
  module ExclamationToken = {
    open ExclamationToken
    type t = PunctuationToken.t<SyntaxKind.ExclamationToken.t>
    type t0 = t
  }
  module ExitStatus = {
    open ExitStatus
    type t = t =   | Success
      | DiagnosticsPresent_OutputsSkipped
      | DiagnosticsPresent_OutputsGenerated
      | InvalidProject_OutputsSkipped
      | ProjectReferenceCycle_OutputsSkipped_ProjectReferenceCycle_OutputsSkupped
    type t_0 = t
    module Success = {
      open Success
      type t = t
      type t0 = t
      @module("typescript") @scope("ExitStatus") @val
      external value: t = "Success"
    }
    module DiagnosticsPresent_OutputsSkipped = {
      open DiagnosticsPresent_OutputsSkipped
      type t = t
      type t0 = t
      @module("typescript") @scope("ExitStatus") @val
      external value: t = "DiagnosticsPresent_OutputsSkipped"
    }
    module DiagnosticsPresent_OutputsGenerated = {
      open DiagnosticsPresent_OutputsGenerated
      type t = t
      type t0 = t
      @module("typescript") @scope("ExitStatus") @val
      external value: t = "DiagnosticsPresent_OutputsGenerated"
    }
    module InvalidProject_OutputsSkipped = {
      open InvalidProject_OutputsSkipped
      type t = t
      type t0 = t
      @module("typescript") @scope("ExitStatus") @val
      external value: t = "InvalidProject_OutputsSkipped"
    }
    module ProjectReferenceCycle_OutputsSkipped = {
      open ProjectReferenceCycle_OutputsSkipped
      type t = t
      type t0 = t
      @module("typescript") @scope("ExitStatus") @val
      external value: t = "ProjectReferenceCycle_OutputsSkipped"
    }
    module ProjectReferenceCycle_OutputsSkupped = {
      open ProjectReferenceCycle_OutputsSkupped
      type t = t
      type t0 = t
      @module("typescript") @scope("ExitStatus") @val
      external value: t = "ProjectReferenceCycle_OutputsSkupped"
    }
  }
  module ExponentiationOperator = {
    open ExponentiationOperator
    type t = SyntaxKind.AsteriskAsteriskToken.t
    type t0 = t
  }
  module ExportAssignment = {
    open ExportAssignment
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_DeclarationStatement | #Ts_ExportAssignment | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ExportAssignment ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ExportAssignment.t = "kind"
    @get
    external parent: this<'tags, 'base> => SourceFile.t = "parent"
    @get
    external isExportEquals: this<'tags, 'base> => bool = "isExportEquals"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.ExportAssignment.t, ~parent: SourceFile.t, ~isExportEquals: bool, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDeclarationStatement: t => DeclarationStatement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module ExportDeclaration = {
    open ExportDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_DeclarationStatement | #Ts_ExportDeclaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ExportDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ExportDeclaration.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t2<SourceFile.t, ModuleBlock.t> = "parent"
    @get
    external isTypeOnly: this<'tags, 'base> => bool = "isTypeOnly"
    @get
    external exportClause: this<'tags, 'base> => NamedExportBindings.t = "exportClause"
    @get
    external moduleSpecifier: this<'tags, 'base> => Expression.t = "moduleSpecifier"
    @get
    external assertClause: this<'tags, 'base> => AssertClause.t = "assertClause"
    @obj
    external make: (~kind: SyntaxKind.ExportDeclaration.t, ~parent: Union.t2<SourceFile.t, ModuleBlock.t>, ~isTypeOnly: bool, ~exportClause: NamedExportBindings.t, ~moduleSpecifier: Expression.t, ~assertClause: AssertClause.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDeclarationStatement: t => DeclarationStatement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module ExportKeyword = {
    open ExportKeyword
    type t = ModifierToken.t<SyntaxKind.ExportKeyword.t>
    type t0 = t
  }
  module ExportSpecifier = {
    open ExportSpecifier
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_ExportSpecifier | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ExportSpecifier ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ExportSpecifier.t = "kind"
    @get
    external parent: this<'tags, 'base> => NamedExports.t = "parent"
    @get
    external isTypeOnly: this<'tags, 'base> => bool = "isTypeOnly"
    @get
    external propertyName: this<'tags, 'base> => Identifier.t = "propertyName"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @obj
    external make: (~kind: SyntaxKind.ExportSpecifier.t, ~parent: NamedExports.t, ~isTypeOnly: bool, ~propertyName: Identifier.t, ~name: Identifier.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module Expression = {
    open Expression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Expression ]
    @get
    external get_expressionBrand: this<'tags, 'base> => any = "_expressionBrand"
    @set
    external set_expressionBrand: (this<'tags, 'base>, any) => unit = "_expressionBrand"
    @obj
    external make: ~\"_expressionBrand": any => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module ExpressionStatement = {
    open ExpressionStatement
    type t = t
    type t0 = t
    type tags = [#Ts_ExpressionStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ExpressionStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ExpressionStatement.t = "kind"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.ExpressionStatement.t, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module ExpressionWithTypeArguments = {
    open ExpressionWithTypeArguments
    type t = t
    type t0 = t
    type tags = [#Ts_ExpressionWithTypeArguments | #Ts_Node | #Ts_NodeWithTypeArguments | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ExpressionWithTypeArguments ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ExpressionWithTypeArguments.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t3<HeritageClause.t, JSDocAugmentsTag.t, JSDocImplementsTag.t> = "parent"
    @get
    external expression: this<'tags, 'base> => LeftHandSideExpression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.ExpressionWithTypeArguments.t, ~parent: Union.t3<HeritageClause.t, JSDocAugmentsTag.t, JSDocImplementsTag.t>, ~expression: LeftHandSideExpression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNodeWithTypeArguments: t => NodeWithTypeArguments.t = "%identity"
  }
  module ExtendedConfigCacheEntry = {
    open ExtendedConfigCacheEntry
    type t = t
    type t0 = t
    type tags = [#Ts_ExtendedConfigCacheEntry]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ExtendedConfigCacheEntry ]
    @get
    external getExtendedResult: this<'tags, 'base> => TsConfigSourceFile.t = "extendedResult"
    @set
    external setExtendedResult: (this<'tags, 'base>, TsConfigSourceFile.t) => unit = "extendedResult"
    @get @return(nullable)
    external getExtendedConfig: this<'tags, 'base> => option<ParsedTsconfig.t> = "extendedConfig"
    @set
    external setExtendedConfig: (this<'tags, 'base>, undefined<ParsedTsconfig.t>) => unit = "extendedConfig"
    @obj
    external make: (~extendedResult: TsConfigSourceFile.t, ~extendedConfig: ParsedTsconfig.t=?, unit) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module Extension = {
    open Extension
    type t = t
    type t_0 = t
    module Ts = {
      open Ts
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "Ts"
    }
    module Tsx = {
      open Tsx
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "Tsx"
    }
    module Dts = {
      open Dts
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "Dts"
    }
    module Js = {
      open Js
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "Js"
    }
    module Jsx = {
      open Jsx
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "Jsx"
    }
    module Json = {
      open Json
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "Json"
    }
    module TsBuildInfo = {
      open TsBuildInfo
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "TsBuildInfo"
    }
    module Mjs = {
      open Mjs
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "Mjs"
    }
    module Mts = {
      open Mts
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "Mts"
    }
    module Dmts = {
      open Dmts
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "Dmts"
    }
    module Cjs = {
      open Cjs
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "Cjs"
    }
    module Cts = {
      open Cts
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "Cts"
    }
    module Dcts = {
      open Dcts
      type t = t
      type t0 = t
      @module("typescript") @scope("Extension") @val
      external value: t = "Dcts"
    }
  }
  module ExternalModuleReference = {
    open ExternalModuleReference
    type t = t
    type t0 = t
    type tags = [#Ts_ExternalModuleReference | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ExternalModuleReference ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ExternalModuleReference.t = "kind"
    @get
    external parent: this<'tags, 'base> => ImportEqualsDeclaration.t = "parent"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.ExternalModuleReference.t, ~parent: ImportEqualsDeclaration.t, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module FalseLiteral = {
    open FalseLiteral
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_FalseLiteral | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FalseLiteral ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.FalseKeyword.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.FalseKeyword.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
  }
  module FileExtensionInfo = {
    open FileExtensionInfo
    type t = t
    type t0 = t
    type tags = [#Ts_FileExtensionInfo]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FileExtensionInfo ]
    @get
    external getExtension: this<'tags, 'base> => string = "extension"
    @set
    external setExtension: (this<'tags, 'base>, string) => unit = "extension"
    @get
    external getIsMixedContent: this<'tags, 'base> => bool = "isMixedContent"
    @set
    external setIsMixedContent: (this<'tags, 'base>, bool) => unit = "isMixedContent"
    @get
    external getScriptKind: this<'tags, 'base> => ScriptKind.t = "scriptKind"
    @set
    external setScriptKind: (this<'tags, 'base>, ScriptKind.t) => unit = "scriptKind"
    @obj
    external make: (~extension: string, ~isMixedContent: bool, ~scriptKind: ScriptKind.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module FileReference = {
    open FileReference
    type t = t
    type t0 = t
    type tags = [#Ts_FileReference | #Ts_TextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FileReference ]
    @get
    external getFileName: this<'tags, 'base> => string = "fileName"
    @set
    external setFileName: (this<'tags, 'base>, string) => unit = "fileName"
    @obj
    external make: ~fileName: string => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTextRange: t => TextRange.t = "%identity"
  }
  module FileTextChanges = {
    open FileTextChanges
    type t = t
    type t0 = t
    type tags = [#Ts_FileTextChanges]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FileTextChanges ]
    @get
    external getFileName: this<'tags, 'base> => string = "fileName"
    @set
    external setFileName: (this<'tags, 'base>, string) => unit = "fileName"
    @get
    external getTextChanges: this<'tags, 'base> => array<TextChange.t> = "textChanges"
    @set
    external setTextChanges: (this<'tags, 'base>, array<TextChange.t>) => unit = "textChanges"
    @get
    external getIsNewFile: this<'tags, 'base> => bool = "isNewFile"
    @set
    external setIsNewFile: (this<'tags, 'base>, bool) => unit = "isNewFile"
    @obj
    external make: (~fileName: string, ~textChanges: array<TextChange.t>, ~isNewFile: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module FileWatcher = {
    open FileWatcher
    type t = t
    type t0 = t
    type tags = [#Ts_FileWatcher]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FileWatcher ]
    @send
    external close: this<'tags, 'base> => unit = "close"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module FileWatcherCallback = {
    open FileWatcherCallback
    type t = (~fileName:string, ~eventKind:FileWatcherEventKind.t) => unit
    type t0 = t
  }
  module FileWatcherEventKind = {
    open FileWatcherEventKind
    type t = t = Created | Changed | Deleted
    type t_0 = t
    module Created = {
      open Created
      type t = t
      type t0 = t
      @module("typescript") @scope("FileWatcherEventKind") @val
      external value: t = "Created"
    }
    module Changed = {
      open Changed
      type t = t
      type t0 = t
      @module("typescript") @scope("FileWatcherEventKind") @val
      external value: t = "Changed"
    }
    module Deleted = {
      open Deleted
      type t = t
      type t0 = t
      @module("typescript") @scope("FileWatcherEventKind") @val
      external value: t = "Deleted"
    }
  }
  module FlowArrayMutation = {
    open FlowArrayMutation
    type t = t
    type t0 = t
    type tags = [#Ts_FlowArrayMutation | #Ts_FlowNodeBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FlowArrayMutation ]
    @get
    external getNode: this<'tags, 'base> => Union.t2<CallExpression.t, BinaryExpression.t> = "node"
    @set
    external setNode: (this<'tags, 'base>, Union.t2<CallExpression.t, BinaryExpression.t>) => unit = "node"
    @get
    external getAntecedent: this<'tags, 'base> => FlowNode.t = "antecedent"
    @set
    external setAntecedent: (this<'tags, 'base>, FlowNode.t) => unit = "antecedent"
    @obj
    external make: (~node: Union.t2<CallExpression.t, BinaryExpression.t>, ~antecedent: FlowNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFlowNodeBase: t => FlowNodeBase.t = "%identity"
  }
  module FlowAssignment = {
    open FlowAssignment
    type t = t
    type t0 = t
    type tags = [#Ts_FlowAssignment | #Ts_FlowNodeBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FlowAssignment ]
    @get
    external getNode: this<'tags, 'base> => Union.t3<Expression.t, VariableDeclaration.t, BindingElement.t> = "node"
    @set
    external setNode: (this<'tags, 'base>, Union.t3<Expression.t, VariableDeclaration.t, BindingElement.t>) => unit = "node"
    @get
    external getAntecedent: this<'tags, 'base> => FlowNode.t = "antecedent"
    @set
    external setAntecedent: (this<'tags, 'base>, FlowNode.t) => unit = "antecedent"
    @obj
    external make: (~node: Union.t3<Expression.t, VariableDeclaration.t, BindingElement.t>, ~antecedent: FlowNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFlowNodeBase: t => FlowNodeBase.t = "%identity"
  }
  module FlowCall = {
    open FlowCall
    type t = t
    type t0 = t
    type tags = [#Ts_FlowCall | #Ts_FlowNodeBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FlowCall ]
    @get
    external getNode: this<'tags, 'base> => CallExpression.t = "node"
    @set
    external setNode: (this<'tags, 'base>, CallExpression.t) => unit = "node"
    @get
    external getAntecedent: this<'tags, 'base> => FlowNode.t = "antecedent"
    @set
    external setAntecedent: (this<'tags, 'base>, FlowNode.t) => unit = "antecedent"
    @obj
    external make: (~node: CallExpression.t, ~antecedent: FlowNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFlowNodeBase: t => FlowNodeBase.t = "%identity"
  }
  module FlowCondition = {
    open FlowCondition
    type t = t
    type t0 = t
    type tags = [#Ts_FlowCondition | #Ts_FlowNodeBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FlowCondition ]
    @get
    external getNode: this<'tags, 'base> => Expression.t = "node"
    @set
    external setNode: (this<'tags, 'base>, Expression.t) => unit = "node"
    @get
    external getAntecedent: this<'tags, 'base> => FlowNode.t = "antecedent"
    @set
    external setAntecedent: (this<'tags, 'base>, FlowNode.t) => unit = "antecedent"
    @obj
    external make: (~node: Expression.t, ~antecedent: FlowNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFlowNodeBase: t => FlowNodeBase.t = "%identity"
  }
  module FlowFlags = {
    open FlowFlags
    type t = t
    type t_0 = t
    module Unreachable = {
      open Unreachable
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "Unreachable"
    }
    module Start = {
      open Start
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "Start"
    }
    module BranchLabel = {
      open BranchLabel
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "BranchLabel"
    }
    module LoopLabel = {
      open LoopLabel
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "LoopLabel"
    }
    module Assignment = {
      open Assignment
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "Assignment"
    }
    module TrueCondition = {
      open TrueCondition
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "TrueCondition"
    }
    module FalseCondition = {
      open FalseCondition
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "FalseCondition"
    }
    module SwitchClause = {
      open SwitchClause
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "SwitchClause"
    }
    module ArrayMutation = {
      open ArrayMutation
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "ArrayMutation"
    }
    module Call = {
      open Call
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "Call"
    }
    module ReduceLabel = {
      open ReduceLabel
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "ReduceLabel"
    }
    module Referenced = {
      open Referenced
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "Referenced"
    }
    module Shared = {
      open Shared
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "Shared"
    }
    module Label = {
      open Label
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "Label"
    }
    module Condition = {
      open Condition
      type t = t
      type t0 = t
      @module("typescript") @scope("FlowFlags") @val
      external value: t = "Condition"
    }
  }
  module FlowLabel = {
    open FlowLabel
    type t = t
    type t0 = t
    type tags = [#Ts_FlowLabel | #Ts_FlowNodeBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FlowLabel ]
    @get @return(nullable)
    external getAntecedents: this<'tags, 'base> => option<array<FlowNode.t>> = "antecedents"
    @set
    external setAntecedents: (this<'tags, 'base>, undefined<array<FlowNode.t>>) => unit = "antecedents"
    @obj
    external make: (~antecedents: array<FlowNode.t>=?, unit) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFlowNodeBase: t => FlowNodeBase.t = "%identity"
  }
  module FlowNode = {
    open FlowNode
    type t = Union.t8<FlowStart.t, FlowLabel.t, FlowAssignment.t, FlowCall.t, FlowCondition.t, FlowSwitchClause.t, FlowArrayMutation.t, Union.t2<FlowCall.t, FlowReduceLabel.t>>
    type t0 = t
  }
  module FlowNodeBase = {
    open FlowNodeBase
    type t = t
    type t0 = t
    type tags = [#Ts_FlowNodeBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FlowNodeBase ]
    @get
    external getFlags: this<'tags, 'base> => FlowFlags.t = "flags"
    @set
    external setFlags: (this<'tags, 'base>, FlowFlags.t) => unit = "flags"
    @get
    external getId: this<'tags, 'base> => float = "id"
    @set
    external setId: (this<'tags, 'base>, float) => unit = "id"
    @obj
    external make: (~flags: FlowFlags.t, ~id: float) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module FlowReduceLabel = {
    open FlowReduceLabel
    type t = t
    type t0 = t
    type tags = [#Ts_FlowNodeBase | #Ts_FlowReduceLabel]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FlowReduceLabel ]
    @get
    external getTarget: this<'tags, 'base> => FlowLabel.t = "target"
    @set
    external setTarget: (this<'tags, 'base>, FlowLabel.t) => unit = "target"
    @get
    external getAntecedents: this<'tags, 'base> => array<FlowNode.t> = "antecedents"
    @set
    external setAntecedents: (this<'tags, 'base>, array<FlowNode.t>) => unit = "antecedents"
    @get
    external getAntecedent: this<'tags, 'base> => FlowNode.t = "antecedent"
    @set
    external setAntecedent: (this<'tags, 'base>, FlowNode.t) => unit = "antecedent"
    @obj
    external make: (~target: FlowLabel.t, ~antecedents: array<FlowNode.t>, ~antecedent: FlowNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFlowNodeBase: t => FlowNodeBase.t = "%identity"
  }
  module FlowStart = {
    open FlowStart
    type t = t
    type t0 = t
    type tags = [#Ts_FlowNodeBase | #Ts_FlowStart]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FlowStart ]
    @get
    external getNode: this<'tags, 'base> => Union.t5<FunctionExpression.t, ArrowFunction.t, MethodDeclaration.t, GetAccessorDeclaration.t, SetAccessorDeclaration.t> = "node"
    @set
    external setNode: (this<'tags, 'base>, Union.t5<FunctionExpression.t, ArrowFunction.t, MethodDeclaration.t, GetAccessorDeclaration.t, SetAccessorDeclaration.t>) => unit = "node"
    @obj
    external make: ~node: Union.t5<FunctionExpression.t, ArrowFunction.t, MethodDeclaration.t, GetAccessorDeclaration.t, SetAccessorDeclaration.t> => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFlowNodeBase: t => FlowNodeBase.t = "%identity"
  }
  module FlowSwitchClause = {
    open FlowSwitchClause
    type t = t
    type t0 = t
    type tags = [#Ts_FlowNodeBase | #Ts_FlowSwitchClause]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FlowSwitchClause ]
    @get
    external getSwitchStatement: this<'tags, 'base> => SwitchStatement.t = "switchStatement"
    @set
    external setSwitchStatement: (this<'tags, 'base>, SwitchStatement.t) => unit = "switchStatement"
    @get
    external getClauseStart: this<'tags, 'base> => float = "clauseStart"
    @set
    external setClauseStart: (this<'tags, 'base>, float) => unit = "clauseStart"
    @get
    external getClauseEnd: this<'tags, 'base> => float = "clauseEnd"
    @set
    external setClauseEnd: (this<'tags, 'base>, float) => unit = "clauseEnd"
    @get
    external getAntecedent: this<'tags, 'base> => FlowNode.t = "antecedent"
    @set
    external setAntecedent: (this<'tags, 'base>, FlowNode.t) => unit = "antecedent"
    @obj
    external make: (~switchStatement: SwitchStatement.t, ~clauseStart: float, ~clauseEnd: float, ~antecedent: FlowNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFlowNodeBase: t => FlowNodeBase.t = "%identity"
  }
  module FlowType = {
    open FlowType
    type t = Union.t2<Type.t, IncompleteType.t>
    type t0 = t
  }
  module ForInOrOfStatement = {
    open ForInOrOfStatement
    type t = Union.t2<ForInStatement.t, ForOfStatement.t>
    type t0 = t
  }
  module ForInStatement = {
    open ForInStatement
    type t = t
    type t0 = t
    type tags = [#Ts_ForInStatement | #Ts_IterationStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ForInStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ForInStatement.t = "kind"
    @get
    external initializer: this<'tags, 'base> => ForInitializer.t = "initializer"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.ForInStatement.t, ~initializer: ForInitializer.t, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asIterationStatement: t => IterationStatement.t = "%identity"
  }
  module ForInitializer = {
    open ForInitializer
    type t = Union.t2<VariableDeclarationList.t, Expression.t>
    type t0 = t
  }
  module ForOfStatement = {
    open ForOfStatement
    type t = t
    type t0 = t
    type tags = [#Ts_ForOfStatement | #Ts_IterationStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ForOfStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ForOfStatement.t = "kind"
    @get
    external awaitModifier: this<'tags, 'base> => AwaitKeyword.t = "awaitModifier"
    @get
    external initializer: this<'tags, 'base> => ForInitializer.t = "initializer"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.ForOfStatement.t, ~awaitModifier: AwaitKeyword.t, ~initializer: ForInitializer.t, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asIterationStatement: t => IterationStatement.t = "%identity"
  }
  module ForStatement = {
    open ForStatement
    type t = t
    type t0 = t
    type tags = [#Ts_ForStatement | #Ts_IterationStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ForStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ForStatement.t = "kind"
    @get
    external initializer: this<'tags, 'base> => ForInitializer.t = "initializer"
    @get
    external condition: this<'tags, 'base> => Expression.t = "condition"
    @get
    external incrementor: this<'tags, 'base> => Expression.t = "incrementor"
    @obj
    external make: (~kind: SyntaxKind.ForStatement.t, ~initializer: ForInitializer.t, ~condition: Expression.t, ~incrementor: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asIterationStatement: t => IterationStatement.t = "%identity"
  }
  module FormatCodeOptions = {
    open FormatCodeOptions
    type t = t
    type t0 = t
    type tags = [#Ts_EditorOptions | #Ts_FormatCodeOptions]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FormatCodeOptions ]
    @get
    external getInsertSpaceAfterCommaDelimiter: this<'tags, 'base> => bool = "InsertSpaceAfterCommaDelimiter"
    @set
    external setInsertSpaceAfterCommaDelimiter: (this<'tags, 'base>, bool) => unit = "InsertSpaceAfterCommaDelimiter"
    @get
    external getInsertSpaceAfterSemicolonInForStatements: this<'tags, 'base> => bool = "InsertSpaceAfterSemicolonInForStatements"
    @set
    external setInsertSpaceAfterSemicolonInForStatements: (this<'tags, 'base>, bool) => unit = "InsertSpaceAfterSemicolonInForStatements"
    @get
    external getInsertSpaceBeforeAndAfterBinaryOperators: this<'tags, 'base> => bool = "InsertSpaceBeforeAndAfterBinaryOperators"
    @set
    external setInsertSpaceBeforeAndAfterBinaryOperators: (this<'tags, 'base>, bool) => unit = "InsertSpaceBeforeAndAfterBinaryOperators"
    @get
    external getInsertSpaceAfterConstructor: this<'tags, 'base> => bool = "InsertSpaceAfterConstructor"
    @set
    external setInsertSpaceAfterConstructor: (this<'tags, 'base>, bool) => unit = "InsertSpaceAfterConstructor"
    @get
    external getInsertSpaceAfterKeywordsInControlFlowStatements: this<'tags, 'base> => bool = "InsertSpaceAfterKeywordsInControlFlowStatements"
    @set
    external setInsertSpaceAfterKeywordsInControlFlowStatements: (this<'tags, 'base>, bool) => unit = "InsertSpaceAfterKeywordsInControlFlowStatements"
    @get
    external getInsertSpaceAfterFunctionKeywordForAnonymousFunctions: this<'tags, 'base> => bool = "InsertSpaceAfterFunctionKeywordForAnonymousFunctions"
    @set
    external setInsertSpaceAfterFunctionKeywordForAnonymousFunctions: (this<'tags, 'base>, bool) => unit = "InsertSpaceAfterFunctionKeywordForAnonymousFunctions"
    @get
    external getInsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: this<'tags, 'base> => bool = "InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"
    @set
    external setInsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: (this<'tags, 'base>, bool) => unit = "InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"
    @get
    external getInsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: this<'tags, 'base> => bool = "InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"
    @set
    external setInsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: (this<'tags, 'base>, bool) => unit = "InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"
    @get
    external getInsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: this<'tags, 'base> => bool = "InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"
    @set
    external setInsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: (this<'tags, 'base>, bool) => unit = "InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"
    @get
    external getInsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: this<'tags, 'base> => bool = "InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"
    @set
    external setInsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: (this<'tags, 'base>, bool) => unit = "InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"
    @get
    external getInsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: this<'tags, 'base> => bool = "InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"
    @set
    external setInsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: (this<'tags, 'base>, bool) => unit = "InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"
    @get
    external getInsertSpaceAfterTypeAssertion: this<'tags, 'base> => bool = "InsertSpaceAfterTypeAssertion"
    @set
    external setInsertSpaceAfterTypeAssertion: (this<'tags, 'base>, bool) => unit = "InsertSpaceAfterTypeAssertion"
    @get
    external getInsertSpaceBeforeFunctionParenthesis: this<'tags, 'base> => bool = "InsertSpaceBeforeFunctionParenthesis"
    @set
    external setInsertSpaceBeforeFunctionParenthesis: (this<'tags, 'base>, bool) => unit = "InsertSpaceBeforeFunctionParenthesis"
    @get
    external getPlaceOpenBraceOnNewLineForFunctions: this<'tags, 'base> => bool = "PlaceOpenBraceOnNewLineForFunctions"
    @set
    external setPlaceOpenBraceOnNewLineForFunctions: (this<'tags, 'base>, bool) => unit = "PlaceOpenBraceOnNewLineForFunctions"
    @get
    external getPlaceOpenBraceOnNewLineForControlBlocks: this<'tags, 'base> => bool = "PlaceOpenBraceOnNewLineForControlBlocks"
    @set
    external setPlaceOpenBraceOnNewLineForControlBlocks: (this<'tags, 'base>, bool) => unit = "PlaceOpenBraceOnNewLineForControlBlocks"
    @get
    external getInsertSpaceBeforeTypeAnnotation: this<'tags, 'base> => bool = "insertSpaceBeforeTypeAnnotation"
    @set
    external setInsertSpaceBeforeTypeAnnotation: (this<'tags, 'base>, bool) => unit = "insertSpaceBeforeTypeAnnotation"
    @obj
    external make: (~insertSpaceAfterCommaDelimiter: bool, ~insertSpaceAfterSemicolonInForStatements: bool, ~insertSpaceBeforeAndAfterBinaryOperators: bool, ~insertSpaceAfterConstructor: bool, ~insertSpaceAfterKeywordsInControlFlowStatements: bool, ~insertSpaceAfterFunctionKeywordForAnonymousFunctions: bool, ~insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: bool, ~insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: bool, ~insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: bool, ~insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: bool, ~insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: bool, ~insertSpaceAfterTypeAssertion: bool, ~insertSpaceBeforeFunctionParenthesis: bool, ~placeOpenBraceOnNewLineForFunctions: bool, ~placeOpenBraceOnNewLineForControlBlocks: bool, ~insertSpaceBeforeTypeAnnotation: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asEditorOptions: t => EditorOptions.t = "%identity"
  }
  module FormatCodeSettings = {
    open FormatCodeSettings
    type t = t
    type t0 = t
    type tags = [#Ts_EditorSettings | #Ts_FormatCodeSettings]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FormatCodeSettings ]
    @get
    external insertSpaceAfterCommaDelimiter: this<'tags, 'base> => bool = "insertSpaceAfterCommaDelimiter"
    @get
    external insertSpaceAfterSemicolonInForStatements: this<'tags, 'base> => bool = "insertSpaceAfterSemicolonInForStatements"
    @get
    external insertSpaceBeforeAndAfterBinaryOperators: this<'tags, 'base> => bool = "insertSpaceBeforeAndAfterBinaryOperators"
    @get
    external insertSpaceAfterConstructor: this<'tags, 'base> => bool = "insertSpaceAfterConstructor"
    @get
    external insertSpaceAfterKeywordsInControlFlowStatements: this<'tags, 'base> => bool = "insertSpaceAfterKeywordsInControlFlowStatements"
    @get
    external insertSpaceAfterFunctionKeywordForAnonymousFunctions: this<'tags, 'base> => bool = "insertSpaceAfterFunctionKeywordForAnonymousFunctions"
    @get
    external insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: this<'tags, 'base> => bool = "insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"
    @get
    external insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: this<'tags, 'base> => bool = "insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"
    @get
    external insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: this<'tags, 'base> => bool = "insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"
    @get
    external insertSpaceAfterOpeningAndBeforeClosingEmptyBraces: this<'tags, 'base> => bool = "insertSpaceAfterOpeningAndBeforeClosingEmptyBraces"
    @get
    external insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: this<'tags, 'base> => bool = "insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"
    @get
    external insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: this<'tags, 'base> => bool = "insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"
    @get
    external insertSpaceAfterTypeAssertion: this<'tags, 'base> => bool = "insertSpaceAfterTypeAssertion"
    @get
    external insertSpaceBeforeFunctionParenthesis: this<'tags, 'base> => bool = "insertSpaceBeforeFunctionParenthesis"
    @get
    external placeOpenBraceOnNewLineForFunctions: this<'tags, 'base> => bool = "placeOpenBraceOnNewLineForFunctions"
    @get
    external placeOpenBraceOnNewLineForControlBlocks: this<'tags, 'base> => bool = "placeOpenBraceOnNewLineForControlBlocks"
    @get
    external insertSpaceBeforeTypeAnnotation: this<'tags, 'base> => bool = "insertSpaceBeforeTypeAnnotation"
    @get
    external indentMultiLineObjectLiteralBeginningOnBlankLine: this<'tags, 'base> => bool = "indentMultiLineObjectLiteralBeginningOnBlankLine"
    @get
    external semicolons: this<'tags, 'base> => SemicolonPreference.t = "semicolons"
    @obj
    external make: (~insertSpaceAfterCommaDelimiter: bool, ~insertSpaceAfterSemicolonInForStatements: bool, ~insertSpaceBeforeAndAfterBinaryOperators: bool, ~insertSpaceAfterConstructor: bool, ~insertSpaceAfterKeywordsInControlFlowStatements: bool, ~insertSpaceAfterFunctionKeywordForAnonymousFunctions: bool, ~insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: bool, ~insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: bool, ~insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: bool, ~insertSpaceAfterOpeningAndBeforeClosingEmptyBraces: bool, ~insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: bool, ~insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: bool, ~insertSpaceAfterTypeAssertion: bool, ~insertSpaceBeforeFunctionParenthesis: bool, ~placeOpenBraceOnNewLineForFunctions: bool, ~placeOpenBraceOnNewLineForControlBlocks: bool, ~insertSpaceBeforeTypeAnnotation: bool, ~indentMultiLineObjectLiteralBeginningOnBlankLine: bool, ~semicolons: SemicolonPreference.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asEditorSettings: t => EditorSettings.t = "%identity"
  }
  module FormatDiagnosticsHost = {
    open FormatDiagnosticsHost
    type t = t
    type t0 = t
    type tags = [#Ts_FormatDiagnosticsHost]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FormatDiagnosticsHost ]
    @send
    external getCurrentDirectory: this<'tags, 'base> => string = "getCurrentDirectory"
    @send
    external getCanonicalFileName: (this<'tags, 'base>, ~fileName:string) => string = "getCanonicalFileName"
    @send
    external getNewLine: this<'tags, 'base> => string = "getNewLine"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module FunctionBody = {
    open FunctionBody
    type t = Block.t
    type t0 = t
  }
  module FunctionDeclaration = {
    open FunctionDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_DeclarationStatement | #Ts_FunctionDeclaration | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FunctionDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.FunctionDeclaration.t = "kind"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external body: this<'tags, 'base> => FunctionBody.t = "body"
    @obj
    external make: (~kind: SyntaxKind.FunctionDeclaration.t, ~name: Identifier.t, ~body: FunctionBody.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFunctionLikeDeclarationBase: t => FunctionLikeDeclarationBase.t = "%identity"
    external asDeclarationStatement: t => DeclarationStatement.t = "%identity"
  }
  module FunctionExpression = {
    open FunctionExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Expression | #Ts_FunctionExpression | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FunctionExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.FunctionExpression.t = "kind"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external body: this<'tags, 'base> => FunctionBody.t = "body"
    @obj
    external make: (~kind: SyntaxKind.FunctionExpression.t, ~name: Identifier.t, ~body: FunctionBody.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
    external asFunctionLikeDeclarationBase: t => FunctionLikeDeclarationBase.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module FunctionLike = {
    open FunctionLike
    type t = SignatureDeclaration.t
    type t0 = t
  }
  module FunctionLikeDeclaration = {
    open FunctionLikeDeclaration
    type t = Union.t7<FunctionDeclaration.t, MethodDeclaration.t, GetAccessorDeclaration.t, SetAccessorDeclaration.t, ConstructorDeclaration.t, FunctionExpression.t, ArrowFunction.t>
    type t0 = t
  }
  module FunctionLikeDeclarationBase = {
    open FunctionLikeDeclarationBase
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FunctionLikeDeclarationBase ]
    @get
    external get_functionLikeDeclarationBrand: this<'tags, 'base> => any = "_functionLikeDeclarationBrand"
    @set
    external set_functionLikeDeclarationBrand: (this<'tags, 'base>, any) => unit = "_functionLikeDeclarationBrand"
    @get
    external asteriskToken: this<'tags, 'base> => AsteriskToken.t = "asteriskToken"
    @get
    external questionToken: this<'tags, 'base> => QuestionToken.t = "questionToken"
    @get
    external exclamationToken: this<'tags, 'base> => ExclamationToken.t = "exclamationToken"
    @get
    external body: this<'tags, 'base> => Union.t2<Block.t, Expression.t> = "body"
    @obj
    external make: (~\"_functionLikeDeclarationBrand": any, ~asteriskToken: AsteriskToken.t, ~questionToken: QuestionToken.t, ~exclamationToken: ExclamationToken.t, ~body: Union.t2<Block.t, Expression.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asSignatureDeclarationBase: t => SignatureDeclarationBase.t = "%identity"
  }
  module FunctionOrConstructorTypeNode = {
    open FunctionOrConstructorTypeNode
    type t = Union.t2<FunctionTypeNode.t, ConstructorTypeNode.t>
    type t0 = t
  }
  module FunctionOrConstructorTypeNodeBase = {
    open FunctionOrConstructorTypeNodeBase
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_FunctionOrConstructorTypeNodeBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FunctionOrConstructorTypeNodeBase ]
    @get
    external kind: this<'tags, 'base> => Union.t2<SyntaxKind.FunctionType.t, SyntaxKind.ConstructorType.t> = "kind"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: Union.t2<SyntaxKind.FunctionType.t, SyntaxKind.ConstructorType.t>, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
    external asSignatureDeclarationBase: t => SignatureDeclarationBase.t = "%identity"
  }
  module FunctionTypeNode = {
    open FunctionTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_FunctionOrConstructorTypeNodeBase | #Ts_FunctionTypeNode | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_FunctionTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.FunctionType.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.FunctionType.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFunctionOrConstructorTypeNodeBase: t => FunctionOrConstructorTypeNodeBase.t = "%identity"
  }
  module GeneratedIdentifierFlags = {
    open GeneratedIdentifierFlags
    type t = t
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("GeneratedIdentifierFlags") @val
      external value: t = "None"
    }
    module ReservedInNestedScopes = {
      open ReservedInNestedScopes
      type t = t
      type t0 = t
      @module("typescript") @scope("GeneratedIdentifierFlags") @val
      external value: t = "ReservedInNestedScopes"
    }
    module Optimistic = {
      open Optimistic
      type t = t
      type t0 = t
      @module("typescript") @scope("GeneratedIdentifierFlags") @val
      external value: t = "Optimistic"
    }
    module FileLevel = {
      open FileLevel
      type t = t
      type t0 = t
      @module("typescript") @scope("GeneratedIdentifierFlags") @val
      external value: t = "FileLevel"
    }
    module AllowNameSubstitution = {
      open AllowNameSubstitution
      type t = t
      type t0 = t
      @module("typescript") @scope("GeneratedIdentifierFlags") @val
      external value: t = "AllowNameSubstitution"
    }
  }
  module GenericType = {
    open GenericType
    type t = t
    type t0 = t
    type tags = [#Ts_GenericType | #Ts_InterfaceType | #Ts_ObjectType | #Ts_Type | #Ts_TypeReference]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_GenericType ]
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asInterfaceType: t => InterfaceType.t = "%identity"
    external asTypeReference: t => TypeReference.t = "%identity"
  }
  module GetAccessorDeclaration = {
    open GetAccessorDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_ClassElement | #Ts_Declaration | #Ts_FunctionLikeDeclarationBase | #Ts_GetAccessorDeclaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeElement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_GetAccessorDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.GetAccessor.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t4<ClassLikeDeclaration.t, ObjectLiteralExpression.t, TypeLiteralNode.t, InterfaceDeclaration.t> = "parent"
    @get
    external name: this<'tags, 'base> => PropertyName.t = "name"
    @get
    external body: this<'tags, 'base> => FunctionBody.t = "body"
    @obj
    external make: (~kind: SyntaxKind.GetAccessor.t, ~parent: Union.t4<ClassLikeDeclaration.t, ObjectLiteralExpression.t, TypeLiteralNode.t, InterfaceDeclaration.t>, ~name: PropertyName.t, ~body: FunctionBody.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFunctionLikeDeclarationBase: t => FunctionLikeDeclarationBase.t = "%identity"
    external asClassElement: t => ClassElement.t = "%identity"
    external asTypeElement: t => TypeElement.t = "%identity"
    external asObjectLiteralElement: t => ObjectLiteralElement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module GetCompletionsAtPositionOptions = {
    open GetCompletionsAtPositionOptions
    type t = t
    type t0 = t
    type tags = [#Ts_GetCompletionsAtPositionOptions | #Ts_UserPreferences]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_GetCompletionsAtPositionOptions ]
    @get
    external getTriggerCharacter: this<'tags, 'base> => CompletionsTriggerCharacter.t = "triggerCharacter"
    @set
    external setTriggerCharacter: (this<'tags, 'base>, CompletionsTriggerCharacter.t) => unit = "triggerCharacter"
    @get
    external getTriggerKind: this<'tags, 'base> => CompletionTriggerKind.t = "triggerKind"
    @set
    external setTriggerKind: (this<'tags, 'base>, CompletionTriggerKind.t) => unit = "triggerKind"
    @get
    external getIncludeExternalModuleExports: this<'tags, 'base> => bool = "includeExternalModuleExports"
    @set
    external setIncludeExternalModuleExports: (this<'tags, 'base>, bool) => unit = "includeExternalModuleExports"
    @get
    external getIncludeInsertTextCompletions: this<'tags, 'base> => bool = "includeInsertTextCompletions"
    @set
    external setIncludeInsertTextCompletions: (this<'tags, 'base>, bool) => unit = "includeInsertTextCompletions"
    @obj
    external make: (~triggerCharacter: CompletionsTriggerCharacter.t, ~triggerKind: CompletionTriggerKind.t, ~includeExternalModuleExports: bool, ~includeInsertTextCompletions: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asUserPreferences: t => UserPreferences.t = "%identity"
  }
  module GetEffectiveTypeRootsHost = {
    open GetEffectiveTypeRootsHost
    type t = t
    type t0 = t
    type tags = [#Ts_GetEffectiveTypeRootsHost]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_GetEffectiveTypeRootsHost ]
    @send
    external directoryExists: (this<'tags, 'base>, ~directoryName:string) => bool = "directoryExists"
    @send
    external getCurrentDirectory: this<'tags, 'base> => string = "getCurrentDirectory"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module HasExpressionInitializer = {
    open HasExpressionInitializer
    type t = Union.t7<VariableDeclaration.t, ParameterDeclaration.t, BindingElement.t, PropertySignature.t, PropertyDeclaration.t, PropertyAssignment.t, EnumMember.t>
    type t0 = t
  }
  module HasInitializer = {
    open HasInitializer
    type t = Union.t5<HasExpressionInitializer.t, ForStatement.t, ForInStatement.t, ForOfStatement.t, JsxAttribute.t>
    type t0 = t
  }
  module HasJSDoc = {
    open HasJSDoc
    type t = Union.t8<ParameterDeclaration.t, CallSignatureDeclaration.t, ClassStaticBlockDeclaration.t, ConstructSignatureDeclaration.t, MethodSignature.t, PropertySignature.t, ArrowFunction.t, Union.t8<ParenthesizedExpression.t, SpreadAssignment.t, ShorthandPropertyAssignment.t, PropertyAssignment.t, FunctionExpression.t, EmptyStatement.t, DebuggerStatement.t, Union.t8<Block.t, VariableStatement.t, ExpressionStatement.t, IfStatement.t, DoStatement.t, WhileStatement.t, ForStatement.t, Union.t8<ForInStatement.t, ForOfStatement.t, BreakStatement.t, ContinueStatement.t, ReturnStatement.t, WithStatement.t, SwitchStatement.t, Union.t8<LabeledStatement.t, ThrowStatement.t, TryStatement.t, FunctionDeclaration.t, ConstructorDeclaration.t, MethodDeclaration.t, VariableDeclaration.t, Union.t8<PropertyDeclaration.t, AccessorDeclaration.t, ClassLikeDeclaration.t, InterfaceDeclaration.t, TypeAliasDeclaration.t, EnumMember.t, EnumDeclaration.t, Union.t8<ModuleDeclaration.t, ImportEqualsDeclaration.t, ImportDeclaration.t, NamespaceExportDeclaration.t, ExportAssignment.t, IndexSignatureDeclaration.t, FunctionTypeNode.t, Union.t6<ConstructorTypeNode.t, JSDocFunctionType.t, ExportDeclaration.t, NamedTupleMember.t, ExportSpecifier.t, EndOfFileToken.t>>>>>>>>
    type t0 = t
  }
  module HasType = {
    open HasType
    type t = Union.t8<SignatureDeclaration.t, VariableDeclaration.t, ParameterDeclaration.t, PropertySignature.t, PropertyDeclaration.t, TypePredicateNode.t, ParenthesizedTypeNode.t, Union.t8<TypeOperatorNode.t, MappedTypeNode.t, AssertionExpression.t, TypeAliasDeclaration.t, JSDocTypeExpression.t, JSDocNonNullableType.t, JSDocNullableType.t, Union.t2<JSDocOptionalType.t, JSDocVariadicType.t>>>
    type t0 = t
  }
  module HasTypeArguments = {
    open HasTypeArguments
    type t = Union.t5<CallExpression.t, NewExpression.t, TaggedTemplateExpression.t, JsxOpeningElement.t, JsxSelfClosingElement.t>
    type t0 = t
  }
  module HeritageClause = {
    open HeritageClause
    type t = t
    type t0 = t
    type tags = [#Ts_HeritageClause | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_HeritageClause ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.HeritageClause.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t2<InterfaceDeclaration.t, ClassLikeDeclaration.t> = "parent"
    @get
    external token: this<'tags, 'base> => Union.t2<SyntaxKind.ExtendsKeyword.t, SyntaxKind.ImplementsKeyword.t> = "token"
    @get
    external types: this<'tags, 'base> => NodeArray.t<ExpressionWithTypeArguments.t> = "types"
    @obj
    external make: (~kind: SyntaxKind.HeritageClause.t, ~parent: Union.t2<InterfaceDeclaration.t, ClassLikeDeclaration.t>, ~token: Union.t2<SyntaxKind.ExtendsKeyword.t, SyntaxKind.ImplementsKeyword.t>, ~types: NodeArray.t<ExpressionWithTypeArguments.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module HighlightSpan = {
    open HighlightSpan
    type t = t
    type t0 = t
    type tags = [#Ts_HighlightSpan]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_HighlightSpan ]
    @get
    external getFileName: this<'tags, 'base> => string = "fileName"
    @set
    external setFileName: (this<'tags, 'base>, string) => unit = "fileName"
    @get
    external getIsInString: this<'tags, 'base> => \"true" = "isInString"
    @set
    external setIsInString: (this<'tags, 'base>, \"true") => unit = "isInString"
    @get
    external getTextSpan: this<'tags, 'base> => TextSpan.t = "textSpan"
    @set
    external setTextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "textSpan"
    @get
    external getContextSpan: this<'tags, 'base> => TextSpan.t = "contextSpan"
    @set
    external setContextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "contextSpan"
    @get
    external getKind: this<'tags, 'base> => HighlightSpanKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, HighlightSpanKind.t) => unit = "kind"
    @obj
    external make: (~fileName: string, ~isInString: \"true", ~textSpan: TextSpan.t, ~contextSpan: TextSpan.t, ~kind: HighlightSpanKind.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module HighlightSpanKind = {
    open HighlightSpanKind
    type t = t
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("HighlightSpanKind") @val
      external value: t = "none"
    }
    module Definition = {
      open Definition
      type t = t
      type t0 = t
      @module("typescript") @scope("HighlightSpanKind") @val
      external value: t = "definition"
    }
    module Reference = {
      open Reference
      type t = t
      type t0 = t
      @module("typescript") @scope("HighlightSpanKind") @val
      external value: t = "reference"
    }
    module WrittenReference = {
      open WrittenReference
      type t = t
      type t0 = t
      @module("typescript") @scope("HighlightSpanKind") @val
      external value: t = "writtenReference"
    }
  }
  module HostCancellationToken = {
    open HostCancellationToken
    type t = t
    type t0 = t
    type tags = [#Ts_HostCancellationToken]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_HostCancellationToken ]
    @send
    external isCancellationRequested: this<'tags, 'base> => bool = "isCancellationRequested"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module IScriptSnapshot = {
    open IScriptSnapshot
    type t = t
    type t0 = t
    type tags = [#Ts_IScriptSnapshot]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IScriptSnapshot ]
    @send
    external getText: (this<'tags, 'base>, ~start:float, ~end:float) => string = "getText"
    @send
    external getLength: this<'tags, 'base> => float = "getLength"
    @send @return(nullable)
    external getChangeRange: (this<'tags, 'base>, ~oldSnapshot:t) => option<TextChangeRange.t> = "getChangeRange"
    @send
    external dispose: this<'tags, 'base> => unit = "dispose"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module Identifier = {
    open Identifier
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Expression | #Ts_Identifier | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Identifier ]
    @get
    external text: this<'tags, 'base> => string = "text"
    @get
    external kind: this<'tags, 'base> => SyntaxKind.Identifier.t = "kind"
    @get
    external escapedText: this<'tags, 'base> => M__String.t = "escapedText"
    @get
    external originalKeywordKind: this<'tags, 'base> => SyntaxKind.t = "originalKeywordKind"
    @get
    external getIsInJSDocNamespace: this<'tags, 'base> => bool = "isInJSDocNamespace"
    @set
    external setIsInJSDocNamespace: (this<'tags, 'base>, bool) => unit = "isInJSDocNamespace"
    @obj
    external make: (~text: string, ~kind: SyntaxKind.Identifier.t, ~escapedText: M__String.t, ~originalKeywordKind: SyntaxKind.t, ~isInJSDocNamespace: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module IdentifierTypePredicate = {
    open IdentifierTypePredicate
    type t = t
    type t0 = t
    type tags = [#Ts_IdentifierTypePredicate | #Ts_TypePredicateBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IdentifierTypePredicate ]
    @get
    external getKind: this<'tags, 'base> => TypePredicateKind.Identifier.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, TypePredicateKind.Identifier.t) => unit = "kind"
    @get
    external getParameterName: this<'tags, 'base> => string = "parameterName"
    @set
    external setParameterName: (this<'tags, 'base>, string) => unit = "parameterName"
    @get
    external getParameterIndex: this<'tags, 'base> => float = "parameterIndex"
    @set
    external setParameterIndex: (this<'tags, 'base>, float) => unit = "parameterIndex"
    @get
    external getType: this<'tags, 'base> => Type.t = "type"
    @set
    external setType: (this<'tags, 'base>, Type.t) => unit = "type"
    @obj
    external make: (~kind: TypePredicateKind.Identifier.t, ~parameterName: string, ~parameterIndex: float, ~\"type": Type.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypePredicateBase: t => TypePredicateBase.t = "%identity"
  }
  module IfStatement = {
    open IfStatement
    type t = t
    type t0 = t
    type tags = [#Ts_IfStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IfStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.IfStatement.t = "kind"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @get
    external thenStatement: this<'tags, 'base> => Statement.t = "thenStatement"
    @get
    external elseStatement: this<'tags, 'base> => Statement.t = "elseStatement"
    @obj
    external make: (~kind: SyntaxKind.IfStatement.t, ~expression: Expression.t, ~thenStatement: Statement.t, ~elseStatement: Statement.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module ImplementationLocation = {
    open ImplementationLocation
    type t = t
    type t0 = t
    type tags = [#Ts_DocumentSpan | #Ts_ImplementationLocation]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ImplementationLocation ]
    @get
    external getKind: this<'tags, 'base> => ScriptElementKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, ScriptElementKind.t) => unit = "kind"
    @get
    external getDisplayParts: this<'tags, 'base> => array<SymbolDisplayPart.t> = "displayParts"
    @set
    external setDisplayParts: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "displayParts"
    @obj
    external make: (~kind: ScriptElementKind.t, ~displayParts: array<SymbolDisplayPart.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDocumentSpan: t => DocumentSpan.t = "%identity"
  }
  module ImportCall = {
    open ImportCall
    type t = t
    type t0 = t
    type tags = [#Ts_CallExpression | #Ts_Declaration | #Ts_Expression | #Ts_ImportCall | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ImportCall ]
    @get
    external expression: this<'tags, 'base> => ImportExpression.t = "expression"
    @obj
    external make: ~expression: ImportExpression.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asCallExpression: t => CallExpression.t = "%identity"
  }
  module ImportClause = {
    open ImportClause
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_ImportClause | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ImportClause ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ImportClause.t = "kind"
    @get
    external parent: this<'tags, 'base> => ImportDeclaration.t = "parent"
    @get
    external isTypeOnly: this<'tags, 'base> => bool = "isTypeOnly"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external namedBindings: this<'tags, 'base> => NamedImportBindings.t = "namedBindings"
    @obj
    external make: (~kind: SyntaxKind.ImportClause.t, ~parent: ImportDeclaration.t, ~isTypeOnly: bool, ~name: Identifier.t, ~namedBindings: NamedImportBindings.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
  }
  module ImportDeclaration = {
    open ImportDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_ImportDeclaration | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ImportDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ImportDeclaration.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t2<SourceFile.t, ModuleBlock.t> = "parent"
    @get
    external importClause: this<'tags, 'base> => ImportClause.t = "importClause"
    @get
    external moduleSpecifier: this<'tags, 'base> => Expression.t = "moduleSpecifier"
    @get
    external assertClause: this<'tags, 'base> => AssertClause.t = "assertClause"
    @obj
    external make: (~kind: SyntaxKind.ImportDeclaration.t, ~parent: Union.t2<SourceFile.t, ModuleBlock.t>, ~importClause: ImportClause.t, ~moduleSpecifier: Expression.t, ~assertClause: AssertClause.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module ImportEqualsDeclaration = {
    open ImportEqualsDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_DeclarationStatement | #Ts_ImportEqualsDeclaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ImportEqualsDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ImportEqualsDeclaration.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t2<SourceFile.t, ModuleBlock.t> = "parent"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external isTypeOnly: this<'tags, 'base> => bool = "isTypeOnly"
    @get
    external moduleReference: this<'tags, 'base> => ModuleReference.t = "moduleReference"
    @obj
    external make: (~kind: SyntaxKind.ImportEqualsDeclaration.t, ~parent: Union.t2<SourceFile.t, ModuleBlock.t>, ~name: Identifier.t, ~isTypeOnly: bool, ~moduleReference: ModuleReference.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDeclarationStatement: t => DeclarationStatement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module ImportExpression = {
    open ImportExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_ImportExpression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ImportExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ImportKeyword.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.ImportKeyword.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
  }
  module ImportOrExportSpecifier = {
    open ImportOrExportSpecifier
    type t = Union.t2<ImportSpecifier.t, ExportSpecifier.t>
    type t0 = t
  }
  module ImportSpecifier = {
    open ImportSpecifier
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_ImportSpecifier | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ImportSpecifier ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ImportSpecifier.t = "kind"
    @get
    external parent: this<'tags, 'base> => NamedImports.t = "parent"
    @get
    external propertyName: this<'tags, 'base> => Identifier.t = "propertyName"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external isTypeOnly: this<'tags, 'base> => bool = "isTypeOnly"
    @obj
    external make: (~kind: SyntaxKind.ImportSpecifier.t, ~parent: NamedImports.t, ~propertyName: Identifier.t, ~name: Identifier.t, ~isTypeOnly: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
  }
  module ImportTypeNode = {
    open ImportTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_ImportTypeNode | #Ts_Node | #Ts_NodeWithTypeArguments | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ImportTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ImportType.t = "kind"
    @get
    external isTypeOf: this<'tags, 'base> => bool = "isTypeOf"
    @get
    external argument: this<'tags, 'base> => TypeNode.t = "argument"
    @get
    external qualifier: this<'tags, 'base> => EntityName.t = "qualifier"
    @obj
    external make: (~kind: SyntaxKind.ImportType.t, ~isTypeOf: bool, ~argument: TypeNode.t, ~qualifier: EntityName.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNodeWithTypeArguments: t => NodeWithTypeArguments.t = "%identity"
  }
  module ImportsNotUsedAsValues = {
    open ImportsNotUsedAsValues
    type t = t = Remove | Preserve | Error
    type t_0 = t
    module Remove = {
      open Remove
      type t = t
      type t0 = t
      @module("typescript") @scope("ImportsNotUsedAsValues") @val
      external value: t = "Remove"
    }
    module Preserve = {
      open Preserve
      type t = t
      type t0 = t
      @module("typescript") @scope("ImportsNotUsedAsValues") @val
      external value: t = "Preserve"
    }
    module Error = {
      open Error
      type t = t
      type t0 = t
      @module("typescript") @scope("ImportsNotUsedAsValues") @val
      external value: t = "Error"
    }
  }
  module IncompleteCompletionsCache = {
    open IncompleteCompletionsCache
    type t = t
    type t0 = t
    type tags = [#Ts_IncompleteCompletionsCache]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IncompleteCompletionsCache ]
    @send @return(nullable)
    external get: this<'tags, 'base> => option<CompletionInfo.t> = "get"
    @send
    external set: (this<'tags, 'base>, ~response:CompletionInfo.t) => unit = "set"
    @send
    external clear: this<'tags, 'base> => unit = "clear"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module IncompleteType = {
    open IncompleteType
    type t = t
    type t0 = t
    type tags = [#Ts_IncompleteType]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IncompleteType ]
    @get
    external getFlags: this<'tags, 'base> => TypeFlags.t = "flags"
    @set
    external setFlags: (this<'tags, 'base>, TypeFlags.t) => unit = "flags"
    @get
    external getType: this<'tags, 'base> => Type.t = "type"
    @set
    external setType: (this<'tags, 'base>, Type.t) => unit = "type"
    @obj
    external make: (~flags: TypeFlags.t, ~\"type": Type.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module IncrementExpression = {
    open IncrementExpression
    type t = UpdateExpression.t
    type t0 = t
  }
  module IncrementalProgramOptions = {
    open IncrementalProgramOptions
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_IncrementalProgramOptions('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_IncrementalProgramOptions('T) ]
    @get
    external getRootNames: this<'tags, 'base, 'T> => array<string> = "rootNames"
    @set
    external setRootNames: (this<'tags, 'base, 'T>, array<string>) => unit = "rootNames"
    @get
    external getOptions: this<'tags, 'base, 'T> => CompilerOptions.t = "options"
    @set
    external setOptions: (this<'tags, 'base, 'T>, CompilerOptions.t) => unit = "options"
    @get
    external getConfigFileParsingDiagnostics: this<'tags, 'base, 'T> => array<Diagnostic.t> = "configFileParsingDiagnostics"
    @set
    external setConfigFileParsingDiagnostics: (this<'tags, 'base, 'T>, array<Diagnostic.t>) => unit = "configFileParsingDiagnostics"
    @get
    external getProjectReferences: this<'tags, 'base, 'T> => array<ProjectReference.t> = "projectReferences"
    @set
    external setProjectReferences: (this<'tags, 'base, 'T>, array<ProjectReference.t>) => unit = "projectReferences"
    @get
    external getHost: this<'tags, 'base, 'T> => CompilerHost.t = "host"
    @set
    external setHost: (this<'tags, 'base, 'T>, CompilerHost.t) => unit = "host"
    @get
    external getCreateProgram: this<'tags, 'base, 'T> => CreateProgram.t<'T> = "createProgram"
    @set
    external setCreateProgram: (this<'tags, 'base, 'T>, CreateProgram.t<'T>) => unit = "createProgram"
    @obj
    external make: (~rootNames: array<string>, ~options: CompilerOptions.t, ~configFileParsingDiagnostics: array<Diagnostic.t>, ~projectReferences: array<ProjectReference.t>, ~host: CompilerHost.t, ~createProgram: CreateProgram.t<'T>) => t<'T> = ""
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
  }
  module IndentStyle = {
    open IndentStyle
    type t = t = None | Block | Smart
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("IndentStyle") @val
      external value: t = "None"
    }
    module Block = {
      open Block
      type t = t
      type t0 = t
      @module("typescript") @scope("IndentStyle") @val
      external value: t = "Block"
    }
    module Smart = {
      open Smart
      type t = t
      type t0 = t
      @module("typescript") @scope("IndentStyle") @val
      external value: t = "Smart"
    }
  }
  module IndexInfo = {
    open IndexInfo
    type t = t
    type t0 = t
    type tags = [#Ts_IndexInfo]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IndexInfo ]
    @get
    external getKeyType: this<'tags, 'base> => Type.t = "keyType"
    @set
    external setKeyType: (this<'tags, 'base>, Type.t) => unit = "keyType"
    @get
    external getType: this<'tags, 'base> => Type.t = "type"
    @set
    external setType: (this<'tags, 'base>, Type.t) => unit = "type"
    @get
    external getIsReadonly: this<'tags, 'base> => bool = "isReadonly"
    @set
    external setIsReadonly: (this<'tags, 'base>, bool) => unit = "isReadonly"
    @get
    external getDeclaration: this<'tags, 'base> => IndexSignatureDeclaration.t = "declaration"
    @set
    external setDeclaration: (this<'tags, 'base>, IndexSignatureDeclaration.t) => unit = "declaration"
    @obj
    external make: (~keyType: Type.t, ~\"type": Type.t, ~isReadonly: bool, ~declaration: IndexSignatureDeclaration.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module IndexKind = {
    open IndexKind
    type t = t = String | Number
    type t_0 = t
    module String = {
      open String
      type t = t
      type t0 = t
      @module("typescript") @scope("IndexKind") @val
      external value: t = "String"
    }
    module Number = {
      open Number
      type t = t
      type t0 = t
      @module("typescript") @scope("IndexKind") @val
      external value: t = "Number"
    }
  }
  module IndexSignatureDeclaration = {
    open IndexSignatureDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_ClassElement | #Ts_Declaration | #Ts_IndexSignatureDeclaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeElement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IndexSignatureDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.IndexSignature.t = "kind"
    @get
    external parent: this<'tags, 'base> => ObjectTypeDeclaration.t = "parent"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: SyntaxKind.IndexSignature.t, ~parent: ObjectTypeDeclaration.t, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asSignatureDeclarationBase: t => SignatureDeclarationBase.t = "%identity"
    external asClassElement: t => ClassElement.t = "%identity"
    external asTypeElement: t => TypeElement.t = "%identity"
  }
  module IndexType = {
    open IndexType
    type t = t
    type t0 = t
    type tags = [#Ts_IndexType | #Ts_InstantiableType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IndexType ]
    @get
    external getType: this<'tags, 'base> => Union.t2<InstantiableType.t, UnionOrIntersectionType.t> = "type"
    @set
    external setType: (this<'tags, 'base>, Union.t2<InstantiableType.t, UnionOrIntersectionType.t>) => unit = "type"
    @obj
    external make: ~\"type": Union.t2<InstantiableType.t, UnionOrIntersectionType.t> => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asInstantiableType: t => InstantiableType.t = "%identity"
  }
  module IndexedAccessType = {
    open IndexedAccessType
    type t = t
    type t0 = t
    type tags = [#Ts_IndexedAccessType | #Ts_InstantiableType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IndexedAccessType ]
    @get
    external getObjectType: this<'tags, 'base> => Type.t = "objectType"
    @set
    external setObjectType: (this<'tags, 'base>, Type.t) => unit = "objectType"
    @get
    external getIndexType: this<'tags, 'base> => Type.t = "indexType"
    @set
    external setIndexType: (this<'tags, 'base>, Type.t) => unit = "indexType"
    @get
    external getConstraint: this<'tags, 'base> => Type.t = "constraint"
    @set
    external setConstraint: (this<'tags, 'base>, Type.t) => unit = "constraint"
    @get
    external getSimplifiedForReading: this<'tags, 'base> => Type.t = "simplifiedForReading"
    @set
    external setSimplifiedForReading: (this<'tags, 'base>, Type.t) => unit = "simplifiedForReading"
    @get
    external getSimplifiedForWriting: this<'tags, 'base> => Type.t = "simplifiedForWriting"
    @set
    external setSimplifiedForWriting: (this<'tags, 'base>, Type.t) => unit = "simplifiedForWriting"
    @obj
    external make: (~objectType: Type.t, ~indexType: Type.t, ~\"constraint": Type.t, ~simplifiedForReading: Type.t, ~simplifiedForWriting: Type.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asInstantiableType: t => InstantiableType.t = "%identity"
  }
  module IndexedAccessTypeNode = {
    open IndexedAccessTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_IndexedAccessTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IndexedAccessTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.IndexedAccessType.t = "kind"
    @get
    external objectType: this<'tags, 'base> => TypeNode.t = "objectType"
    @get
    external indexType: this<'tags, 'base> => TypeNode.t = "indexType"
    @obj
    external make: (~kind: SyntaxKind.IndexedAccessType.t, ~objectType: TypeNode.t, ~indexType: TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
  }
  module InferTypeNode = {
    open InferTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_InferTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_InferTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.InferType.t = "kind"
    @get
    external typeParameter: this<'tags, 'base> => TypeParameterDeclaration.t = "typeParameter"
    @obj
    external make: (~kind: SyntaxKind.InferType.t, ~typeParameter: TypeParameterDeclaration.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
  }
  module InferencePriority = {
    open InferencePriority
    /* FIXME: float/negative enum (at line 2799, col 5 of /mnt/d/Documents/codes/ts2bs/node_modules/typescript/lib/typescript.d.ts) */
    type t = t
    type t_0 = t
    module NakedTypeVariable = {
      open NakedTypeVariable
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "NakedTypeVariable"
    }
    module SpeculativeTuple = {
      open SpeculativeTuple
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "SpeculativeTuple"
    }
    module SubstituteSource = {
      open SubstituteSource
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "SubstituteSource"
    }
    module HomomorphicMappedType = {
      open HomomorphicMappedType
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "HomomorphicMappedType"
    }
    module PartialHomomorphicMappedType = {
      open PartialHomomorphicMappedType
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "PartialHomomorphicMappedType"
    }
    module MappedTypeConstraint = {
      open MappedTypeConstraint
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "MappedTypeConstraint"
    }
    module ContravariantConditional = {
      open ContravariantConditional
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "ContravariantConditional"
    }
    module ReturnType = {
      open ReturnType
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "ReturnType"
    }
    module LiteralKeyof = {
      open LiteralKeyof
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "LiteralKeyof"
    }
    module NoConstraints = {
      open NoConstraints
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "NoConstraints"
    }
    module AlwaysStrict = {
      open AlwaysStrict
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "AlwaysStrict"
    }
    module MaxValue = {
      open MaxValue
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "MaxValue"
    }
    module PriorityImpliesCombination = {
      open PriorityImpliesCombination
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "PriorityImpliesCombination"
    }
    module Circularity = {
      open Circularity
      type t = t
      type t0 = t
      @module("typescript") @scope("InferencePriority") @val
      external value: t = "Circularity"
    }
  }
  module InlayHint = {
    open InlayHint
    type t = t
    type t0 = t
    type tags = [#Ts_InlayHint]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_InlayHint ]
    @get
    external getText: this<'tags, 'base> => string = "text"
    @set
    external setText: (this<'tags, 'base>, string) => unit = "text"
    @get
    external getPosition: this<'tags, 'base> => float = "position"
    @set
    external setPosition: (this<'tags, 'base>, float) => unit = "position"
    @get
    external getKind: this<'tags, 'base> => InlayHintKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, InlayHintKind.t) => unit = "kind"
    @get
    external getWhitespaceBefore: this<'tags, 'base> => bool = "whitespaceBefore"
    @set
    external setWhitespaceBefore: (this<'tags, 'base>, bool) => unit = "whitespaceBefore"
    @get
    external getWhitespaceAfter: this<'tags, 'base> => bool = "whitespaceAfter"
    @set
    external setWhitespaceAfter: (this<'tags, 'base>, bool) => unit = "whitespaceAfter"
    @obj
    external make: (~text: string, ~position: float, ~kind: InlayHintKind.t, ~whitespaceBefore: bool, ~whitespaceAfter: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module InlayHintKind = {
    open InlayHintKind
    type t = t
    type t_0 = t
    module Type = {
      open Type
      type t = t
      type t0 = t
      @module("typescript") @scope("InlayHintKind") @val
      external value: t = "Type"
    }
    module Parameter = {
      open Parameter
      type t = t
      type t0 = t
      @module("typescript") @scope("InlayHintKind") @val
      external value: t = "Parameter"
    }
    module Enum = {
      open Enum
      type t = t
      type t0 = t
      @module("typescript") @scope("InlayHintKind") @val
      external value: t = "Enum"
    }
  }
  module InlayHintsContext = {
    open InlayHintsContext
    type t = t
    type t0 = t
    type tags = [#Ts_InlayHintsContext]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_InlayHintsContext ]
    @get
    external getFile: this<'tags, 'base> => SourceFile.t = "file"
    @set
    external setFile: (this<'tags, 'base>, SourceFile.t) => unit = "file"
    @get
    external getProgram: this<'tags, 'base> => Program.t = "program"
    @set
    external setProgram: (this<'tags, 'base>, Program.t) => unit = "program"
    @get
    external getCancellationToken: this<'tags, 'base> => CancellationToken.t = "cancellationToken"
    @set
    external setCancellationToken: (this<'tags, 'base>, CancellationToken.t) => unit = "cancellationToken"
    @get
    external getHost: this<'tags, 'base> => LanguageServiceHost.t = "host"
    @set
    external setHost: (this<'tags, 'base>, LanguageServiceHost.t) => unit = "host"
    @get
    external getSpan: this<'tags, 'base> => TextSpan.t = "span"
    @set
    external setSpan: (this<'tags, 'base>, TextSpan.t) => unit = "span"
    @get
    external getPreferences: this<'tags, 'base> => InlayHintsOptions.t = "preferences"
    @set
    external setPreferences: (this<'tags, 'base>, InlayHintsOptions.t) => unit = "preferences"
    @obj
    external make: (~file: SourceFile.t, ~program: Program.t, ~cancellationToken: CancellationToken.t, ~host: LanguageServiceHost.t, ~span: TextSpan.t, ~preferences: InlayHintsOptions.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module InlayHintsOptions = {
    open InlayHintsOptions
    type t = t
    type t0 = t
    type tags = [#Ts_InlayHintsOptions | #Ts_UserPreferences]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_InlayHintsOptions ]
    @get
    external includeInlayParameterNameHints: this<'tags, 'base> => Union.t3<[#none], [#literals], [#all]> = "includeInlayParameterNameHints"
    @get
    external includeInlayParameterNameHintsWhenArgumentMatchesName: this<'tags, 'base> => bool = "includeInlayParameterNameHintsWhenArgumentMatchesName"
    @get
    external includeInlayFunctionParameterTypeHints: this<'tags, 'base> => bool = "includeInlayFunctionParameterTypeHints"
    @get
    external includeInlayVariableTypeHints: this<'tags, 'base> => bool = "includeInlayVariableTypeHints"
    @get
    external includeInlayPropertyDeclarationTypeHints: this<'tags, 'base> => bool = "includeInlayPropertyDeclarationTypeHints"
    @get
    external includeInlayFunctionLikeReturnTypeHints: this<'tags, 'base> => bool = "includeInlayFunctionLikeReturnTypeHints"
    @get
    external includeInlayEnumMemberValueHints: this<'tags, 'base> => bool = "includeInlayEnumMemberValueHints"
    @obj
    external make: (~includeInlayParameterNameHints: Union.t3<[#none], [#literals], [#all]>, ~includeInlayParameterNameHintsWhenArgumentMatchesName: bool, ~includeInlayFunctionParameterTypeHints: bool, ~includeInlayVariableTypeHints: bool, ~includeInlayPropertyDeclarationTypeHints: bool, ~includeInlayFunctionLikeReturnTypeHints: bool, ~includeInlayEnumMemberValueHints: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asUserPreferences: t => UserPreferences.t = "%identity"
  }
  module InputFiles = {
    open InputFiles
    type t = t
    type t0 = t
    type tags = [#Ts_InputFiles | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_InputFiles ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.InputFiles.t = "kind"
    @get
    external getJavascriptPath: this<'tags, 'base> => string = "javascriptPath"
    @set
    external setJavascriptPath: (this<'tags, 'base>, string) => unit = "javascriptPath"
    @get
    external getJavascriptText: this<'tags, 'base> => string = "javascriptText"
    @set
    external setJavascriptText: (this<'tags, 'base>, string) => unit = "javascriptText"
    @get
    external getJavascriptMapPath: this<'tags, 'base> => string = "javascriptMapPath"
    @set
    external setJavascriptMapPath: (this<'tags, 'base>, string) => unit = "javascriptMapPath"
    @get
    external getJavascriptMapText: this<'tags, 'base> => string = "javascriptMapText"
    @set
    external setJavascriptMapText: (this<'tags, 'base>, string) => unit = "javascriptMapText"
    @get
    external getDeclarationPath: this<'tags, 'base> => string = "declarationPath"
    @set
    external setDeclarationPath: (this<'tags, 'base>, string) => unit = "declarationPath"
    @get
    external getDeclarationText: this<'tags, 'base> => string = "declarationText"
    @set
    external setDeclarationText: (this<'tags, 'base>, string) => unit = "declarationText"
    @get
    external getDeclarationMapPath: this<'tags, 'base> => string = "declarationMapPath"
    @set
    external setDeclarationMapPath: (this<'tags, 'base>, string) => unit = "declarationMapPath"
    @get
    external getDeclarationMapText: this<'tags, 'base> => string = "declarationMapText"
    @set
    external setDeclarationMapText: (this<'tags, 'base>, string) => unit = "declarationMapText"
    @obj
    external make: (~kind: SyntaxKind.InputFiles.t, ~javascriptPath: string, ~javascriptText: string, ~javascriptMapPath: string, ~javascriptMapText: string, ~declarationPath: string, ~declarationText: string, ~declarationMapPath: string, ~declarationMapText: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module InstallPackageAction = {
    open InstallPackageAction
    type t = t
    type t0 = t
    type tags = [#Ts_InstallPackageAction]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_InstallPackageAction ]
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module InstallPackageOptions = {
    open InstallPackageOptions
    type t = t
    type t0 = t
    type tags = [#Ts_InstallPackageOptions]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_InstallPackageOptions ]
    @get
    external getFileName: this<'tags, 'base> => Path.t = "fileName"
    @set
    external setFileName: (this<'tags, 'base>, Path.t) => unit = "fileName"
    @get
    external getPackageName: this<'tags, 'base> => string = "packageName"
    @set
    external setPackageName: (this<'tags, 'base>, string) => unit = "packageName"
    @obj
    external make: (~fileName: Path.t, ~packageName: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module InstantiableType = {
    open InstantiableType
    type t = t
    type t0 = t
    type tags = [#Ts_InstantiableType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_InstantiableType ]
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asType: t => Type.t = "%identity"
  }
  module InterfaceDeclaration = {
    open InterfaceDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_DeclarationStatement | #Ts_InterfaceDeclaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_InterfaceDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.InterfaceDeclaration.t = "kind"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external typeParameters: this<'tags, 'base> => NodeArray.t<TypeParameterDeclaration.t> = "typeParameters"
    @get
    external heritageClauses: this<'tags, 'base> => NodeArray.t<HeritageClause.t> = "heritageClauses"
    @get
    external members: this<'tags, 'base> => NodeArray.t<TypeElement.t> = "members"
    @obj
    external make: (~kind: SyntaxKind.InterfaceDeclaration.t, ~name: Identifier.t, ~typeParameters: NodeArray.t<TypeParameterDeclaration.t>, ~heritageClauses: NodeArray.t<HeritageClause.t>, ~members: NodeArray.t<TypeElement.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDeclarationStatement: t => DeclarationStatement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module InterfaceType = {
    open InterfaceType
    type t = t
    type t0 = t
    type tags = [#Ts_InterfaceType | #Ts_ObjectType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_InterfaceType ]
    @get @return(nullable)
    external getTypeParameters: this<'tags, 'base> => option<array<TypeParameter.t>> = "typeParameters"
    @set
    external setTypeParameters: (this<'tags, 'base>, undefined<array<TypeParameter.t>>) => unit = "typeParameters"
    @get @return(nullable)
    external getOuterTypeParameters: this<'tags, 'base> => option<array<TypeParameter.t>> = "outerTypeParameters"
    @set
    external setOuterTypeParameters: (this<'tags, 'base>, undefined<array<TypeParameter.t>>) => unit = "outerTypeParameters"
    @get @return(nullable)
    external getLocalTypeParameters: this<'tags, 'base> => option<array<TypeParameter.t>> = "localTypeParameters"
    @set
    external setLocalTypeParameters: (this<'tags, 'base>, undefined<array<TypeParameter.t>>) => unit = "localTypeParameters"
    @get @return(nullable)
    external getThisType: this<'tags, 'base> => option<TypeParameter.t> = "thisType"
    @set
    external setThisType: (this<'tags, 'base>, undefined<TypeParameter.t>) => unit = "thisType"
    @obj
    external make: (~typeParameters: array<TypeParameter.t>=?, ~outerTypeParameters: array<TypeParameter.t>=?, ~localTypeParameters: array<TypeParameter.t>=?, ~thisType: TypeParameter.t=?, unit) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asObjectType: t => ObjectType.t = "%identity"
  }
  module InterfaceTypeWithDeclaredMembers = {
    open InterfaceTypeWithDeclaredMembers
    type t = t
    type t0 = t
    type tags = [#Ts_InterfaceType | #Ts_InterfaceTypeWithDeclaredMembers | #Ts_ObjectType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_InterfaceTypeWithDeclaredMembers ]
    @get
    external getDeclaredProperties: this<'tags, 'base> => array<Symbol.t> = "declaredProperties"
    @set
    external setDeclaredProperties: (this<'tags, 'base>, array<Symbol.t>) => unit = "declaredProperties"
    @get
    external getDeclaredCallSignatures: this<'tags, 'base> => array<Signature.t> = "declaredCallSignatures"
    @set
    external setDeclaredCallSignatures: (this<'tags, 'base>, array<Signature.t>) => unit = "declaredCallSignatures"
    @get
    external getDeclaredConstructSignatures: this<'tags, 'base> => array<Signature.t> = "declaredConstructSignatures"
    @set
    external setDeclaredConstructSignatures: (this<'tags, 'base>, array<Signature.t>) => unit = "declaredConstructSignatures"
    @get
    external getDeclaredIndexInfos: this<'tags, 'base> => array<IndexInfo.t> = "declaredIndexInfos"
    @set
    external setDeclaredIndexInfos: (this<'tags, 'base>, array<IndexInfo.t>) => unit = "declaredIndexInfos"
    @obj
    external make: (~declaredProperties: array<Symbol.t>, ~declaredCallSignatures: array<Signature.t>, ~declaredConstructSignatures: array<Signature.t>, ~declaredIndexInfos: array<IndexInfo.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asInterfaceType: t => InterfaceType.t = "%identity"
  }
  module InternalSymbolName = {
    open InternalSymbolName
    type t = t
    type t_0 = t
    module Call = {
      open Call
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "Call"
    }
    module Constructor = {
      open Constructor
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "Constructor"
    }
    module New = {
      open New
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "New"
    }
    module Index = {
      open Index
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "Index"
    }
    module ExportStar = {
      open ExportStar
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "ExportStar"
    }
    module Global = {
      open Global
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "Global"
    }
    module Missing = {
      open Missing
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "Missing"
    }
    module Type = {
      open Type
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "Type"
    }
    module Object = {
      open Object
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "Object"
    }
    module JSXAttributes = {
      open JSXAttributes
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "JSXAttributes"
    }
    module Class = {
      open Class
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "Class"
    }
    module Function = {
      open Function
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "Function"
    }
    module Computed = {
      open Computed
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "Computed"
    }
    module Resolving = {
      open Resolving
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "Resolving"
    }
    module ExportEquals = {
      open ExportEquals
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "ExportEquals"
    }
    module Default_ = {
      open Default_
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "Default"
    }
    module This = {
      open This
      type t = t
      type t0 = t
      @module("typescript") @scope("InternalSymbolName") @val
      external value: t = "This"
    }
  }
  module IntersectionType = {
    open IntersectionType
    type t = t
    type t0 = t
    type tags = [#Ts_IntersectionType | #Ts_Type | #Ts_UnionOrIntersectionType]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IntersectionType ]
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asUnionOrIntersectionType: t => UnionOrIntersectionType.t = "%identity"
  }
  module IntersectionTypeNode = {
    open IntersectionTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_IntersectionTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IntersectionTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.IntersectionType.t = "kind"
    @get
    external types: this<'tags, 'base> => NodeArray.t<TypeNode.t> = "types"
    @obj
    external make: (~kind: SyntaxKind.IntersectionType.t, ~types: NodeArray.t<TypeNode.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
  }
  module InvalidatedProject = {
    open InvalidatedProject
    type t<'T> = Union.t3<UpdateOutputFileStampsProject.t, BuildInvalidedProject.t<'T>, UpdateBundleProject.t<'T>>
    type t1<'T> = t<'T>
  }
  module InvalidatedProjectBase = {
    open InvalidatedProjectBase
    type t = t
    type t0 = t
    type tags = [#Ts_InvalidatedProjectBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_InvalidatedProjectBase ]
    @get
    external kind: this<'tags, 'base> => InvalidatedProjectKind.t = "kind"
    @get
    external project: this<'tags, 'base> => ResolvedConfigFileName.t = "project"
    @send
    external done: (this<'tags, 'base>, ~cancellationToken:CancellationToken.t=?, ~writeFile:WriteFileCallback.t=?, ~customTransformers:CustomTransformers.t=?, unit) => ExitStatus.t = "done"
    @send
    external getCompilerOptions: this<'tags, 'base> => CompilerOptions.t = "getCompilerOptions"
    @send
    external getCurrentDirectory: this<'tags, 'base> => string = "getCurrentDirectory"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module InvalidatedProjectKind = {
    open InvalidatedProjectKind
    type t = t = Build | UpdateBundle | UpdateOutputFileStamps
    type t_0 = t
    module Build = {
      open Build
      type t = t
      type t0 = t
      @module("typescript") @scope("InvalidatedProjectKind") @val
      external value: t = "Build"
    }
    module UpdateBundle = {
      open UpdateBundle
      type t = t
      type t0 = t
      @module("typescript") @scope("InvalidatedProjectKind") @val
      external value: t = "UpdateBundle"
    }
    module UpdateOutputFileStamps = {
      open UpdateOutputFileStamps
      type t = t
      type t0 = t
      @module("typescript") @scope("InvalidatedProjectKind") @val
      external value: t = "UpdateOutputFileStamps"
    }
  }
  module IterationStatement = {
    open IterationStatement
    type t = t
    type t0 = t
    type tags = [#Ts_IterationStatement | #Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_IterationStatement ]
    @get
    external statement: this<'tags, 'base> => Statement.t = "statement"
    @obj
    external make: ~statement: Statement.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module Iterator = {
    open Iterator
    module AnonymousInterface31 = {
      open AnonymousInterface31
      type t = t
      @get
      external getValue: t => unit = "value"
      @set
      external setValue: (t, unit) => unit = "value"
      @get
      external getDone: t => \"true" = "done"
      @set
      external setDone: (t, \"true") => unit = "done"
      @obj
      external make: (~value: unit, ~done: \"true") => t = ""
    }
    module AnonymousInterface55 = {
      open AnonymousInterface55
      type t<'T> = t<'T>
      @get
      external getValue: t<'T> => 'T = "value"
      @set
      external setValue: (t<'T>, 'T) => unit = "value"
      @get
      external getDone: t<'T> => \"false" = "done"
      @set
      external setDone: (t<'T>, \"false") => unit = "done"
      @obj
      external make: (~value: 'T, ~done: \"false") => t<'T> = ""
    }
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_Iterator('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_Iterator('T) ]
    @send
    external next: this<'tags, 'base, 'T> => Union.t2<AnonymousInterface55.t<'T>, AnonymousInterface31.t> = "next"
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
  }
  module JSDoc = {
    open JSDoc
    type t = t
    type t0 = t
    type tags = [#Ts_JSDoc | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDoc ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocComment.t = "kind"
    @get
    external parent: this<'tags, 'base> => HasJSDoc.t = "parent"
    @get
    external tags: this<'tags, 'base> => NodeArray.t<JSDocTag.t> = "tags"
    @get
    external comment: this<'tags, 'base> => Union.t2<string, NodeArray.t<JSDocComment.t>> = "comment"
    @obj
    external make: (~kind: SyntaxKind.JSDocComment.t, ~parent: HasJSDoc.t, ~tags: NodeArray.t<JSDocTag.t>, ~comment: Union.t2<string, NodeArray.t<JSDocComment.t>>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module JSDocAllType = {
    open JSDocAllType
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocAllType | #Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocAllType ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocAllType.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocAllType.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocType: t => JSDocType.t = "%identity"
  }
  module JSDocAugmentsTag = {
    open JSDocAugmentsTag
    module AnonymousInterface14 = {
      open AnonymousInterface14
      type t = t
      @get
      external expression: t => Union.t2<Identifier.t, PropertyAccessEntityNameExpression.t> = "expression"
      @obj
      external make: ~expression: Union.t2<Identifier.t, PropertyAccessEntityNameExpression.t> => t = ""
    }
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocAugmentsTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocAugmentsTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocAugmentsTag.t = "kind"
    @get
    external class: this<'tags, 'base> => Intersection.t2<ExpressionWithTypeArguments.t, AnonymousInterface14.t> = "class"
    @obj
    external make: (~kind: SyntaxKind.JSDocAugmentsTag.t, ~class: Intersection.t2<ExpressionWithTypeArguments.t, AnonymousInterface14.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocAuthorTag = {
    open JSDocAuthorTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocAuthorTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocAuthorTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocAuthorTag.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocAuthorTag.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocCallbackTag = {
    open JSDocCallbackTag
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocCallbackTag | #Ts_JSDocTag | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocCallbackTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocCallbackTag.t = "kind"
    @get
    external parent: this<'tags, 'base> => JSDoc.t = "parent"
    @get
    external fullName: this<'tags, 'base> => Union.t2<JSDocNamespaceDeclaration.t, Identifier.t> = "fullName"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external typeExpression: this<'tags, 'base> => JSDocSignature.t = "typeExpression"
    @obj
    external make: (~kind: SyntaxKind.JSDocCallbackTag.t, ~parent: JSDoc.t, ~fullName: Union.t2<JSDocNamespaceDeclaration.t, Identifier.t>, ~name: Identifier.t, ~typeExpression: JSDocSignature.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
  }
  module JSDocClassTag = {
    open JSDocClassTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocClassTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocClassTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocClassTag.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocClassTag.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocComment = {
    open JSDocComment
    type t = Union.t4<JSDocText.t, JSDocLink.t, JSDocLinkCode.t, JSDocLinkPlain.t>
    type t0 = t
  }
  module JSDocContainer = {
    open JSDocContainer
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocContainer]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocContainer ]
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module JSDocDeprecatedTag = {
    open JSDocDeprecatedTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocDeprecatedTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocDeprecatedTag ]
    @get
    external getKind: this<'tags, 'base> => SyntaxKind.JSDocDeprecatedTag.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, SyntaxKind.JSDocDeprecatedTag.t) => unit = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocDeprecatedTag.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocEnumTag = {
    open JSDocEnumTag
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocEnumTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocEnumTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocEnumTag.t = "kind"
    @get
    external parent: this<'tags, 'base> => JSDoc.t = "parent"
    @get
    external typeExpression: this<'tags, 'base> => JSDocTypeExpression.t = "typeExpression"
    @obj
    external make: (~kind: SyntaxKind.JSDocEnumTag.t, ~parent: JSDoc.t, ~typeExpression: JSDocTypeExpression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module JSDocFunctionType = {
    open JSDocFunctionType
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocContainer | #Ts_JSDocFunctionType | #Ts_JSDocType | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocFunctionType ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocFunctionType.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocFunctionType.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocType: t => JSDocType.t = "%identity"
    external asSignatureDeclarationBase: t => SignatureDeclarationBase.t = "%identity"
  }
  module JSDocImplementsTag = {
    open JSDocImplementsTag
    module AnonymousInterface14 = {
      open AnonymousInterface14
      type t = t
      @get
      external expression: t => Union.t2<Identifier.t, PropertyAccessEntityNameExpression.t> = "expression"
      @obj
      external make: ~expression: Union.t2<Identifier.t, PropertyAccessEntityNameExpression.t> => t = ""
    }
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocImplementsTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocImplementsTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocImplementsTag.t = "kind"
    @get
    external class: this<'tags, 'base> => Intersection.t2<ExpressionWithTypeArguments.t, AnonymousInterface14.t> = "class"
    @obj
    external make: (~kind: SyntaxKind.JSDocImplementsTag.t, ~class: Intersection.t2<ExpressionWithTypeArguments.t, AnonymousInterface14.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocLink = {
    open JSDocLink
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocLink | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocLink ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocLink.t = "kind"
    @get
    external name: this<'tags, 'base> => Union.t2<EntityName.t, JSDocMemberName.t> = "name"
    @get
    external getText: this<'tags, 'base> => string = "text"
    @set
    external setText: (this<'tags, 'base>, string) => unit = "text"
    @obj
    external make: (~kind: SyntaxKind.JSDocLink.t, ~name: Union.t2<EntityName.t, JSDocMemberName.t>, ~text: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module JSDocLinkCode = {
    open JSDocLinkCode
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocLinkCode | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocLinkCode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocLinkCode.t = "kind"
    @get
    external name: this<'tags, 'base> => Union.t2<EntityName.t, JSDocMemberName.t> = "name"
    @get
    external getText: this<'tags, 'base> => string = "text"
    @set
    external setText: (this<'tags, 'base>, string) => unit = "text"
    @obj
    external make: (~kind: SyntaxKind.JSDocLinkCode.t, ~name: Union.t2<EntityName.t, JSDocMemberName.t>, ~text: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module JSDocLinkDisplayPart = {
    open JSDocLinkDisplayPart
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocLinkDisplayPart | #Ts_SymbolDisplayPart]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocLinkDisplayPart ]
    @get
    external getTarget: this<'tags, 'base> => DocumentSpan.t = "target"
    @set
    external setTarget: (this<'tags, 'base>, DocumentSpan.t) => unit = "target"
    @obj
    external make: ~target: DocumentSpan.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asSymbolDisplayPart: t => SymbolDisplayPart.t = "%identity"
  }
  module JSDocLinkPlain = {
    open JSDocLinkPlain
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocLinkPlain | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocLinkPlain ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocLinkPlain.t = "kind"
    @get
    external name: this<'tags, 'base> => Union.t2<EntityName.t, JSDocMemberName.t> = "name"
    @get
    external getText: this<'tags, 'base> => string = "text"
    @set
    external setText: (this<'tags, 'base>, string) => unit = "text"
    @obj
    external make: (~kind: SyntaxKind.JSDocLinkPlain.t, ~name: Union.t2<EntityName.t, JSDocMemberName.t>, ~text: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module JSDocMemberName = {
    open JSDocMemberName
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocMemberName | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocMemberName ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocMemberName.t = "kind"
    @get
    external left: this<'tags, 'base> => Union.t2<EntityName.t, t> = "left"
    @get
    external right: this<'tags, 'base> => Identifier.t = "right"
    @obj
    external make: (~kind: SyntaxKind.JSDocMemberName.t, ~left: Union.t2<EntityName.t, t>, ~right: Identifier.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module JSDocNameReference = {
    open JSDocNameReference
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocNameReference | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocNameReference ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocNameReference.t = "kind"
    @get
    external name: this<'tags, 'base> => Union.t2<EntityName.t, JSDocMemberName.t> = "name"
    @obj
    external make: (~kind: SyntaxKind.JSDocNameReference.t, ~name: Union.t2<EntityName.t, JSDocMemberName.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module JSDocNamepathType = {
    open JSDocNamepathType
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocNamepathType | #Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocNamepathType ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocNamepathType.t = "kind"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: SyntaxKind.JSDocNamepathType.t, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocType: t => JSDocType.t = "%identity"
  }
  module JSDocNamespaceBody = {
    open JSDocNamespaceBody
    type t = Union.t2<Identifier.t, JSDocNamespaceDeclaration.t>
    type t0 = t
  }
  module JSDocNamespaceDeclaration = {
    open JSDocNamespaceDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_JSDocNamespaceDeclaration | #Ts_ModuleDeclaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocNamespaceDeclaration ]
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external body: this<'tags, 'base> => JSDocNamespaceBody.t = "body"
    @obj
    external make: (~name: Identifier.t, ~body: JSDocNamespaceBody.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asModuleDeclaration: t => ModuleDeclaration.t = "%identity"
  }
  module JSDocNonNullableType = {
    open JSDocNonNullableType
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocNonNullableType | #Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocNonNullableType ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocNonNullableType.t = "kind"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: SyntaxKind.JSDocNonNullableType.t, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocType: t => JSDocType.t = "%identity"
  }
  module JSDocNullableType = {
    open JSDocNullableType
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocNullableType | #Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocNullableType ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocNullableType.t = "kind"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: SyntaxKind.JSDocNullableType.t, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocType: t => JSDocType.t = "%identity"
  }
  module JSDocOptionalType = {
    open JSDocOptionalType
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocOptionalType | #Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocOptionalType ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocOptionalType.t = "kind"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: SyntaxKind.JSDocOptionalType.t, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocType: t => JSDocType.t = "%identity"
  }
  module JSDocOverrideTag = {
    open JSDocOverrideTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocOverrideTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocOverrideTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocOverrideTag.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocOverrideTag.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocParameterTag = {
    open JSDocParameterTag
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocParameterTag | #Ts_JSDocPropertyLikeTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocParameterTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocParameterTag.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocParameterTag.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocPropertyLikeTag: t => JSDocPropertyLikeTag.t = "%identity"
  }
  module JSDocPrivateTag = {
    open JSDocPrivateTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocPrivateTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocPrivateTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocPrivateTag.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocPrivateTag.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocPropertyLikeTag = {
    open JSDocPropertyLikeTag
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocPropertyLikeTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocPropertyLikeTag ]
    @get
    external parent: this<'tags, 'base> => JSDoc.t = "parent"
    @get
    external name: this<'tags, 'base> => EntityName.t = "name"
    @get
    external typeExpression: this<'tags, 'base> => JSDocTypeExpression.t = "typeExpression"
    @get
    external isNameFirst: this<'tags, 'base> => bool = "isNameFirst"
    @get
    external isBracketed: this<'tags, 'base> => bool = "isBracketed"
    @obj
    external make: (~parent: JSDoc.t, ~name: EntityName.t, ~typeExpression: JSDocTypeExpression.t, ~isNameFirst: bool, ~isBracketed: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module JSDocPropertyTag = {
    open JSDocPropertyTag
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocPropertyLikeTag | #Ts_JSDocPropertyTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocPropertyTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocPropertyTag.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocPropertyTag.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocPropertyLikeTag: t => JSDocPropertyLikeTag.t = "%identity"
  }
  module JSDocProtectedTag = {
    open JSDocProtectedTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocProtectedTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocProtectedTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocProtectedTag.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocProtectedTag.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocPublicTag = {
    open JSDocPublicTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocPublicTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocPublicTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocPublicTag.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocPublicTag.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocReadonlyTag = {
    open JSDocReadonlyTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocReadonlyTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocReadonlyTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocReadonlyTag.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocReadonlyTag.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocReturnTag = {
    open JSDocReturnTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocReturnTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocReturnTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocReturnTag.t = "kind"
    @get
    external typeExpression: this<'tags, 'base> => JSDocTypeExpression.t = "typeExpression"
    @obj
    external make: (~kind: SyntaxKind.JSDocReturnTag.t, ~typeExpression: JSDocTypeExpression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocSeeTag = {
    open JSDocSeeTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocSeeTag | #Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocSeeTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocSeeTag.t = "kind"
    @get
    external name: this<'tags, 'base> => JSDocNameReference.t = "name"
    @obj
    external make: (~kind: SyntaxKind.JSDocSeeTag.t, ~name: JSDocNameReference.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocSignature = {
    open JSDocSignature
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocSignature | #Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocSignature ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocSignature.t = "kind"
    @get
    external typeParameters: this<'tags, 'base> => array<JSDocTemplateTag.t> = "typeParameters"
    @get
    external parameters: this<'tags, 'base> => array<JSDocParameterTag.t> = "parameters"
    @get @return(nullable)
    external \"type": this<'tags, 'base> => option<JSDocReturnTag.t> = "type"
    @obj
    external make: (~kind: SyntaxKind.JSDocSignature.t, ~typeParameters: array<JSDocTemplateTag.t>, ~parameters: array<JSDocParameterTag.t>, ~\"type": JSDocReturnTag.t=?, unit) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocType: t => JSDocType.t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module JSDocSyntaxKind = {
    open JSDocSyntaxKind
    type t = Union.t8<SyntaxKind.EndOfFileToken.t, SyntaxKind.WhitespaceTrivia.t, SyntaxKind.AtToken.t, SyntaxKind.NewLineTrivia.t, SyntaxKind.AsteriskToken.t, SyntaxKind.OpenBraceToken.t, SyntaxKind.CloseBraceToken.t, Union.t8<SyntaxKind.LessThanToken.t, SyntaxKind.GreaterThanToken.t, SyntaxKind.OpenBracketToken.t, SyntaxKind.CloseBracketToken.t, SyntaxKind.EqualsToken.t, SyntaxKind.CommaToken.t, SyntaxKind.DotToken.t, Union.t5<SyntaxKind.Identifier.t, SyntaxKind.BacktickToken.t, SyntaxKind.HashToken.t, SyntaxKind.Unknown.t, KeywordSyntaxKind.t>>>
    type t0 = t
  }
  module JSDocTag = {
    open JSDocTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocTag ]
    @get
    external parent: this<'tags, 'base> => Union.t2<JSDoc.t, JSDocTypeLiteral.t> = "parent"
    @get
    external tagName: this<'tags, 'base> => Identifier.t = "tagName"
    @get
    external comment: this<'tags, 'base> => Union.t2<string, NodeArray.t<JSDocComment.t>> = "comment"
    @obj
    external make: (~parent: Union.t2<JSDoc.t, JSDocTypeLiteral.t>, ~tagName: Identifier.t, ~comment: Union.t2<string, NodeArray.t<JSDocComment.t>>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module JSDocTagInfo = {
    open JSDocTagInfo
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocTagInfo]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocTagInfo ]
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @get
    external getText: this<'tags, 'base> => array<SymbolDisplayPart.t> = "text"
    @set
    external setText: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "text"
    @obj
    external make: (~name: string, ~text: array<SymbolDisplayPart.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module JSDocTemplateTag = {
    open JSDocTemplateTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocTag | #Ts_JSDocTemplateTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocTemplateTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocTemplateTag.t = "kind"
    @get @return(nullable)
    external \"constraint": this<'tags, 'base> => option<JSDocTypeExpression.t> = "constraint"
    @get
    external typeParameters: this<'tags, 'base> => NodeArray.t<TypeParameterDeclaration.t> = "typeParameters"
    @obj
    external make: (~kind: SyntaxKind.JSDocTemplateTag.t, ~\"constraint": JSDocTypeExpression.t=?, ~typeParameters: NodeArray.t<TypeParameterDeclaration.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocText = {
    open JSDocText
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocText | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocText ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocText.t = "kind"
    @get
    external getText: this<'tags, 'base> => string = "text"
    @set
    external setText: (this<'tags, 'base>, string) => unit = "text"
    @obj
    external make: (~kind: SyntaxKind.JSDocText.t, ~text: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module JSDocThisTag = {
    open JSDocThisTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocTag | #Ts_JSDocThisTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocThisTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocThisTag.t = "kind"
    @get
    external typeExpression: this<'tags, 'base> => JSDocTypeExpression.t = "typeExpression"
    @obj
    external make: (~kind: SyntaxKind.JSDocThisTag.t, ~typeExpression: JSDocTypeExpression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocType = {
    open JSDocType
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocType ]
    @get
    external get_jsDocTypeBrand: this<'tags, 'base> => any = "_jsDocTypeBrand"
    @set
    external set_jsDocTypeBrand: (this<'tags, 'base>, any) => unit = "_jsDocTypeBrand"
    @obj
    external make: ~\"_jsDocTypeBrand": any => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
  }
  module JSDocTypeExpression = {
    open JSDocTypeExpression
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocTypeExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocTypeExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocTypeExpression.t = "kind"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: SyntaxKind.JSDocTypeExpression.t, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
  }
  module JSDocTypeLiteral = {
    open JSDocTypeLiteral
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocType | #Ts_JSDocTypeLiteral | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocTypeLiteral ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocTypeLiteral.t = "kind"
    @get
    external jsDocPropertyTags: this<'tags, 'base> => array<JSDocPropertyLikeTag.t> = "jsDocPropertyTags"
    @get
    external isArrayType: this<'tags, 'base> => bool = "isArrayType"
    @obj
    external make: (~kind: SyntaxKind.JSDocTypeLiteral.t, ~jsDocPropertyTags: array<JSDocPropertyLikeTag.t>, ~isArrayType: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocType: t => JSDocType.t = "%identity"
  }
  module JSDocTypeReferencingNode = {
    open JSDocTypeReferencingNode
    type t = Union.t4<JSDocVariadicType.t, JSDocOptionalType.t, JSDocNullableType.t, JSDocNonNullableType.t>
    type t0 = t
  }
  module JSDocTypeTag = {
    open JSDocTypeTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocTag | #Ts_JSDocTypeTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocTypeTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocTypeTag.t = "kind"
    @get
    external typeExpression: this<'tags, 'base> => JSDocTypeExpression.t = "typeExpression"
    @obj
    external make: (~kind: SyntaxKind.JSDocTypeTag.t, ~typeExpression: JSDocTypeExpression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocTypedefTag = {
    open JSDocTypedefTag
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocTag | #Ts_JSDocTypedefTag | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocTypedefTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocTypedefTag.t = "kind"
    @get
    external parent: this<'tags, 'base> => JSDoc.t = "parent"
    @get
    external fullName: this<'tags, 'base> => Union.t2<JSDocNamespaceDeclaration.t, Identifier.t> = "fullName"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external typeExpression: this<'tags, 'base> => Union.t2<JSDocTypeExpression.t, JSDocTypeLiteral.t> = "typeExpression"
    @obj
    external make: (~kind: SyntaxKind.JSDocTypedefTag.t, ~parent: JSDoc.t, ~fullName: Union.t2<JSDocNamespaceDeclaration.t, Identifier.t>, ~name: Identifier.t, ~typeExpression: Union.t2<JSDocTypeExpression.t, JSDocTypeLiteral.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
  }
  module JSDocUnknownTag = {
    open JSDocUnknownTag
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocTag | #Ts_JSDocUnknownTag | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocUnknownTag ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocTag.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocTag.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocTag: t => JSDocTag.t = "%identity"
  }
  module JSDocUnknownType = {
    open JSDocUnknownType
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocType | #Ts_JSDocUnknownType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocUnknownType ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocUnknownType.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.JSDocUnknownType.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocType: t => JSDocType.t = "%identity"
  }
  module JSDocVariadicType = {
    open JSDocVariadicType
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocType | #Ts_JSDocVariadicType | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JSDocVariadicType ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JSDocVariadicType.t = "kind"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: SyntaxKind.JSDocVariadicType.t, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asJSDocType: t => JSDocType.t = "%identity"
  }
  module JsFileExtensionInfo = {
    open JsFileExtensionInfo
    type t = FileExtensionInfo.t
    type t0 = t
  }
  module JsonMinusNumericLiteral = {
    open JsonMinusNumericLiteral
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_JsonMinusNumericLiteral | #Ts_Node | #Ts_PrefixUnaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsonMinusNumericLiteral ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.PrefixUnaryExpression.t = "kind"
    @get
    external operator: this<'tags, 'base> => SyntaxKind.MinusToken.t = "operator"
    @get
    external operand: this<'tags, 'base> => NumericLiteral.t = "operand"
    @obj
    external make: (~kind: SyntaxKind.PrefixUnaryExpression.t, ~operator: SyntaxKind.MinusToken.t, ~operand: NumericLiteral.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrefixUnaryExpression: t => PrefixUnaryExpression.t = "%identity"
  }
  module JsonObjectExpression = {
    open JsonObjectExpression
    type t = Union.t7<ObjectLiteralExpression.t, ArrayLiteralExpression.t, JsonMinusNumericLiteral.t, NumericLiteral.t, StringLiteral.t, BooleanLiteral.t, NullLiteral.t>
    type t0 = t
  }
  module JsonObjectExpressionStatement = {
    open JsonObjectExpressionStatement
    type t = t
    type t0 = t
    type tags = [#Ts_ExpressionStatement | #Ts_JSDocContainer | #Ts_JsonObjectExpressionStatement | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsonObjectExpressionStatement ]
    @get
    external expression: this<'tags, 'base> => JsonObjectExpression.t = "expression"
    @obj
    external make: ~expression: JsonObjectExpression.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asExpressionStatement: t => ExpressionStatement.t = "%identity"
  }
  module JsonSourceFile = {
    open JsonSourceFile
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JsonSourceFile | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SourceFile]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsonSourceFile ]
    @get
    external statements: this<'tags, 'base> => NodeArray.t<JsonObjectExpressionStatement.t> = "statements"
    @obj
    external make: ~statements: NodeArray.t<JsonObjectExpressionStatement.t> => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asSourceFile: t => SourceFile.t = "%identity"
  }
  module JsxAttribute = {
    open JsxAttribute
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JsxAttribute | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxAttribute ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JsxAttribute.t = "kind"
    @get
    external parent: this<'tags, 'base> => JsxAttributes.t = "parent"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external initializer: this<'tags, 'base> => Union.t2<StringLiteral.t, JsxExpression.t> = "initializer"
    @obj
    external make: (~kind: SyntaxKind.JsxAttribute.t, ~parent: JsxAttributes.t, ~name: Identifier.t, ~initializer: Union.t2<StringLiteral.t, JsxExpression.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asObjectLiteralElement: t => ObjectLiteralElement.t = "%identity"
  }
  module JsxAttributeLike = {
    open JsxAttributeLike
    type t = Union.t2<JsxAttribute.t, JsxSpreadAttribute.t>
    type t0 = t
  }
  module JsxAttributes = {
    open JsxAttributes
    type t = t
    type t0 = t
    type tags = [#Ts_ObjectLiteralExpressionBase(JsxAttributeLike.t) | #Ts_Declaration | #Ts_Expression | #Ts_JsxAttributes | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxAttributes ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JsxAttributes.t = "kind"
    @get
    external parent: this<'tags, 'base> => JsxOpeningLikeElement.t = "parent"
    @obj
    external make: (~kind: SyntaxKind.JsxAttributes.t, ~parent: JsxOpeningLikeElement.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asObjectLiteralExpressionBase: t => ObjectLiteralExpressionBase.t<JsxAttributeLike.t> = "%identity"
  }
  module JsxChild = {
    open JsxChild
    type t = Union.t5<JsxText.t, JsxExpression.t, JsxElement.t, JsxSelfClosingElement.t, JsxFragment.t>
    type t0 = t
  }
  module JsxClosingElement = {
    open JsxClosingElement
    type t = t
    type t0 = t
    type tags = [#Ts_JsxClosingElement | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxClosingElement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JsxClosingElement.t = "kind"
    @get
    external parent: this<'tags, 'base> => JsxElement.t = "parent"
    @get
    external tagName: this<'tags, 'base> => JsxTagNameExpression.t = "tagName"
    @obj
    external make: (~kind: SyntaxKind.JsxClosingElement.t, ~parent: JsxElement.t, ~tagName: JsxTagNameExpression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module JsxClosingFragment = {
    open JsxClosingFragment
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_JsxClosingFragment | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxClosingFragment ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JsxClosingFragment.t = "kind"
    @get
    external parent: this<'tags, 'base> => JsxFragment.t = "parent"
    @obj
    external make: (~kind: SyntaxKind.JsxClosingFragment.t, ~parent: JsxFragment.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asExpression: t => Expression.t = "%identity"
  }
  module JsxClosingTagInfo = {
    open JsxClosingTagInfo
    type t = t
    type t0 = t
    type tags = [#Ts_JsxClosingTagInfo]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxClosingTagInfo ]
    @get
    external newText: this<'tags, 'base> => string = "newText"
    @obj
    external make: ~newText: string => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module JsxElement = {
    open JsxElement
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_JsxElement | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxElement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JsxElement.t = "kind"
    @get
    external openingElement: this<'tags, 'base> => JsxOpeningElement.t = "openingElement"
    @get
    external children: this<'tags, 'base> => NodeArray.t<JsxChild.t> = "children"
    @get
    external closingElement: this<'tags, 'base> => JsxClosingElement.t = "closingElement"
    @obj
    external make: (~kind: SyntaxKind.JsxElement.t, ~openingElement: JsxOpeningElement.t, ~children: NodeArray.t<JsxChild.t>, ~closingElement: JsxClosingElement.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
  }
  module JsxEmit = {
    open JsxEmit
    type t = t = None | Preserve | React | ReactNative | ReactJSX | ReactJSXDev
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("JsxEmit") @val
      external value: t = "None"
    }
    module Preserve = {
      open Preserve
      type t = t
      type t0 = t
      @module("typescript") @scope("JsxEmit") @val
      external value: t = "Preserve"
    }
    module React = {
      open React
      type t = t
      type t0 = t
      @module("typescript") @scope("JsxEmit") @val
      external value: t = "React"
    }
    module ReactNative = {
      open ReactNative
      type t = t
      type t0 = t
      @module("typescript") @scope("JsxEmit") @val
      external value: t = "ReactNative"
    }
    module ReactJSX = {
      open ReactJSX
      type t = t
      type t0 = t
      @module("typescript") @scope("JsxEmit") @val
      external value: t = "ReactJSX"
    }
    module ReactJSXDev = {
      open ReactJSXDev
      type t = t
      type t0 = t
      @module("typescript") @scope("JsxEmit") @val
      external value: t = "ReactJSXDev"
    }
  }
  module JsxExpression = {
    open JsxExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_JsxExpression | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JsxExpression.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t3<JsxElement.t, JsxFragment.t, JsxAttributeLike.t> = "parent"
    @get
    external dotDotDotToken: this<'tags, 'base> => Token.t<SyntaxKind.DotDotDotToken.t> = "dotDotDotToken"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.JsxExpression.t, ~parent: Union.t3<JsxElement.t, JsxFragment.t, JsxAttributeLike.t>, ~dotDotDotToken: Token.t<SyntaxKind.DotDotDotToken.t>, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asExpression: t => Expression.t = "%identity"
  }
  module JsxFlags = {
    open JsxFlags
    type t = t = None | IntrinsicNamedElement | IntrinsicIndexedElement | IntrinsicElement
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("JsxFlags") @val
      external value: t = "None"
    }
    module IntrinsicNamedElement = {
      open IntrinsicNamedElement
      type t = t
      type t0 = t
      @module("typescript") @scope("JsxFlags") @val
      external value: t = "IntrinsicNamedElement"
    }
    module IntrinsicIndexedElement = {
      open IntrinsicIndexedElement
      type t = t
      type t0 = t
      @module("typescript") @scope("JsxFlags") @val
      external value: t = "IntrinsicIndexedElement"
    }
    module IntrinsicElement = {
      open IntrinsicElement
      type t = t
      type t0 = t
      @module("typescript") @scope("JsxFlags") @val
      external value: t = "IntrinsicElement"
    }
  }
  module JsxFragment = {
    open JsxFragment
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_JsxFragment | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxFragment ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JsxFragment.t = "kind"
    @get
    external openingFragment: this<'tags, 'base> => JsxOpeningFragment.t = "openingFragment"
    @get
    external children: this<'tags, 'base> => NodeArray.t<JsxChild.t> = "children"
    @get
    external closingFragment: this<'tags, 'base> => JsxClosingFragment.t = "closingFragment"
    @obj
    external make: (~kind: SyntaxKind.JsxFragment.t, ~openingFragment: JsxOpeningFragment.t, ~children: NodeArray.t<JsxChild.t>, ~closingFragment: JsxClosingFragment.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
  }
  module JsxOpeningElement = {
    open JsxOpeningElement
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_JsxOpeningElement | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxOpeningElement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JsxOpeningElement.t = "kind"
    @get
    external parent: this<'tags, 'base> => JsxElement.t = "parent"
    @get
    external tagName: this<'tags, 'base> => JsxTagNameExpression.t = "tagName"
    @get
    external typeArguments: this<'tags, 'base> => NodeArray.t<TypeNode.t> = "typeArguments"
    @get
    external attributes: this<'tags, 'base> => JsxAttributes.t = "attributes"
    @obj
    external make: (~kind: SyntaxKind.JsxOpeningElement.t, ~parent: JsxElement.t, ~tagName: JsxTagNameExpression.t, ~typeArguments: NodeArray.t<TypeNode.t>, ~attributes: JsxAttributes.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asExpression: t => Expression.t = "%identity"
  }
  module JsxOpeningFragment = {
    open JsxOpeningFragment
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_JsxOpeningFragment | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxOpeningFragment ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JsxOpeningFragment.t = "kind"
    @get
    external parent: this<'tags, 'base> => JsxFragment.t = "parent"
    @obj
    external make: (~kind: SyntaxKind.JsxOpeningFragment.t, ~parent: JsxFragment.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asExpression: t => Expression.t = "%identity"
  }
  module JsxOpeningLikeElement = {
    open JsxOpeningLikeElement
    type t = Union.t2<JsxSelfClosingElement.t, JsxOpeningElement.t>
    type t0 = t
  }
  module JsxSelfClosingElement = {
    open JsxSelfClosingElement
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_JsxSelfClosingElement | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxSelfClosingElement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JsxSelfClosingElement.t = "kind"
    @get
    external tagName: this<'tags, 'base> => JsxTagNameExpression.t = "tagName"
    @get
    external typeArguments: this<'tags, 'base> => NodeArray.t<TypeNode.t> = "typeArguments"
    @get
    external attributes: this<'tags, 'base> => JsxAttributes.t = "attributes"
    @obj
    external make: (~kind: SyntaxKind.JsxSelfClosingElement.t, ~tagName: JsxTagNameExpression.t, ~typeArguments: NodeArray.t<TypeNode.t>, ~attributes: JsxAttributes.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
  }
  module JsxSpreadAttribute = {
    open JsxSpreadAttribute
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JsxSpreadAttribute | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxSpreadAttribute ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JsxSpreadAttribute.t = "kind"
    @get
    external parent: this<'tags, 'base> => JsxAttributes.t = "parent"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.JsxSpreadAttribute.t, ~parent: JsxAttributes.t, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asObjectLiteralElement: t => ObjectLiteralElement.t = "%identity"
  }
  module JsxTagNameExpression = {
    open JsxTagNameExpression
    type t = Union.t3<Identifier.t, ThisExpression.t, JsxTagNamePropertyAccess.t>
    type t0 = t
  }
  module JsxTagNamePropertyAccess = {
    open JsxTagNamePropertyAccess
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Expression | #Ts_JsxTagNamePropertyAccess | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyAccessExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxTagNamePropertyAccess ]
    @get
    external expression: this<'tags, 'base> => JsxTagNameExpression.t = "expression"
    @obj
    external make: ~expression: JsxTagNameExpression.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPropertyAccessExpression: t => PropertyAccessExpression.t = "%identity"
  }
  module JsxText = {
    open JsxText
    type t = t
    type t0 = t
    type tags = [#Ts_JsxText | #Ts_LiteralLikeNode | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_JsxText ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.JsxText.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t2<JsxElement.t, JsxFragment.t> = "parent"
    @get
    external containsOnlyTriviaWhiteSpaces: this<'tags, 'base> => bool = "containsOnlyTriviaWhiteSpaces"
    @obj
    external make: (~kind: SyntaxKind.JsxText.t, ~parent: Union.t2<JsxElement.t, JsxFragment.t>, ~containsOnlyTriviaWhiteSpaces: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLiteralLikeNode: t => LiteralLikeNode.t = "%identity"
  }
  module JsxTokenSyntaxKind = {
    open JsxTokenSyntaxKind
    type t = Union.t7<SyntaxKind.LessThanSlashToken.t, SyntaxKind.EndOfFileToken.t, SyntaxKind.ConflictMarkerTrivia.t, SyntaxKind.JsxText.t, SyntaxKind.JsxTextAllWhiteSpaces.t, SyntaxKind.OpenBraceToken.t, SyntaxKind.LessThanToken.t>
    type t0 = t
  }
  module KeywordSyntaxKind = {
    open KeywordSyntaxKind
    type t = Union.t8<SyntaxKind.AbstractKeyword.t, SyntaxKind.AnyKeyword.t, SyntaxKind.AsKeyword.t, SyntaxKind.AssertsKeyword.t, SyntaxKind.AssertKeyword.t, SyntaxKind.AsyncKeyword.t, SyntaxKind.AwaitKeyword.t, Union.t8<SyntaxKind.BigIntKeyword.t, SyntaxKind.BooleanKeyword.t, SyntaxKind.BreakKeyword.t, SyntaxKind.CaseKeyword.t, SyntaxKind.CatchKeyword.t, SyntaxKind.ClassKeyword.t, SyntaxKind.ConstKeyword.t, Union.t8<SyntaxKind.ConstructorKeyword.t, SyntaxKind.ContinueKeyword.t, SyntaxKind.DebuggerKeyword.t, SyntaxKind.DeclareKeyword.t, SyntaxKind.DefaultKeyword.t, SyntaxKind.DeleteKeyword.t, SyntaxKind.DoKeyword.t, Union.t8<SyntaxKind.ElseKeyword.t, SyntaxKind.EnumKeyword.t, SyntaxKind.ExportKeyword.t, SyntaxKind.ExtendsKeyword.t, SyntaxKind.FalseKeyword.t, SyntaxKind.FinallyKeyword.t, SyntaxKind.ForKeyword.t, Union.t8<SyntaxKind.FromKeyword.t, SyntaxKind.FunctionKeyword.t, SyntaxKind.GetKeyword.t, SyntaxKind.GlobalKeyword.t, SyntaxKind.IfKeyword.t, SyntaxKind.ImplementsKeyword.t, SyntaxKind.ImportKeyword.t, Union.t8<SyntaxKind.InferKeyword.t, SyntaxKind.InKeyword.t, SyntaxKind.InstanceOfKeyword.t, SyntaxKind.InterfaceKeyword.t, SyntaxKind.IntrinsicKeyword.t, SyntaxKind.IsKeyword.t, SyntaxKind.KeyOfKeyword.t, Union.t8<SyntaxKind.LetKeyword.t, SyntaxKind.ModuleKeyword.t, SyntaxKind.NamespaceKeyword.t, SyntaxKind.NeverKeyword.t, SyntaxKind.NewKeyword.t, SyntaxKind.NullKeyword.t, SyntaxKind.NumberKeyword.t, Union.t8<SyntaxKind.ObjectKeyword.t, SyntaxKind.OfKeyword.t, SyntaxKind.PackageKeyword.t, SyntaxKind.PrivateKeyword.t, SyntaxKind.ProtectedKeyword.t, SyntaxKind.PublicKeyword.t, SyntaxKind.ReadonlyKeyword.t, Union.t8<SyntaxKind.OverrideKeyword.t, SyntaxKind.RequireKeyword.t, SyntaxKind.ReturnKeyword.t, SyntaxKind.SetKeyword.t, SyntaxKind.StaticKeyword.t, SyntaxKind.StringKeyword.t, SyntaxKind.SuperKeyword.t, Union.t8<SyntaxKind.SwitchKeyword.t, SyntaxKind.SymbolKeyword.t, SyntaxKind.ThisKeyword.t, SyntaxKind.ThrowKeyword.t, SyntaxKind.TrueKeyword.t, SyntaxKind.TryKeyword.t, SyntaxKind.TypeKeyword.t, Union.t8<SyntaxKind.TypeOfKeyword.t, SyntaxKind.UndefinedKeyword.t, SyntaxKind.UniqueKeyword.t, SyntaxKind.UnknownKeyword.t, SyntaxKind.VarKeyword.t, SyntaxKind.VoidKeyword.t, SyntaxKind.WhileKeyword.t, Union.t2<SyntaxKind.WithKeyword.t, SyntaxKind.YieldKeyword.t>>>>>>>>>>>>
    type t0 = t
  }
  module KeywordToken = {
    open KeywordToken
    type t<'TKind> = t<'TKind>
    type t1<'TKind> = t<'TKind>
    type tags<'TKind> = [#Ts_KeywordToken('TKind) | #Ts_Token('TKind) | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags1<'TKind> = tags<'TKind>
    type this<'tags, 'base, 'TKind> = intf<'tags, 'base> constraint 'tags = [> #Ts_KeywordToken('TKind) ]
    external castFrom: this<'tags, 'base, 'TKind> => t<'TKind> = "%identity"
    external asToken: t<'TKind> => Token.t<'TKind> = "%identity"
  }
  module KeywordTypeNode = {
    open KeywordTypeNode
    type t<'TKind> = t<'TKind>
    type t1<'TKind> = t<'TKind>
    type t0 = t<KeywordTypeSyntaxKind.t>
    type tags<'TKind> = [#Ts_KeywordToken('TKind) | #Ts_KeywordTypeNode('TKind) | #Ts_Token('TKind) | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags1<'TKind> = tags<'TKind>
    type tags0 = tags<KeywordTypeSyntaxKind.t>
    type this<'tags, 'base, 'TKind> = intf<'tags, 'base> constraint 'tags = [> #Ts_KeywordTypeNode('TKind) ]
    @get
    external kind: this<'tags, 'base, 'TKind> => 'TKind = "kind"
    @obj
    external make: ~kind: 'TKind => t<'TKind> = ""
    external castFrom: this<'tags, 'base, 'TKind> => t<'TKind> = "%identity"
    external asKeywordToken: t<'TKind> => KeywordToken.t<'TKind> = "%identity"
    external asTypeNode: t<'TKind> => TypeNode.t = "%identity"
  }
  module KeywordTypeSyntaxKind = {
    open KeywordTypeSyntaxKind
    type t = Union.t8<SyntaxKind.AnyKeyword.t, SyntaxKind.BigIntKeyword.t, SyntaxKind.BooleanKeyword.t, SyntaxKind.IntrinsicKeyword.t, SyntaxKind.NeverKeyword.t, SyntaxKind.NumberKeyword.t, SyntaxKind.ObjectKeyword.t, Union.t5<SyntaxKind.StringKeyword.t, SyntaxKind.SymbolKeyword.t, SyntaxKind.UndefinedKeyword.t, SyntaxKind.UnknownKeyword.t, SyntaxKind.VoidKeyword.t>>
    type t0 = t
  }
  module LabeledStatement = {
    open LabeledStatement
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocContainer | #Ts_LabeledStatement | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_LabeledStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.LabeledStatement.t = "kind"
    @get
    external label: this<'tags, 'base> => Identifier.t = "label"
    @get
    external statement: this<'tags, 'base> => Statement.t = "statement"
    @obj
    external make: (~kind: SyntaxKind.LabeledStatement.t, ~label: Identifier.t, ~statement: Statement.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module LanguageService = {
    open LanguageService
    type t = t
    type t0 = t
    type tags = [#Ts_LanguageService]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_LanguageService ]
    @send
    external cleanupSemanticCache: this<'tags, 'base> => unit = "cleanupSemanticCache"
    @send
    external getSyntacticDiagnostics: (this<'tags, 'base>, ~fileName:string) => array<DiagnosticWithLocation.t> = "getSyntacticDiagnostics"
    @send
    external getSemanticDiagnostics: (this<'tags, 'base>, ~fileName:string) => array<Diagnostic.t> = "getSemanticDiagnostics"
    @send
    external getSuggestionDiagnostics: (this<'tags, 'base>, ~fileName:string) => array<DiagnosticWithLocation.t> = "getSuggestionDiagnostics"
    @send
    external getCompilerOptionsDiagnostics: this<'tags, 'base> => array<Diagnostic.t> = "getCompilerOptionsDiagnostics"
    @send
    external getSyntacticClassifications: (this<'tags, 'base>, ~fileName:string, ~span:TextSpan.t) => array<ClassifiedSpan.t> = "getSyntacticClassifications"
    @send
    external getSyntacticClassifications': (this<'tags, 'base>, ~fileName:string, ~span:TextSpan.t, ~format:SemanticClassificationFormat.t) => Union.t2<array<ClassifiedSpan.t>, array<ClassifiedSpan2020.t>> = "getSyntacticClassifications"
    @send
    external getSemanticClassifications: (this<'tags, 'base>, ~fileName:string, ~span:TextSpan.t) => array<ClassifiedSpan.t> = "getSemanticClassifications"
    @send
    external getSemanticClassifications': (this<'tags, 'base>, ~fileName:string, ~span:TextSpan.t, ~format:SemanticClassificationFormat.t) => Union.t2<array<ClassifiedSpan.t>, array<ClassifiedSpan2020.t>> = "getSemanticClassifications"
    @send
    external getEncodedSyntacticClassifications: (this<'tags, 'base>, ~fileName:string, ~span:TextSpan.t) => Classifications.t = "getEncodedSyntacticClassifications"
    @send
    external getEncodedSemanticClassifications: (this<'tags, 'base>, ~fileName:string, ~span:TextSpan.t, ~format:SemanticClassificationFormat.t=?, unit) => Classifications.t = "getEncodedSemanticClassifications"
    @send @return(nullable)
    external getCompletionsAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float, ~options:undefined<GetCompletionsAtPositionOptions.t>, ~formattingSettings:FormatCodeSettings.t=?, unit) => option<WithMetadata.t<CompletionInfo.t>> = "getCompletionsAtPosition"
    @send @return(nullable)
    external getCompletionEntryDetails: (this<'tags, 'base>, ~fileName:string, ~position:float, ~entryName:string, ~formatOptions:undefined<Union.t2<FormatCodeOptions.t, FormatCodeSettings.t>>, ~source:undefined<string>, ~preferences:undefined<UserPreferences.t>, ~data:undefined<CompletionEntryData.t>) => option<CompletionEntryDetails.t> = "getCompletionEntryDetails"
    @send @return(nullable)
    external getCompletionEntrySymbol: (this<'tags, 'base>, ~fileName:string, ~position:float, ~name:string, ~source:undefined<string>) => option<Symbol.t> = "getCompletionEntrySymbol"
    @send @return(nullable)
    external getQuickInfoAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float) => option<QuickInfo.t> = "getQuickInfoAtPosition"
    @send @return(nullable)
    external getNameOrDottedNameSpan: (this<'tags, 'base>, ~fileName:string, ~startPos:float, ~endPos:float) => option<TextSpan.t> = "getNameOrDottedNameSpan"
    @send @return(nullable)
    external getBreakpointStatementAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float) => option<TextSpan.t> = "getBreakpointStatementAtPosition"
    @send @return(nullable)
    external getSignatureHelpItems: (this<'tags, 'base>, ~fileName:string, ~position:float, ~options:undefined<SignatureHelpItemsOptions.t>) => option<SignatureHelpItems.t> = "getSignatureHelpItems"
    @send
    external getRenameInfo: (this<'tags, 'base>, ~fileName:string, ~position:float, ~options:RenameInfoOptions.t=?, unit) => RenameInfo.t = "getRenameInfo"
    @send @return(nullable)
    external findRenameLocations: (this<'tags, 'base>, ~fileName:string, ~position:float, ~findInStrings:bool, ~findInComments:bool, ~providePrefixAndSuffixTextForRename:bool=?, unit) => option<array<RenameLocation.t>> = "findRenameLocations"
    @send
    external getSmartSelectionRange: (this<'tags, 'base>, ~fileName:string, ~position:float) => SelectionRange.t = "getSmartSelectionRange"
    @send @return(nullable)
    external getDefinitionAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float) => option<array<DefinitionInfo.t>> = "getDefinitionAtPosition"
    @send @return(nullable)
    external getDefinitionAndBoundSpan: (this<'tags, 'base>, ~fileName:string, ~position:float) => option<DefinitionInfoAndBoundSpan.t> = "getDefinitionAndBoundSpan"
    @send @return(nullable)
    external getTypeDefinitionAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float) => option<array<DefinitionInfo.t>> = "getTypeDefinitionAtPosition"
    @send @return(nullable)
    external getImplementationAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float) => option<array<ImplementationLocation.t>> = "getImplementationAtPosition"
    @send @return(nullable)
    external getReferencesAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float) => option<array<ReferenceEntry.t>> = "getReferencesAtPosition"
    @send @return(nullable)
    external findReferences: (this<'tags, 'base>, ~fileName:string, ~position:float) => option<array<ReferencedSymbol.t>> = "findReferences"
    @send @return(nullable)
    external getDocumentHighlights: (this<'tags, 'base>, ~fileName:string, ~position:float, ~filesToSearch:array<string>) => option<array<DocumentHighlights.t>> = "getDocumentHighlights"
    @send
    external getFileReferences: (this<'tags, 'base>, ~fileName:string) => array<ReferenceEntry.t> = "getFileReferences"
    @send @return(nullable)
    external getOccurrencesAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float) => option<array<ReferenceEntry.t>> = "getOccurrencesAtPosition"
    @send
    external getNavigateToItems: (this<'tags, 'base>, ~searchValue:string, ~maxResultCount:float=?, ~fileName:string=?, ~excludeDtsFiles:bool=?, unit) => array<NavigateToItem.t> = "getNavigateToItems"
    @send
    external getNavigationBarItems: (this<'tags, 'base>, ~fileName:string) => array<NavigationBarItem.t> = "getNavigationBarItems"
    @send
    external getNavigationTree: (this<'tags, 'base>, ~fileName:string) => NavigationTree.t = "getNavigationTree"
    @send @return(nullable)
    external prepareCallHierarchy: (this<'tags, 'base>, ~fileName:string, ~position:float) => option<Union.t2<CallHierarchyItem.t, array<CallHierarchyItem.t>>> = "prepareCallHierarchy"
    @send
    external provideCallHierarchyIncomingCalls: (this<'tags, 'base>, ~fileName:string, ~position:float) => array<CallHierarchyIncomingCall.t> = "provideCallHierarchyIncomingCalls"
    @send
    external provideCallHierarchyOutgoingCalls: (this<'tags, 'base>, ~fileName:string, ~position:float) => array<CallHierarchyOutgoingCall.t> = "provideCallHierarchyOutgoingCalls"
    @send
    external provideInlayHints: (this<'tags, 'base>, ~fileName:string, ~span:TextSpan.t, ~preferences:undefined<UserPreferences.t>) => array<InlayHint.t> = "provideInlayHints"
    @send
    external getOutliningSpans: (this<'tags, 'base>, ~fileName:string) => array<OutliningSpan.t> = "getOutliningSpans"
    @send
    external getTodoComments: (this<'tags, 'base>, ~fileName:string, ~descriptors:array<TodoCommentDescriptor.t>) => array<TodoComment.t> = "getTodoComments"
    @send
    external getBraceMatchingAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float) => array<TextSpan.t> = "getBraceMatchingAtPosition"
    @send
    external getIndentationAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float, ~options:Union.t2<EditorOptions.t, EditorSettings.t>) => float = "getIndentationAtPosition"
    @send
    external getFormattingEditsForRange: (this<'tags, 'base>, ~fileName:string, ~start:float, ~end:float, ~options:Union.t2<FormatCodeOptions.t, FormatCodeSettings.t>) => array<TextChange.t> = "getFormattingEditsForRange"
    @send
    external getFormattingEditsForDocument: (this<'tags, 'base>, ~fileName:string, ~options:Union.t2<FormatCodeOptions.t, FormatCodeSettings.t>) => array<TextChange.t> = "getFormattingEditsForDocument"
    @send
    external getFormattingEditsAfterKeystroke: (this<'tags, 'base>, ~fileName:string, ~position:float, ~key:string, ~options:Union.t2<FormatCodeOptions.t, FormatCodeSettings.t>) => array<TextChange.t> = "getFormattingEditsAfterKeystroke"
    @send @return(nullable)
    external getDocCommentTemplateAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float, ~options:DocCommentTemplateOptions.t=?, unit) => option<TextInsertion.t> = "getDocCommentTemplateAtPosition"
    @send
    external isValidBraceCompletionAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float, ~openingBrace:float) => bool = "isValidBraceCompletionAtPosition"
    @send @return(nullable)
    external getJsxClosingTagAtPosition: (this<'tags, 'base>, ~fileName:string, ~position:float) => option<JsxClosingTagInfo.t> = "getJsxClosingTagAtPosition"
    @send @return(nullable)
    external getSpanOfEnclosingComment: (this<'tags, 'base>, ~fileName:string, ~position:float, ~onlyMultiLine:bool) => option<TextSpan.t> = "getSpanOfEnclosingComment"
    @send
    external toLineColumnOffset: (this<'tags, 'base>, ~fileName:string, ~position:float) => LineAndCharacter.t = "toLineColumnOffset"
    @send
    external getCodeFixesAtPosition: (this<'tags, 'base>, ~fileName:string, ~start:float, ~end:float, ~errorCodes:array<float>, ~formatOptions:FormatCodeSettings.t, ~preferences:UserPreferences.t) => array<CodeFixAction.t> = "getCodeFixesAtPosition"
    @send
    external getCombinedCodeFix: (this<'tags, 'base>, ~scope:CombinedCodeFixScope.t, ~fixId:untyped_object, ~formatOptions:FormatCodeSettings.t, ~preferences:UserPreferences.t) => CombinedCodeActions.t = "getCombinedCodeFix"
    @send
    external applyCodeActionCommand: (this<'tags, 'base>, ~action:CodeActionCommand.t, ~formatSettings:FormatCodeSettings.t=?, unit) => Js.Promise.t<ApplyCodeActionCommandResult.t> = "applyCodeActionCommand"
    @send
    external applyCodeActionCommand': (this<'tags, 'base>, ~action:array<CodeActionCommand.t>, ~formatSettings:FormatCodeSettings.t=?, unit) => Js.Promise.t<array<ApplyCodeActionCommandResult.t>> = "applyCodeActionCommand"
    @send
    external applyCodeActionCommand'': (this<'tags, 'base>, ~action:Union.t2<CodeActionCommand.t, array<CodeActionCommand.t>>, ~formatSettings:FormatCodeSettings.t=?, unit) => Js.Promise.t<Union.t2<ApplyCodeActionCommandResult.t, array<ApplyCodeActionCommandResult.t>>> = "applyCodeActionCommand"
    @send
    external applyCodeActionCommand''': (this<'tags, 'base>, ~fileName:string, ~action:CodeActionCommand.t) => Js.Promise.t<ApplyCodeActionCommandResult.t> = "applyCodeActionCommand"
    @send
    external applyCodeActionCommand'''': (this<'tags, 'base>, ~fileName:string, ~action:array<CodeActionCommand.t>) => Js.Promise.t<array<ApplyCodeActionCommandResult.t>> = "applyCodeActionCommand"
    @send
    external applyCodeActionCommand''''': (this<'tags, 'base>, ~fileName:string, ~action:Union.t2<CodeActionCommand.t, array<CodeActionCommand.t>>) => Js.Promise.t<Union.t2<ApplyCodeActionCommandResult.t, array<ApplyCodeActionCommandResult.t>>> = "applyCodeActionCommand"
    @send
    external getApplicableRefactors: (this<'tags, 'base>, ~fileName:string, ~positionOrRange:Union.t2<float, TextRange.t>, ~preferences:undefined<UserPreferences.t>, ~triggerReason:RefactorTriggerReason.t=?, ~kind:string=?, unit) => array<ApplicableRefactorInfo.t> = "getApplicableRefactors"
    @send @return(nullable)
    external getEditsForRefactor: (this<'tags, 'base>, ~fileName:string, ~formatOptions:FormatCodeSettings.t, ~positionOrRange:Union.t2<float, TextRange.t>, ~refactorName:string, ~actionName:string, ~preferences:undefined<UserPreferences.t>) => option<RefactorEditInfo.t> = "getEditsForRefactor"
    @send
    external organizeImports: (this<'tags, 'base>, ~args:OrganizeImportsArgs.t, ~formatOptions:FormatCodeSettings.t, ~preferences:undefined<UserPreferences.t>) => array<FileTextChanges.t> = "organizeImports"
    @send
    external getEditsForFileRename: (this<'tags, 'base>, ~oldFilePath:string, ~newFilePath:string, ~formatOptions:FormatCodeSettings.t, ~preferences:undefined<UserPreferences.t>) => array<FileTextChanges.t> = "getEditsForFileRename"
    @send
    external getEmitOutput: (this<'tags, 'base>, ~fileName:string, ~emitOnlyDtsFiles:bool=?, ~forceDtsEmit:bool=?, unit) => EmitOutput.t = "getEmitOutput"
    @send @return(nullable)
    external getProgram: this<'tags, 'base> => option<Program.t> = "getProgram"
    @send
    external toggleLineComment: (this<'tags, 'base>, ~fileName:string, ~textRange:TextRange.t) => array<TextChange.t> = "toggleLineComment"
    @send
    external toggleMultilineComment: (this<'tags, 'base>, ~fileName:string, ~textRange:TextRange.t) => array<TextChange.t> = "toggleMultilineComment"
    @send
    external commentSelection: (this<'tags, 'base>, ~fileName:string, ~textRange:TextRange.t) => array<TextChange.t> = "commentSelection"
    @send
    external uncommentSelection: (this<'tags, 'base>, ~fileName:string, ~textRange:TextRange.t) => array<TextChange.t> = "uncommentSelection"
    @send
    external dispose: this<'tags, 'base> => unit = "dispose"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module LanguageServiceHost = {
    open LanguageServiceHost
    type t = t
    type t0 = t
    type tags = [#Ts_GetEffectiveTypeRootsHost | #Ts_LanguageServiceHost]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_LanguageServiceHost ]
    @send
    external getCompilationSettings: this<'tags, 'base> => CompilerOptions.t = "getCompilationSettings"
    @send
    external getNewLine: this<'tags, 'base> => string = "getNewLine"
    @send
    external getProjectVersion: this<'tags, 'base> => string = "getProjectVersion"
    @send
    external getScriptFileNames: this<'tags, 'base> => array<string> = "getScriptFileNames"
    @send
    external getScriptKind: (this<'tags, 'base>, ~fileName:string) => ScriptKind.t = "getScriptKind"
    @send
    external getScriptVersion: (this<'tags, 'base>, ~fileName:string) => string = "getScriptVersion"
    @send @return(nullable)
    external getScriptSnapshot: (this<'tags, 'base>, ~fileName:string) => option<IScriptSnapshot.t> = "getScriptSnapshot"
    @send @return(nullable)
    external getProjectReferences: this<'tags, 'base> => option<array<ProjectReference.t>> = "getProjectReferences"
    @send
    external getLocalizedDiagnosticMessages: this<'tags, 'base> => any = "getLocalizedDiagnosticMessages"
    @send
    external getCancellationToken: this<'tags, 'base> => HostCancellationToken.t = "getCancellationToken"
    @send
    external getCurrentDirectory: this<'tags, 'base> => string = "getCurrentDirectory"
    @send
    external getDefaultLibFileName: (this<'tags, 'base>, ~options:CompilerOptions.t) => string = "getDefaultLibFileName"
    @send
    external log: (this<'tags, 'base>, ~s:string) => unit = "log"
    @send
    external trace: (this<'tags, 'base>, ~s:string) => unit = "trace"
    @send
    external error: (this<'tags, 'base>, ~s:string) => unit = "error"
    @send
    external useCaseSensitiveFileNames: this<'tags, 'base> => bool = "useCaseSensitiveFileNames"
    @send
    external readDirectory: (this<'tags, 'base>, ~path:string, ~extensions:array<string>=?, ~exclude:array<string>=?, ~\"include":array<string>=?, ~depth:float=?, unit) => array<string> = "readDirectory"
    @send @return(nullable)
    external readFile: (this<'tags, 'base>, ~path:string, ~encoding:string=?, unit) => option<string> = "readFile"
    @send
    external realpath: (this<'tags, 'base>, ~path:string) => string = "realpath"
    @send
    external fileExists: (this<'tags, 'base>, ~path:string) => bool = "fileExists"
    @send
    external getTypeRootsVersion: this<'tags, 'base> => float = "getTypeRootsVersion"
    @send
    external resolveModuleNames: (this<'tags, 'base>, ~moduleNames:array<string>, ~containingFile:string, ~reusedNames:undefined<array<string>>, ~redirectedReference:undefined<ResolvedProjectReference.t>, ~options:CompilerOptions.t, ~containingSourceFile:SourceFile.t=?, unit) => array<undefined<ResolvedModule.t>> = "resolveModuleNames"
    @send @return(nullable)
    external getResolvedModuleWithFailedLookupLocationsFromCache: (this<'tags, 'base>, ~modulename:string, ~containingFile:string, ~resolutionMode:Union.t2<ModuleKind.CommonJS.t, ModuleKind.ESNext.t>=?, unit) => option<ResolvedModuleWithFailedLookupLocations.t> = "getResolvedModuleWithFailedLookupLocationsFromCache"
    @send
    external resolveTypeReferenceDirectives: (this<'tags, 'base>, ~typeDirectiveNames:array<string>, ~containingFile:string, ~redirectedReference:undefined<ResolvedProjectReference.t>, ~options:CompilerOptions.t) => array<undefined<ResolvedTypeReferenceDirective.t>> = "resolveTypeReferenceDirectives"
    @send
    external getDirectories: (this<'tags, 'base>, ~directoryName:string) => array<string> = "getDirectories"
    @send @return(nullable)
    external getCustomTransformers: this<'tags, 'base> => option<CustomTransformers.t> = "getCustomTransformers"
    @send
    external isKnownTypesPackageName: (this<'tags, 'base>, ~name:string) => bool = "isKnownTypesPackageName"
    @send
    external installPackage: (this<'tags, 'base>, ~options:InstallPackageOptions.t) => Js.Promise.t<ApplyCodeActionCommandResult.t> = "installPackage"
    @send
    external writeFile: (this<'tags, 'base>, ~fileName:string, ~content:string) => unit = "writeFile"
    @send @return(nullable)
    external getParsedCommandLine: (this<'tags, 'base>, ~fileName:string) => option<ParsedCommandLine.t> = "getParsedCommandLine"
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asGetEffectiveTypeRootsHost: t => GetEffectiveTypeRootsHost.t = "%identity"
  }
  module LanguageServiceMode = {
    open LanguageServiceMode
    type t = t = Semantic | PartialSemantic | Syntactic
    type t_0 = t
    module Semantic = {
      open Semantic
      type t = t
      type t0 = t
      @module("typescript") @scope("LanguageServiceMode") @val
      external value: t = "Semantic"
    }
    module PartialSemantic = {
      open PartialSemantic
      type t = t
      type t0 = t
      @module("typescript") @scope("LanguageServiceMode") @val
      external value: t = "PartialSemantic"
    }
    module Syntactic = {
      open Syntactic
      type t = t
      type t0 = t
      @module("typescript") @scope("LanguageServiceMode") @val
      external value: t = "Syntactic"
    }
  }
  module LanguageVariant = {
    open LanguageVariant
    type t = t = Standard | JSX
    type t_0 = t
    module Standard = {
      open Standard
      type t = t
      type t0 = t
      @module("typescript") @scope("LanguageVariant") @val
      external value: t = "Standard"
    }
    module JSX = {
      open JSX
      type t = t
      type t0 = t
      @module("typescript") @scope("LanguageVariant") @val
      external value: t = "JSX"
    }
  }
  module LeftHandSideExpression = {
    open LeftHandSideExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_LeftHandSideExpression ]
    @get
    external get_leftHandSideExpressionBrand: this<'tags, 'base> => any = "_leftHandSideExpressionBrand"
    @set
    external set_leftHandSideExpressionBrand: (this<'tags, 'base>, any) => unit = "_leftHandSideExpressionBrand"
    @obj
    external make: ~\"_leftHandSideExpressionBrand": any => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asUpdateExpression: t => UpdateExpression.t = "%identity"
  }
  module LineAndCharacter = {
    open LineAndCharacter
    type t = t
    type t0 = t
    type tags = [#Ts_LineAndCharacter]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_LineAndCharacter ]
    @get
    external getLine: this<'tags, 'base> => float = "line"
    @set
    external setLine: (this<'tags, 'base>, float) => unit = "line"
    @get
    external getCharacter: this<'tags, 'base> => float = "character"
    @set
    external setCharacter: (this<'tags, 'base>, float) => unit = "character"
    @obj
    external make: (~line: float, ~character: float) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ListFormat = {
    open ListFormat
    type t = t
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "None"
    }
    module SingleLine = {
      open SingleLine
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "SingleLine"
    }
    module MultiLine = {
      open MultiLine
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "MultiLine"
    }
    module PreserveLines = {
      open PreserveLines
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "PreserveLines"
    }
    module LinesMask = {
      open LinesMask
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "LinesMask"
    }
    module NotDelimited = {
      open NotDelimited
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "NotDelimited"
    }
    module BarDelimited = {
      open BarDelimited
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "BarDelimited"
    }
    module AmpersandDelimited = {
      open AmpersandDelimited
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "AmpersandDelimited"
    }
    module CommaDelimited = {
      open CommaDelimited
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "CommaDelimited"
    }
    module AsteriskDelimited = {
      open AsteriskDelimited
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "AsteriskDelimited"
    }
    module DelimitersMask = {
      open DelimitersMask
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "DelimitersMask"
    }
    module AllowTrailingComma = {
      open AllowTrailingComma
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "AllowTrailingComma"
    }
    module Indented = {
      open Indented
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "Indented"
    }
    module SpaceBetweenBraces = {
      open SpaceBetweenBraces
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "SpaceBetweenBraces"
    }
    module SpaceBetweenSiblings = {
      open SpaceBetweenSiblings
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "SpaceBetweenSiblings"
    }
    module Braces = {
      open Braces
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "Braces"
    }
    module Parenthesis = {
      open Parenthesis
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "Parenthesis"
    }
    module AngleBrackets = {
      open AngleBrackets
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "AngleBrackets"
    }
    module SquareBrackets = {
      open SquareBrackets
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "SquareBrackets"
    }
    module BracketsMask = {
      open BracketsMask
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "BracketsMask"
    }
    module OptionalIfUndefined = {
      open OptionalIfUndefined
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "OptionalIfUndefined"
    }
    module OptionalIfEmpty = {
      open OptionalIfEmpty
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "OptionalIfEmpty"
    }
    module Optional = {
      open Optional
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "Optional"
    }
    module PreferNewLine = {
      open PreferNewLine
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "PreferNewLine"
    }
    module NoTrailingNewLine = {
      open NoTrailingNewLine
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "NoTrailingNewLine"
    }
    module NoInterveningComments = {
      open NoInterveningComments
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "NoInterveningComments"
    }
    module NoSpaceIfEmpty = {
      open NoSpaceIfEmpty
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "NoSpaceIfEmpty"
    }
    module SingleElement = {
      open SingleElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "SingleElement"
    }
    module SpaceAfterList = {
      open SpaceAfterList
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "SpaceAfterList"
    }
    module Modifiers = {
      open Modifiers
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "Modifiers"
    }
    module HeritageClauses = {
      open HeritageClauses
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "HeritageClauses"
    }
    module SingleLineTypeLiteralMembers = {
      open SingleLineTypeLiteralMembers
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "SingleLineTypeLiteralMembers"
    }
    module MultiLineTypeLiteralMembers = {
      open MultiLineTypeLiteralMembers
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "MultiLineTypeLiteralMembers"
    }
    module SingleLineTupleTypeElements = {
      open SingleLineTupleTypeElements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "SingleLineTupleTypeElements"
    }
    module MultiLineTupleTypeElements = {
      open MultiLineTupleTypeElements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "MultiLineTupleTypeElements"
    }
    module UnionTypeConstituents = {
      open UnionTypeConstituents
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "UnionTypeConstituents"
    }
    module IntersectionTypeConstituents = {
      open IntersectionTypeConstituents
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "IntersectionTypeConstituents"
    }
    module ObjectBindingPatternElements = {
      open ObjectBindingPatternElements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "ObjectBindingPatternElements"
    }
    module ArrayBindingPatternElements = {
      open ArrayBindingPatternElements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "ArrayBindingPatternElements"
    }
    module ObjectLiteralExpressionProperties = {
      open ObjectLiteralExpressionProperties
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "ObjectLiteralExpressionProperties"
    }
    module ImportClauseEntries = {
      open ImportClauseEntries
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "ImportClauseEntries"
    }
    module ArrayLiteralExpressionElements = {
      open ArrayLiteralExpressionElements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "ArrayLiteralExpressionElements"
    }
    module CommaListElements = {
      open CommaListElements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "CommaListElements"
    }
    module CallExpressionArguments = {
      open CallExpressionArguments
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "CallExpressionArguments"
    }
    module NewExpressionArguments = {
      open NewExpressionArguments
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "NewExpressionArguments"
    }
    module TemplateExpressionSpans = {
      open TemplateExpressionSpans
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "TemplateExpressionSpans"
    }
    module SingleLineBlockStatements = {
      open SingleLineBlockStatements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "SingleLineBlockStatements"
    }
    module MultiLineBlockStatements = {
      open MultiLineBlockStatements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "MultiLineBlockStatements"
    }
    module VariableDeclarationList = {
      open VariableDeclarationList
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "VariableDeclarationList"
    }
    module SingleLineFunctionBodyStatements = {
      open SingleLineFunctionBodyStatements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "SingleLineFunctionBodyStatements"
    }
    module MultiLineFunctionBodyStatements = {
      open MultiLineFunctionBodyStatements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "MultiLineFunctionBodyStatements"
    }
    module ClassHeritageClauses = {
      open ClassHeritageClauses
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "ClassHeritageClauses"
    }
    module ClassMembers = {
      open ClassMembers
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "ClassMembers"
    }
    module InterfaceMembers = {
      open InterfaceMembers
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "InterfaceMembers"
    }
    module EnumMembers = {
      open EnumMembers
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "EnumMembers"
    }
    module CaseBlockClauses = {
      open CaseBlockClauses
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "CaseBlockClauses"
    }
    module NamedImportsOrExportsElements = {
      open NamedImportsOrExportsElements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "NamedImportsOrExportsElements"
    }
    module JsxElementOrFragmentChildren = {
      open JsxElementOrFragmentChildren
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "JsxElementOrFragmentChildren"
    }
    module JsxElementAttributes = {
      open JsxElementAttributes
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "JsxElementAttributes"
    }
    module CaseOrDefaultClauseStatements = {
      open CaseOrDefaultClauseStatements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "CaseOrDefaultClauseStatements"
    }
    module HeritageClauseTypes = {
      open HeritageClauseTypes
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "HeritageClauseTypes"
    }
    module SourceFileStatements = {
      open SourceFileStatements
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "SourceFileStatements"
    }
    module Decorators = {
      open Decorators
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "Decorators"
    }
    module TypeArguments = {
      open TypeArguments
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "TypeArguments"
    }
    module TypeParameters = {
      open TypeParameters
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "TypeParameters"
    }
    module Parameters = {
      open Parameters
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "Parameters"
    }
    module IndexSignatureParameters = {
      open IndexSignatureParameters
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "IndexSignatureParameters"
    }
    module JSDocComment = {
      open JSDocComment
      type t = t
      type t0 = t
      @module("typescript") @scope("ListFormat") @val
      external value: t = "JSDocComment"
    }
  }
  module LiteralExpression = {
    open LiteralExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_LiteralExpression | #Ts_LiteralLikeNode | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_LiteralExpression ]
    @get
    external get_literalExpressionBrand: this<'tags, 'base> => any = "_literalExpressionBrand"
    @set
    external set_literalExpressionBrand: (this<'tags, 'base>, any) => unit = "_literalExpressionBrand"
    @obj
    external make: ~\"_literalExpressionBrand": any => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLiteralLikeNode: t => LiteralLikeNode.t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
  }
  module LiteralLikeNode = {
    open LiteralLikeNode
    type t = t
    type t0 = t
    type tags = [#Ts_LiteralLikeNode | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_LiteralLikeNode ]
    @get
    external getText: this<'tags, 'base> => string = "text"
    @set
    external setText: (this<'tags, 'base>, string) => unit = "text"
    @get
    external getIsUnterminated: this<'tags, 'base> => bool = "isUnterminated"
    @set
    external setIsUnterminated: (this<'tags, 'base>, bool) => unit = "isUnterminated"
    @get
    external getHasExtendedUnicodeEscape: this<'tags, 'base> => bool = "hasExtendedUnicodeEscape"
    @set
    external setHasExtendedUnicodeEscape: (this<'tags, 'base>, bool) => unit = "hasExtendedUnicodeEscape"
    @obj
    external make: (~text: string, ~isUnterminated: bool, ~hasExtendedUnicodeEscape: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module LiteralSyntaxKind = {
    open LiteralSyntaxKind
    type t = Union.t7<SyntaxKind.NumericLiteral.t, SyntaxKind.BigIntLiteral.t, SyntaxKind.StringLiteral.t, SyntaxKind.JsxText.t, SyntaxKind.JsxTextAllWhiteSpaces.t, SyntaxKind.RegularExpressionLiteral.t, SyntaxKind.NoSubstitutionTemplateLiteral.t>
    type t0 = t
  }
  module LiteralToken = {
    open LiteralToken
    type t = Union.t6<NumericLiteral.t, BigIntLiteral.t, StringLiteral.t, JsxText.t, RegularExpressionLiteral.t, NoSubstitutionTemplateLiteral.t>
    type t0 = t
  }
  module LiteralType = {
    open LiteralType
    type t = t
    type t0 = t
    type tags = [#Ts_LiteralType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_LiteralType ]
    @get
    external getValue: this<'tags, 'base> => Union.t3<string, float, PseudoBigInt.t> = "value"
    @set
    external setValue: (this<'tags, 'base>, Union.t3<string, float, PseudoBigInt.t>) => unit = "value"
    @get
    external getFreshType: this<'tags, 'base> => t = "freshType"
    @set
    external setFreshType: (this<'tags, 'base>, t) => unit = "freshType"
    @get
    external getRegularType: this<'tags, 'base> => t = "regularType"
    @set
    external setRegularType: (this<'tags, 'base>, t) => unit = "regularType"
    @obj
    external make: (~value: Union.t3<string, float, PseudoBigInt.t>, ~freshType: t, ~regularType: t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asType: t => Type.t = "%identity"
  }
  module LiteralTypeNode = {
    open LiteralTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_LiteralTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_LiteralTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.LiteralType.t = "kind"
    @get
    external literal: this<'tags, 'base> => Union.t4<NullLiteral.t, BooleanLiteral.t, LiteralExpression.t, PrefixUnaryExpression.t> = "literal"
    @obj
    external make: (~kind: SyntaxKind.LiteralType.t, ~literal: Union.t4<NullLiteral.t, BooleanLiteral.t, LiteralExpression.t, PrefixUnaryExpression.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
  }
  module LogicalOperator = {
    open LogicalOperator
    type t = Union.t2<SyntaxKind.AmpersandAmpersandToken.t, SyntaxKind.BarBarToken.t>
    type t0 = t
  }
  module LogicalOperatorOrHigher = {
    open LogicalOperatorOrHigher
    type t = Union.t2<BitwiseOperatorOrHigher.t, LogicalOperator.t>
    type t0 = t
  }
  module LogicalOrCoalescingAssignmentOperator = {
    open LogicalOrCoalescingAssignmentOperator
    type t = Union.t3<SyntaxKind.AmpersandAmpersandEqualsToken.t, SyntaxKind.BarBarEqualsToken.t, SyntaxKind.QuestionQuestionEqualsToken.t>
    type t0 = t
  }
  module Map = {
    open Map
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_Collection(string) | #Ts_Map('T) | #Ts_ReadonlyCollection(string) | #Ts_ESMap(string, 'T) | #Ts_ReadonlyESMap(string, 'T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_Map('T) ]
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asESMap: t<'T> => ESMap.t<string, 'T> = "%identity"
    external asESMap': t<'T> => ESMap.t<string, 'T> = "%identity"
  }
  module MapLike = {
    open MapLike
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_MapLike('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_MapLike('T) ]
    @get_index
    external get: (this<'tags, 'base, 'T>, string) => 'T = ""
    @set_index
    external set: (this<'tags, 'base, 'T>, string, 'T) => unit = ""
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
  }
  module MappedTypeNode = {
    open MappedTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_MappedTypeNode | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_MappedTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.MappedType.t = "kind"
    @get
    external readonlyToken: this<'tags, 'base> => Union.t3<ReadonlyKeyword.t, PlusToken.t, MinusToken.t> = "readonlyToken"
    @get
    external typeParameter: this<'tags, 'base> => TypeParameterDeclaration.t = "typeParameter"
    @get
    external nameType: this<'tags, 'base> => TypeNode.t = "nameType"
    @get
    external questionToken: this<'tags, 'base> => Union.t3<QuestionToken.t, PlusToken.t, MinusToken.t> = "questionToken"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @get
    external members: this<'tags, 'base> => NodeArray.t<TypeElement.t> = "members"
    @obj
    external make: (~kind: SyntaxKind.MappedType.t, ~readonlyToken: Union.t3<ReadonlyKeyword.t, PlusToken.t, MinusToken.t>, ~typeParameter: TypeParameterDeclaration.t, ~nameType: TypeNode.t, ~questionToken: Union.t3<QuestionToken.t, PlusToken.t, MinusToken.t>, ~\"type": TypeNode.t, ~members: NodeArray.t<TypeElement.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module MemberExpression = {
    open MemberExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_MemberExpression ]
    @get
    external get_memberExpressionBrand: this<'tags, 'base> => any = "_memberExpressionBrand"
    @set
    external set_memberExpressionBrand: (this<'tags, 'base>, any) => unit = "_memberExpressionBrand"
    @obj
    external make: ~\"_memberExpressionBrand": any => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLeftHandSideExpression: t => LeftHandSideExpression.t = "%identity"
  }
  module MemberName = {
    open MemberName
    type t = Union.t2<Identifier.t, PrivateIdentifier.t>
    type t0 = t
  }
  module MetaProperty = {
    open MetaProperty
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_MetaProperty | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_MetaProperty ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.MetaProperty.t = "kind"
    @get
    external keywordToken: this<'tags, 'base> => Union.t2<SyntaxKind.NewKeyword.t, SyntaxKind.ImportKeyword.t> = "keywordToken"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @obj
    external make: (~kind: SyntaxKind.MetaProperty.t, ~keywordToken: Union.t2<SyntaxKind.NewKeyword.t, SyntaxKind.ImportKeyword.t>, ~name: Identifier.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
  }
  module MethodDeclaration = {
    open MethodDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_ClassElement | #Ts_Declaration | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_MethodDeclaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_MethodDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.MethodDeclaration.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t2<ClassLikeDeclaration.t, ObjectLiteralExpression.t> = "parent"
    @get
    external name: this<'tags, 'base> => PropertyName.t = "name"
    @get
    external body: this<'tags, 'base> => FunctionBody.t = "body"
    @obj
    external make: (~kind: SyntaxKind.MethodDeclaration.t, ~parent: Union.t2<ClassLikeDeclaration.t, ObjectLiteralExpression.t>, ~name: PropertyName.t, ~body: FunctionBody.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFunctionLikeDeclarationBase: t => FunctionLikeDeclarationBase.t = "%identity"
    external asClassElement: t => ClassElement.t = "%identity"
    external asObjectLiteralElement: t => ObjectLiteralElement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module MethodSignature = {
    open MethodSignature
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocContainer | #Ts_MethodSignature | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase | #Ts_TypeElement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_MethodSignature ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.MethodSignature.t = "kind"
    @get
    external parent: this<'tags, 'base> => ObjectTypeDeclaration.t = "parent"
    @get
    external name: this<'tags, 'base> => PropertyName.t = "name"
    @obj
    external make: (~kind: SyntaxKind.MethodSignature.t, ~parent: ObjectTypeDeclaration.t, ~name: PropertyName.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asSignatureDeclarationBase: t => SignatureDeclarationBase.t = "%identity"
    external asTypeElement: t => TypeElement.t = "%identity"
  }
  module MinusToken = {
    open MinusToken
    type t = PunctuationToken.t<SyntaxKind.MinusToken.t>
    type t0 = t
  }
  module MissingDeclaration = {
    open MissingDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_MissingDeclaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_MissingDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.MissingDeclaration.t = "kind"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @obj
    external make: (~kind: SyntaxKind.MissingDeclaration.t, ~name: Identifier.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDeclarationStatement: t => DeclarationStatement.t = "%identity"
  }
  module ModeAwareCache = {
    open ModeAwareCache
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_ModeAwareCache('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_ModeAwareCache('T) ]
    @send @return(nullable)
    external get: (this<'tags, 'base, 'T>, ~key:string, ~mode:undefined<Union.t2<ModuleKind.CommonJS.t, ModuleKind.ESNext.t>>) => option<'T> = "get"
    @send
    external set: (this<'tags, 'base, 'T>, ~key:string, ~mode:undefined<Union.t2<ModuleKind.CommonJS.t, ModuleKind.ESNext.t>>, ~value:'T) => this<'tags, 'base, 'T> = "set"
    @send
    external delete: (this<'tags, 'base, 'T>, ~key:string, ~mode:undefined<Union.t2<ModuleKind.CommonJS.t, ModuleKind.ESNext.t>>) => this<'tags, 'base, 'T> = "delete"
    @send
    external has: (this<'tags, 'base, 'T>, ~key:string, ~mode:undefined<Union.t2<ModuleKind.CommonJS.t, ModuleKind.ESNext.t>>) => bool = "has"
    @send
    external forEach: (this<'tags, 'base, 'T>, ~cb:(@uncurry (~elem:'T, ~key:string, ~mode:undefined<Union.t2<ModuleKind.CommonJS.t, ModuleKind.ESNext.t>>) => unit)) => unit = "forEach"
    @send
    external size: this<'tags, 'base, 'T> => float = "size"
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
  }
  module Modifier = {
    open Modifier
    type t = Union.t8<AbstractKeyword.t, AsyncKeyword.t, ConstKeyword.t, DeclareKeyword.t, DefaultKeyword.t, ExportKeyword.t, PrivateKeyword.t, Union.t5<ProtectedKeyword.t, PublicKeyword.t, OverrideKeyword.t, ReadonlyKeyword.t, StaticKeyword.t>>
    type t0 = t
  }
  module ModifierFlags = {
    open ModifierFlags
    type t = t
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "None"
    }
    module Export_ = {
      open Export_
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Export"
    }
    module Ambient = {
      open Ambient
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Ambient"
    }
    module Public = {
      open Public
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Public"
    }
    module Private = {
      open Private
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Private"
    }
    module Protected = {
      open Protected
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Protected"
    }
    module Static = {
      open Static
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Static"
    }
    module Readonly = {
      open Readonly
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Readonly"
    }
    module Abstract = {
      open Abstract
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Abstract"
    }
    module Async = {
      open Async
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Async"
    }
    module Default_ = {
      open Default_
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Default"
    }
    module Const = {
      open Const
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Const"
    }
    module HasComputedJSDocModifiers = {
      open HasComputedJSDocModifiers
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "HasComputedJSDocModifiers"
    }
    module Deprecated = {
      open Deprecated
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Deprecated"
    }
    module Override = {
      open Override
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "Override"
    }
    module HasComputedFlags = {
      open HasComputedFlags
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "HasComputedFlags"
    }
    module AccessibilityModifier = {
      open AccessibilityModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "AccessibilityModifier"
    }
    module ParameterPropertyModifier = {
      open ParameterPropertyModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "ParameterPropertyModifier"
    }
    module NonPublicAccessibilityModifier = {
      open NonPublicAccessibilityModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "NonPublicAccessibilityModifier"
    }
    module TypeScriptModifier = {
      open TypeScriptModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "TypeScriptModifier"
    }
    module ExportDefault = {
      open ExportDefault
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "ExportDefault"
    }
    module All = {
      open All
      type t = t
      type t0 = t
      @module("typescript") @scope("ModifierFlags") @val
      external value: t = "All"
    }
  }
  module ModifierSyntaxKind = {
    open ModifierSyntaxKind
    type t = Union.t8<SyntaxKind.AbstractKeyword.t, SyntaxKind.AsyncKeyword.t, SyntaxKind.ConstKeyword.t, SyntaxKind.DeclareKeyword.t, SyntaxKind.DefaultKeyword.t, SyntaxKind.ExportKeyword.t, SyntaxKind.PrivateKeyword.t, Union.t5<SyntaxKind.ProtectedKeyword.t, SyntaxKind.PublicKeyword.t, SyntaxKind.ReadonlyKeyword.t, SyntaxKind.OverrideKeyword.t, SyntaxKind.StaticKeyword.t>>
    type t0 = t
  }
  module ModifierToken = {
    open ModifierToken
    type t<'TKind> = t<'TKind>
    type t1<'TKind> = t<'TKind>
    type tags<'TKind> = [#Ts_KeywordToken('TKind) | #Ts_ModifierToken('TKind) | #Ts_Token('TKind) | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags1<'TKind> = tags<'TKind>
    type this<'tags, 'base, 'TKind> = intf<'tags, 'base> constraint 'tags = [> #Ts_ModifierToken('TKind) ]
    external castFrom: this<'tags, 'base, 'TKind> => t<'TKind> = "%identity"
    external asKeywordToken: t<'TKind> => KeywordToken.t<'TKind> = "%identity"
  }
  module ModifiersArray = {
    open ModifiersArray
    type t = NodeArray.t<Modifier.t>
    type t0 = t
  }
  module ModuleBlock = {
    open ModuleBlock
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocContainer | #Ts_ModuleBlock | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ModuleBlock ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ModuleBlock.t = "kind"
    @get
    external parent: this<'tags, 'base> => ModuleDeclaration.t = "parent"
    @get
    external statements: this<'tags, 'base> => NodeArray.t<Statement.t> = "statements"
    @obj
    external make: (~kind: SyntaxKind.ModuleBlock.t, ~parent: ModuleDeclaration.t, ~statements: NodeArray.t<Statement.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module ModuleBody = {
    open ModuleBody
    type t = Union.t2<NamespaceBody.t, JSDocNamespaceBody.t>
    type t0 = t
  }
  module ModuleDeclaration = {
    open ModuleDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_ModuleDeclaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ModuleDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ModuleDeclaration.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t2<ModuleBody.t, SourceFile.t> = "parent"
    @get
    external name: this<'tags, 'base> => ModuleName.t = "name"
    @get
    external body: this<'tags, 'base> => Union.t2<ModuleBody.t, JSDocNamespaceDeclaration.t> = "body"
    @obj
    external make: (~kind: SyntaxKind.ModuleDeclaration.t, ~parent: Union.t2<ModuleBody.t, SourceFile.t>, ~name: ModuleName.t, ~body: Union.t2<ModuleBody.t, JSDocNamespaceDeclaration.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDeclarationStatement: t => DeclarationStatement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module ModuleKind = {
    open ModuleKind
    type t = t
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleKind") @val
      external value: t = "None"
    }
    module CommonJS = {
      open CommonJS
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleKind") @val
      external value: t = "CommonJS"
    }
    module AMD = {
      open AMD
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleKind") @val
      external value: t = "AMD"
    }
    module UMD = {
      open UMD
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleKind") @val
      external value: t = "UMD"
    }
    module System = {
      open System
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleKind") @val
      external value: t = "System"
    }
    module ES2015 = {
      open ES2015
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleKind") @val
      external value: t = "ES2015"
    }
    module ES2020 = {
      open ES2020
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleKind") @val
      external value: t = "ES2020"
    }
    module ES2022 = {
      open ES2022
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleKind") @val
      external value: t = "ES2022"
    }
    module ESNext = {
      open ESNext
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleKind") @val
      external value: t = "ESNext"
    }
    module Node12 = {
      open Node12
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleKind") @val
      external value: t = "Node12"
    }
    module NodeNext = {
      open NodeNext
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleKind") @val
      external value: t = "NodeNext"
    }
  }
  module ModuleName = {
    open ModuleName
    type t = Union.t2<Identifier.t, StringLiteral.t>
    type t0 = t
  }
  module ModuleReference = {
    open ModuleReference
    type t = Union.t2<EntityName.t, ExternalModuleReference.t>
    type t0 = t
  }
  module ModuleResolutionCache = {
    open ModuleResolutionCache
    type t = t
    type t0 = t
    type tags = [#Ts_PerDirectoryResolutionCache(ResolvedModuleWithFailedLookupLocations.t) | #Ts_ModuleResolutionCache | #Ts_NonRelativeModuleNameResolutionCache | #Ts_PackageJsonInfoCache]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ModuleResolutionCache ]
    @send
    external getPackageJsonInfoCache: this<'tags, 'base> => PackageJsonInfoCache.t = "getPackageJsonInfoCache"
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPerDirectoryResolutionCache: t => PerDirectoryResolutionCache.t<ResolvedModuleWithFailedLookupLocations.t> = "%identity"
    external asNonRelativeModuleNameResolutionCache: t => NonRelativeModuleNameResolutionCache.t = "%identity"
    external asPackageJsonInfoCache: t => PackageJsonInfoCache.t = "%identity"
  }
  module ModuleResolutionHost = {
    open ModuleResolutionHost
    type t = t
    type t0 = t
    type tags = [#Ts_ModuleResolutionHost]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ModuleResolutionHost ]
    @send
    external fileExists: (this<'tags, 'base>, ~fileName:string) => bool = "fileExists"
    @send @return(nullable)
    external readFile: (this<'tags, 'base>, ~fileName:string) => option<string> = "readFile"
    @send
    external trace: (this<'tags, 'base>, ~s:string) => unit = "trace"
    @send
    external directoryExists: (this<'tags, 'base>, ~directoryName:string) => bool = "directoryExists"
    @send
    external realpath: (this<'tags, 'base>, ~path:string) => string = "realpath"
    @send
    external getCurrentDirectory: this<'tags, 'base> => string = "getCurrentDirectory"
    @send
    external getDirectories: (this<'tags, 'base>, ~path:string) => array<string> = "getDirectories"
    @get
    external getUseCaseSensitiveFileNames: this<'tags, 'base> => Union.t2<bool, (() => bool)> = "useCaseSensitiveFileNames"
    @set
    external setUseCaseSensitiveFileNames: (this<'tags, 'base>, Union.t2<bool, (() => bool)>) => unit = "useCaseSensitiveFileNames"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ModuleResolutionKind = {
    open ModuleResolutionKind
    type t = t
    type t_0 = t
    module Classic = {
      open Classic
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleResolutionKind") @val
      external value: t = "Classic"
    }
    module NodeJs = {
      open NodeJs
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleResolutionKind") @val
      external value: t = "NodeJs"
    }
    module Node12 = {
      open Node12
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleResolutionKind") @val
      external value: t = "Node12"
    }
    module NodeNext = {
      open NodeNext
      type t = t
      type t0 = t
      @module("typescript") @scope("ModuleResolutionKind") @val
      external value: t = "NodeNext"
    }
  }
  module MultiplicativeOperator = {
    open MultiplicativeOperator
    type t = Union.t3<SyntaxKind.AsteriskToken.t, SyntaxKind.SlashToken.t, SyntaxKind.PercentToken.t>
    type t0 = t
  }
  module MultiplicativeOperatorOrHigher = {
    open MultiplicativeOperatorOrHigher
    type t = Union.t2<ExponentiationOperator.t, MultiplicativeOperator.t>
    type t0 = t
  }
  module NamedDeclaration = {
    open NamedDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NamedDeclaration ]
    @get
    external name: this<'tags, 'base> => DeclarationName.t = "name"
    @obj
    external make: ~name: DeclarationName.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module NamedExportBindings = {
    open NamedExportBindings
    type t = Union.t2<NamespaceExport.t, NamedExports.t>
    type t0 = t
  }
  module NamedExports = {
    open NamedExports
    type t = t
    type t0 = t
    type tags = [#Ts_NamedExports | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NamedExports ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.NamedExports.t = "kind"
    @get
    external parent: this<'tags, 'base> => ExportDeclaration.t = "parent"
    @get
    external elements: this<'tags, 'base> => NodeArray.t<ExportSpecifier.t> = "elements"
    @obj
    external make: (~kind: SyntaxKind.NamedExports.t, ~parent: ExportDeclaration.t, ~elements: NodeArray.t<ExportSpecifier.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module NamedImportBindings = {
    open NamedImportBindings
    type t = Union.t2<NamespaceImport.t, NamedImports.t>
    type t0 = t
  }
  module NamedImports = {
    open NamedImports
    type t = t
    type t0 = t
    type tags = [#Ts_NamedImports | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NamedImports ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.NamedImports.t = "kind"
    @get
    external parent: this<'tags, 'base> => ImportClause.t = "parent"
    @get
    external elements: this<'tags, 'base> => NodeArray.t<ImportSpecifier.t> = "elements"
    @obj
    external make: (~kind: SyntaxKind.NamedImports.t, ~parent: ImportClause.t, ~elements: NodeArray.t<ImportSpecifier.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module NamedImportsOrExports = {
    open NamedImportsOrExports
    type t = Union.t2<NamedImports.t, NamedExports.t>
    type t0 = t
  }
  module NamedTupleMember = {
    open NamedTupleMember
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedTupleMember | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NamedTupleMember ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.NamedTupleMember.t = "kind"
    @get
    external dotDotDotToken: this<'tags, 'base> => Token.t<SyntaxKind.DotDotDotToken.t> = "dotDotDotToken"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external questionToken: this<'tags, 'base> => Token.t<SyntaxKind.QuestionToken.t> = "questionToken"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: SyntaxKind.NamedTupleMember.t, ~dotDotDotToken: Token.t<SyntaxKind.DotDotDotToken.t>, ~name: Identifier.t, ~questionToken: Token.t<SyntaxKind.QuestionToken.t>, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module NamespaceBody = {
    open NamespaceBody
    type t = Union.t2<ModuleBlock.t, NamespaceDeclaration.t>
    type t0 = t
  }
  module NamespaceDeclaration = {
    open NamespaceDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_ModuleDeclaration | #Ts_NamedDeclaration | #Ts_NamespaceDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NamespaceDeclaration ]
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external body: this<'tags, 'base> => NamespaceBody.t = "body"
    @obj
    external make: (~name: Identifier.t, ~body: NamespaceBody.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asModuleDeclaration: t => ModuleDeclaration.t = "%identity"
  }
  module NamespaceExport = {
    open NamespaceExport
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_NamedDeclaration | #Ts_NamespaceExport | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NamespaceExport ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.NamespaceExport.t = "kind"
    @get
    external parent: this<'tags, 'base> => ExportDeclaration.t = "parent"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @obj
    external make: (~kind: SyntaxKind.NamespaceExport.t, ~parent: ExportDeclaration.t, ~name: Identifier.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
  }
  module NamespaceExportDeclaration = {
    open NamespaceExportDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_DeclarationStatement | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_NamespaceExportDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NamespaceExportDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.NamespaceExportDeclaration.t = "kind"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @obj
    external make: (~kind: SyntaxKind.NamespaceExportDeclaration.t, ~name: Identifier.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDeclarationStatement: t => DeclarationStatement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module NamespaceImport = {
    open NamespaceImport
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_NamedDeclaration | #Ts_NamespaceImport | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NamespaceImport ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.NamespaceImport.t = "kind"
    @get
    external parent: this<'tags, 'base> => ImportClause.t = "parent"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @obj
    external make: (~kind: SyntaxKind.NamespaceImport.t, ~parent: ImportClause.t, ~name: Identifier.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
  }
  module NavigateToItem = {
    open NavigateToItem
    type t = t
    type t0 = t
    type tags = [#Ts_NavigateToItem]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NavigateToItem ]
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @get
    external getKind: this<'tags, 'base> => ScriptElementKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, ScriptElementKind.t) => unit = "kind"
    @get
    external getKindModifiers: this<'tags, 'base> => string = "kindModifiers"
    @set
    external setKindModifiers: (this<'tags, 'base>, string) => unit = "kindModifiers"
    @get
    external getMatchKind: this<'tags, 'base> => Union.t4<[#exact], [#prefix], [#substring], [#camelCase]> = "matchKind"
    @set
    external setMatchKind: (this<'tags, 'base>, Union.t4<[#exact], [#prefix], [#substring], [#camelCase]>) => unit = "matchKind"
    @get
    external getIsCaseSensitive: this<'tags, 'base> => bool = "isCaseSensitive"
    @set
    external setIsCaseSensitive: (this<'tags, 'base>, bool) => unit = "isCaseSensitive"
    @get
    external getFileName: this<'tags, 'base> => string = "fileName"
    @set
    external setFileName: (this<'tags, 'base>, string) => unit = "fileName"
    @get
    external getTextSpan: this<'tags, 'base> => TextSpan.t = "textSpan"
    @set
    external setTextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "textSpan"
    @get
    external getContainerName: this<'tags, 'base> => string = "containerName"
    @set
    external setContainerName: (this<'tags, 'base>, string) => unit = "containerName"
    @get
    external getContainerKind: this<'tags, 'base> => ScriptElementKind.t = "containerKind"
    @set
    external setContainerKind: (this<'tags, 'base>, ScriptElementKind.t) => unit = "containerKind"
    @obj
    external make: (~name: string, ~kind: ScriptElementKind.t, ~kindModifiers: string, ~matchKind: Union.t4<[#exact], [#prefix], [#substring], [#camelCase]>, ~isCaseSensitive: bool, ~fileName: string, ~textSpan: TextSpan.t, ~containerName: string, ~containerKind: ScriptElementKind.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module NavigationBarItem = {
    open NavigationBarItem
    type t = t
    type t0 = t
    type tags = [#Ts_NavigationBarItem]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NavigationBarItem ]
    @get
    external getText: this<'tags, 'base> => string = "text"
    @set
    external setText: (this<'tags, 'base>, string) => unit = "text"
    @get
    external getKind: this<'tags, 'base> => ScriptElementKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, ScriptElementKind.t) => unit = "kind"
    @get
    external getKindModifiers: this<'tags, 'base> => string = "kindModifiers"
    @set
    external setKindModifiers: (this<'tags, 'base>, string) => unit = "kindModifiers"
    @get
    external getSpans: this<'tags, 'base> => array<TextSpan.t> = "spans"
    @set
    external setSpans: (this<'tags, 'base>, array<TextSpan.t>) => unit = "spans"
    @get
    external getChildItems: this<'tags, 'base> => array<t> = "childItems"
    @set
    external setChildItems: (this<'tags, 'base>, array<t>) => unit = "childItems"
    @get
    external getIndent: this<'tags, 'base> => float = "indent"
    @set
    external setIndent: (this<'tags, 'base>, float) => unit = "indent"
    @get
    external getBolded: this<'tags, 'base> => bool = "bolded"
    @set
    external setBolded: (this<'tags, 'base>, bool) => unit = "bolded"
    @get
    external getGrayed: this<'tags, 'base> => bool = "grayed"
    @set
    external setGrayed: (this<'tags, 'base>, bool) => unit = "grayed"
    @obj
    external make: (~text: string, ~kind: ScriptElementKind.t, ~kindModifiers: string, ~spans: array<TextSpan.t>, ~childItems: array<t>, ~indent: float, ~bolded: bool, ~grayed: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module NavigationTree = {
    open NavigationTree
    type t = t
    type t0 = t
    type tags = [#Ts_NavigationTree]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NavigationTree ]
    @get
    external getText: this<'tags, 'base> => string = "text"
    @set
    external setText: (this<'tags, 'base>, string) => unit = "text"
    @get
    external getKind: this<'tags, 'base> => ScriptElementKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, ScriptElementKind.t) => unit = "kind"
    @get
    external getKindModifiers: this<'tags, 'base> => string = "kindModifiers"
    @set
    external setKindModifiers: (this<'tags, 'base>, string) => unit = "kindModifiers"
    @get
    external getSpans: this<'tags, 'base> => array<TextSpan.t> = "spans"
    @set
    external setSpans: (this<'tags, 'base>, array<TextSpan.t>) => unit = "spans"
    @get @return(nullable)
    external getNameSpan: this<'tags, 'base> => option<TextSpan.t> = "nameSpan"
    @set
    external setNameSpan: (this<'tags, 'base>, undefined<TextSpan.t>) => unit = "nameSpan"
    @get
    external getChildItems: this<'tags, 'base> => array<t> = "childItems"
    @set
    external setChildItems: (this<'tags, 'base>, array<t>) => unit = "childItems"
    @obj
    external make: (~text: string, ~kind: ScriptElementKind.t, ~kindModifiers: string, ~spans: array<TextSpan.t>, ~nameSpan: TextSpan.t=?, ~childItems: array<t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module NewExpression = {
    open NewExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NewExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NewExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.NewExpression.t = "kind"
    @get
    external expression: this<'tags, 'base> => LeftHandSideExpression.t = "expression"
    @get
    external typeArguments: this<'tags, 'base> => NodeArray.t<TypeNode.t> = "typeArguments"
    @get
    external arguments: this<'tags, 'base> => NodeArray.t<Expression.t> = "arguments"
    @obj
    external make: (~kind: SyntaxKind.NewExpression.t, ~expression: LeftHandSideExpression.t, ~typeArguments: NodeArray.t<TypeNode.t>, ~arguments: NodeArray.t<Expression.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module NewLineKind = {
    open NewLineKind
    type t = t = CarriageReturnLineFeed | LineFeed
    type t_0 = t
    module CarriageReturnLineFeed = {
      open CarriageReturnLineFeed
      type t = t
      type t0 = t
      @module("typescript") @scope("NewLineKind") @val
      external value: t = "CarriageReturnLineFeed"
    }
    module LineFeed = {
      open LineFeed
      type t = t
      type t0 = t
      @module("typescript") @scope("NewLineKind") @val
      external value: t = "LineFeed"
    }
  }
  module NoSubstitutionTemplateLiteral = {
    open NoSubstitutionTemplateLiteral
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_LiteralExpression | #Ts_LiteralLikeNode | #Ts_MemberExpression | #Ts_NoSubstitutionTemplateLiteral | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_TemplateLiteralLikeNode | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NoSubstitutionTemplateLiteral ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.NoSubstitutionTemplateLiteral.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.NoSubstitutionTemplateLiteral.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLiteralExpression: t => LiteralExpression.t = "%identity"
    external asTemplateLiteralLikeNode: t => TemplateLiteralLikeNode.t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module Node = {
    open Node
    type t = t
    type t0 = t
    type tags = [#Ts_Node | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Node ]
    @send
    external getSourceFile: this<'tags, 'base> => SourceFile.t = "getSourceFile"
    @send
    external getChildCount: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, unit) => float = "getChildCount"
    @send
    external getChildAt: (this<'tags, 'base>, ~index:float, ~sourceFile:SourceFile.t=?, unit) => Dom.node = "getChildAt"
    @send
    external getChildren: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, unit) => array<Dom.node> = "getChildren"
    @send
    external getStart: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, ~includeJsDocComment:bool=?, unit) => float = "getStart"
    @send
    external getFullStart: this<'tags, 'base> => float = "getFullStart"
    @send
    external getEnd: this<'tags, 'base> => float = "getEnd"
    @send
    external getWidth: (this<'tags, 'base>, ~sourceFile:SourceFileLike.t=?, unit) => float = "getWidth"
    @send
    external getFullWidth: this<'tags, 'base> => float = "getFullWidth"
    @send
    external getLeadingTriviaWidth: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, unit) => float = "getLeadingTriviaWidth"
    @send
    external getFullText: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, unit) => string = "getFullText"
    @send
    external getText: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, unit) => string = "getText"
    @send @return(nullable)
    external getFirstToken: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, unit) => option<Dom.node> = "getFirstToken"
    @send @return(nullable)
    external getLastToken: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, unit) => option<Dom.node> = "getLastToken"
    @send @return(nullable)
    external forEachChild: (this<'tags, 'base>, ~cbNode:(@uncurry Dom.node => undefined<'T>), ~cbNodeArray:(@uncurry NodeArray.t<Dom.node> => undefined<'T>)=?, unit) => option<'T> = "forEachChild"
    @get
    external kind: this<'tags, 'base> => SyntaxKind.t = "kind"
    @get
    external flags: this<'tags, 'base> => NodeFlags.t = "flags"
    @get
    external decorators: this<'tags, 'base> => NodeArray.t<Decorator.t> = "decorators"
    @get
    external modifiers: this<'tags, 'base> => ModifiersArray.t = "modifiers"
    @get
    external parent: this<'tags, 'base> => Dom.node = "parent"
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asReadonlyTextRange: t => ReadonlyTextRange.t = "%identity"
  }
  module NodeArray = {
    open NodeArray
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#ReadonlyArray('T) | #Ts_NodeArray('T) | #Ts_ReadonlyTextRange]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_NodeArray('T) ]
    @get
    external hasTrailingComma: this<'tags, 'base, 'T> => bool = "hasTrailingComma"
    @obj
    external make: ~hasTrailingComma: bool => t<'T> = ""
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asReadonlyArray: t<'T> => array<'T> = "%identity"
    external asReadonlyTextRange: t<'T> => ReadonlyTextRange.t = "%identity"
  }
  module NodeBuilderFlags = {
    open NodeBuilderFlags
    type t = t
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "None"
    }
    module NoTruncation = {
      open NoTruncation
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "NoTruncation"
    }
    module WriteArrayAsGenericType = {
      open WriteArrayAsGenericType
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "WriteArrayAsGenericType"
    }
    module GenerateNamesForShadowedTypeParams = {
      open GenerateNamesForShadowedTypeParams
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "GenerateNamesForShadowedTypeParams"
    }
    module UseStructuralFallback = {
      open UseStructuralFallback
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "UseStructuralFallback"
    }
    module ForbidIndexedAccessSymbolReferences = {
      open ForbidIndexedAccessSymbolReferences
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "ForbidIndexedAccessSymbolReferences"
    }
    module WriteTypeArgumentsOfSignature = {
      open WriteTypeArgumentsOfSignature
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "WriteTypeArgumentsOfSignature"
    }
    module UseFullyQualifiedType = {
      open UseFullyQualifiedType
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "UseFullyQualifiedType"
    }
    module UseOnlyExternalAliasing = {
      open UseOnlyExternalAliasing
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "UseOnlyExternalAliasing"
    }
    module SuppressAnyReturnType = {
      open SuppressAnyReturnType
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "SuppressAnyReturnType"
    }
    module WriteTypeParametersInQualifiedName = {
      open WriteTypeParametersInQualifiedName
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "WriteTypeParametersInQualifiedName"
    }
    module MultilineObjectLiterals = {
      open MultilineObjectLiterals
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "MultilineObjectLiterals"
    }
    module WriteClassExpressionAsTypeLiteral = {
      open WriteClassExpressionAsTypeLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "WriteClassExpressionAsTypeLiteral"
    }
    module UseTypeOfFunction = {
      open UseTypeOfFunction
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "UseTypeOfFunction"
    }
    module OmitParameterModifiers = {
      open OmitParameterModifiers
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "OmitParameterModifiers"
    }
    module UseAliasDefinedOutsideCurrentScope = {
      open UseAliasDefinedOutsideCurrentScope
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "UseAliasDefinedOutsideCurrentScope"
    }
    module UseSingleQuotesForStringLiteralType = {
      open UseSingleQuotesForStringLiteralType
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "UseSingleQuotesForStringLiteralType"
    }
    module NoTypeReduction = {
      open NoTypeReduction
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "NoTypeReduction"
    }
    module NoUndefinedOptionalParameterType = {
      open NoUndefinedOptionalParameterType
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "NoUndefinedOptionalParameterType"
    }
    module AllowThisInObjectLiteral = {
      open AllowThisInObjectLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "AllowThisInObjectLiteral"
    }
    module AllowQualifiedNameInPlaceOfIdentifier = {
      open AllowQualifiedNameInPlaceOfIdentifier
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "AllowQualifiedNameInPlaceOfIdentifier"
    }
    module AllowQualifedNameInPlaceOfIdentifier = {
      open AllowQualifedNameInPlaceOfIdentifier
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "AllowQualifedNameInPlaceOfIdentifier"
    }
    module AllowAnonymousIdentifier = {
      open AllowAnonymousIdentifier
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "AllowAnonymousIdentifier"
    }
    module AllowEmptyUnionOrIntersection = {
      open AllowEmptyUnionOrIntersection
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "AllowEmptyUnionOrIntersection"
    }
    module AllowEmptyTuple = {
      open AllowEmptyTuple
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "AllowEmptyTuple"
    }
    module AllowUniqueESSymbolType = {
      open AllowUniqueESSymbolType
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "AllowUniqueESSymbolType"
    }
    module AllowEmptyIndexInfoType = {
      open AllowEmptyIndexInfoType
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "AllowEmptyIndexInfoType"
    }
    module AllowNodeModulesRelativePaths = {
      open AllowNodeModulesRelativePaths
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "AllowNodeModulesRelativePaths"
    }
    module IgnoreErrors = {
      open IgnoreErrors
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "IgnoreErrors"
    }
    module InObjectTypeLiteral = {
      open InObjectTypeLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "InObjectTypeLiteral"
    }
    module InTypeAlias = {
      open InTypeAlias
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "InTypeAlias"
    }
    module InInitialEntityName = {
      open InInitialEntityName
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeBuilderFlags") @val
      external value: t = "InInitialEntityName"
    }
  }
  module NodeFactory = {
    open NodeFactory
    module AnonymousInterface14 = {
      open AnonymousInterface14
      type t = t
      @get
      external expression: t => Union.t2<Identifier.t, PropertyAccessEntityNameExpression.t> = "expression"
      @obj
      external make: ~expression: Union.t2<Identifier.t, PropertyAccessEntityNameExpression.t> => t = ""
    }
    type t = t
    type t0 = t
    type tags = [#Ts_NodeFactory]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NodeFactory ]
    @send
    external createNodeArray: (this<'tags, 'base>, ~elements:array<'T>=?, ~hasTrailingComma:bool=?, unit) => NodeArray.t<'T> = "createNodeArray"
    @send
    external createNumericLiteral: (this<'tags, 'base>, ~value:Union.t2<string, float>, ~numericLiteralFlags:TokenFlags.t=?, unit) => NumericLiteral.t = "createNumericLiteral"
    @send
    external createBigIntLiteral: (this<'tags, 'base>, ~value:Union.t2<string, PseudoBigInt.t>) => BigIntLiteral.t = "createBigIntLiteral"
    @send
    external createStringLiteral: (this<'tags, 'base>, ~text:string, ~isSingleQuote:bool=?, unit) => StringLiteral.t = "createStringLiteral"
    @send
    external createStringLiteralFromNode: (this<'tags, 'base>, ~sourceNode:PropertyNameLiteral.t, ~isSingleQuote:bool=?, unit) => StringLiteral.t = "createStringLiteralFromNode"
    @send
    external createRegularExpressionLiteral: (this<'tags, 'base>, ~text:string) => RegularExpressionLiteral.t = "createRegularExpressionLiteral"
    @send
    external createIdentifier: (this<'tags, 'base>, ~text:string) => Identifier.t = "createIdentifier"
    @send
    external createTempVariable: (this<'tags, 'base>, ~recordTempVariable:undefined<(Identifier.t => unit)>, ~reservedInNestedScopes:bool=?, unit) => Identifier.t = "createTempVariable"
    @send
    external createLoopVariable: (this<'tags, 'base>, ~reservedInNestedScopes:bool=?, unit) => Identifier.t = "createLoopVariable"
    @send
    external createUniqueName: (this<'tags, 'base>, ~text:string, ~flags:GeneratedIdentifierFlags.t=?, unit) => Identifier.t = "createUniqueName"
    @send
    external getGeneratedNameForNode: (this<'tags, 'base>, ~node:undefined<Dom.node>, ~flags:GeneratedIdentifierFlags.t=?, unit) => Identifier.t = "getGeneratedNameForNode"
    @send
    external createPrivateIdentifier: (this<'tags, 'base>, ~text:string) => PrivateIdentifier.t = "createPrivateIdentifier"
    @send
    external createToken: (this<'tags, 'base>, ~token:SyntaxKind.SuperKeyword.t) => SuperExpression.t = "createToken"
    @send
    external createToken': (this<'tags, 'base>, ~token:SyntaxKind.ThisKeyword.t) => ThisExpression.t = "createToken"
    @send
    external createToken'': (this<'tags, 'base>, ~token:SyntaxKind.NullKeyword.t) => NullLiteral.t = "createToken"
    @send
    external createToken''': (this<'tags, 'base>, ~token:SyntaxKind.TrueKeyword.t) => TrueLiteral.t = "createToken"
    @send
    external createToken'''': (this<'tags, 'base>, ~token:SyntaxKind.FalseKeyword.t) => FalseLiteral.t = "createToken"
    @send
    external createToken''''': (this<'tags, 'base>, ~token:'TKind) => PunctuationToken.t<'TKind> = "createToken"
    @send
    external createToken'''''': (this<'tags, 'base>, ~token:'TKind) => KeywordTypeNode.t<'TKind> = "createToken"
    @send
    external createToken''''''': (this<'tags, 'base>, ~token:'TKind) => ModifierToken.t<'TKind> = "createToken"
    @send
    external createToken'''''''': (this<'tags, 'base>, ~token:'TKind) => KeywordToken.t<'TKind> = "createToken"
    @send
    external createToken''''''''': (this<'tags, 'base>, ~token:'TKind) => Token.t<'TKind> = "createToken"
    @send
    external createSuper: this<'tags, 'base> => SuperExpression.t = "createSuper"
    @send
    external createThis: this<'tags, 'base> => ThisExpression.t = "createThis"
    @send
    external createNull: this<'tags, 'base> => NullLiteral.t = "createNull"
    @send
    external createTrue: this<'tags, 'base> => TrueLiteral.t = "createTrue"
    @send
    external createFalse: this<'tags, 'base> => FalseLiteral.t = "createFalse"
    @send
    external createModifier: (this<'tags, 'base>, ~kind:'T) => ModifierToken.t<'T> = "createModifier"
    @send @return(nullable)
    external createModifiersFromModifierFlags: (this<'tags, 'base>, ~flags:ModifierFlags.t) => option<array<Modifier.t>> = "createModifiersFromModifierFlags"
    @send
    external createQualifiedName: (this<'tags, 'base>, ~left:EntityName.t, ~right:Union.t2<string, Identifier.t>) => QualifiedName.t = "createQualifiedName"
    @send
    external updateQualifiedName: (this<'tags, 'base>, ~node:QualifiedName.t, ~left:EntityName.t, ~right:Identifier.t) => QualifiedName.t = "updateQualifiedName"
    @send
    external createComputedPropertyName: (this<'tags, 'base>, ~expression:Expression.t) => ComputedPropertyName.t = "createComputedPropertyName"
    @send
    external updateComputedPropertyName: (this<'tags, 'base>, ~node:ComputedPropertyName.t, ~expression:Expression.t) => ComputedPropertyName.t = "updateComputedPropertyName"
    @send
    external createTypeParameterDeclaration: (this<'tags, 'base>, ~name:Union.t2<string, Identifier.t>, ~\"constraint":TypeNode.t=?, ~defaultType:TypeNode.t=?, unit) => TypeParameterDeclaration.t = "createTypeParameterDeclaration"
    @send
    external updateTypeParameterDeclaration: (this<'tags, 'base>, ~node:TypeParameterDeclaration.t, ~name:Identifier.t, ~\"constraint":undefined<TypeNode.t>, ~defaultType:undefined<TypeNode.t>) => TypeParameterDeclaration.t = "updateTypeParameterDeclaration"
    @send
    external createParameterDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~dotDotDotToken:undefined<DotDotDotToken.t>, ~name:Union.t2<string, BindingName.t>, ~questionToken:QuestionToken.t=?, ~\"type":TypeNode.t=?, ~initializer:Expression.t=?, unit) => ParameterDeclaration.t = "createParameterDeclaration"
    @send
    external updateParameterDeclaration: (this<'tags, 'base>, ~node:ParameterDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~dotDotDotToken:undefined<DotDotDotToken.t>, ~name:Union.t2<string, BindingName.t>, ~questionToken:undefined<QuestionToken.t>, ~\"type":undefined<TypeNode.t>, ~initializer:undefined<Expression.t>) => ParameterDeclaration.t = "updateParameterDeclaration"
    @send
    external createDecorator: (this<'tags, 'base>, ~expression:Expression.t) => Decorator.t = "createDecorator"
    @send
    external updateDecorator: (this<'tags, 'base>, ~node:Decorator.t, ~expression:Expression.t) => Decorator.t = "updateDecorator"
    @send
    external createPropertySignature: (this<'tags, 'base>, ~modifiers:undefined<array<Modifier.t>>, ~name:Union.t2<PropertyName.t, string>, ~questionToken:undefined<QuestionToken.t>, ~\"type":undefined<TypeNode.t>) => PropertySignature.t = "createPropertySignature"
    @send
    external updatePropertySignature: (this<'tags, 'base>, ~node:PropertySignature.t, ~modifiers:undefined<array<Modifier.t>>, ~name:PropertyName.t, ~questionToken:undefined<QuestionToken.t>, ~\"type":undefined<TypeNode.t>) => PropertySignature.t = "updatePropertySignature"
    @send
    external createPropertyDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:Union.t2<string, PropertyName.t>, ~questionOrExclamationToken:undefined<Union.t2<QuestionToken.t, ExclamationToken.t>>, ~\"type":undefined<TypeNode.t>, ~initializer:undefined<Expression.t>) => PropertyDeclaration.t = "createPropertyDeclaration"
    @send
    external updatePropertyDeclaration: (this<'tags, 'base>, ~node:PropertyDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:Union.t2<string, PropertyName.t>, ~questionOrExclamationToken:undefined<Union.t2<QuestionToken.t, ExclamationToken.t>>, ~\"type":undefined<TypeNode.t>, ~initializer:undefined<Expression.t>) => PropertyDeclaration.t = "updatePropertyDeclaration"
    @send
    external createMethodSignature: (this<'tags, 'base>, ~modifiers:undefined<array<Modifier.t>>, ~name:Union.t2<string, PropertyName.t>, ~questionToken:undefined<QuestionToken.t>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>) => MethodSignature.t = "createMethodSignature"
    @send
    external updateMethodSignature: (this<'tags, 'base>, ~node:MethodSignature.t, ~modifiers:undefined<array<Modifier.t>>, ~name:PropertyName.t, ~questionToken:undefined<QuestionToken.t>, ~typeParameters:undefined<NodeArray.t<TypeParameterDeclaration.t>>, ~parameters:NodeArray.t<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>) => MethodSignature.t = "updateMethodSignature"
    @send
    external createMethodDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~asteriskToken:undefined<AsteriskToken.t>, ~name:Union.t2<string, PropertyName.t>, ~questionToken:undefined<QuestionToken.t>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>, ~body:undefined<Block.t>) => MethodDeclaration.t = "createMethodDeclaration"
    @send
    external updateMethodDeclaration: (this<'tags, 'base>, ~node:MethodDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~asteriskToken:undefined<AsteriskToken.t>, ~name:PropertyName.t, ~questionToken:undefined<QuestionToken.t>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>, ~body:undefined<Block.t>) => MethodDeclaration.t = "updateMethodDeclaration"
    @send
    external createConstructorDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~parameters:array<ParameterDeclaration.t>, ~body:undefined<Block.t>) => ConstructorDeclaration.t = "createConstructorDeclaration"
    @send
    external updateConstructorDeclaration: (this<'tags, 'base>, ~node:ConstructorDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~parameters:array<ParameterDeclaration.t>, ~body:undefined<Block.t>) => ConstructorDeclaration.t = "updateConstructorDeclaration"
    @send
    external createGetAccessorDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:Union.t2<string, PropertyName.t>, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>, ~body:undefined<Block.t>) => GetAccessorDeclaration.t = "createGetAccessorDeclaration"
    @send
    external updateGetAccessorDeclaration: (this<'tags, 'base>, ~node:GetAccessorDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:PropertyName.t, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>, ~body:undefined<Block.t>) => GetAccessorDeclaration.t = "updateGetAccessorDeclaration"
    @send
    external createSetAccessorDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:Union.t2<string, PropertyName.t>, ~parameters:array<ParameterDeclaration.t>, ~body:undefined<Block.t>) => SetAccessorDeclaration.t = "createSetAccessorDeclaration"
    @send
    external updateSetAccessorDeclaration: (this<'tags, 'base>, ~node:SetAccessorDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:PropertyName.t, ~parameters:array<ParameterDeclaration.t>, ~body:undefined<Block.t>) => SetAccessorDeclaration.t = "updateSetAccessorDeclaration"
    @send
    external createCallSignature: (this<'tags, 'base>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>) => CallSignatureDeclaration.t = "createCallSignature"
    @send
    external updateCallSignature: (this<'tags, 'base>, ~node:CallSignatureDeclaration.t, ~typeParameters:undefined<NodeArray.t<TypeParameterDeclaration.t>>, ~parameters:NodeArray.t<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>) => CallSignatureDeclaration.t = "updateCallSignature"
    @send
    external createConstructSignature: (this<'tags, 'base>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>) => ConstructSignatureDeclaration.t = "createConstructSignature"
    @send
    external updateConstructSignature: (this<'tags, 'base>, ~node:ConstructSignatureDeclaration.t, ~typeParameters:undefined<NodeArray.t<TypeParameterDeclaration.t>>, ~parameters:NodeArray.t<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>) => ConstructSignatureDeclaration.t = "updateConstructSignature"
    @send
    external createIndexSignature: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":TypeNode.t) => IndexSignatureDeclaration.t = "createIndexSignature"
    @send
    external updateIndexSignature: (this<'tags, 'base>, ~node:IndexSignatureDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":TypeNode.t) => IndexSignatureDeclaration.t = "updateIndexSignature"
    @send
    external createTemplateLiteralTypeSpan: (this<'tags, 'base>, ~\"type":TypeNode.t, ~literal:Union.t2<TemplateMiddle.t, TemplateTail.t>) => TemplateLiteralTypeSpan.t = "createTemplateLiteralTypeSpan"
    @send
    external updateTemplateLiteralTypeSpan: (this<'tags, 'base>, ~node:TemplateLiteralTypeSpan.t, ~\"type":TypeNode.t, ~literal:Union.t2<TemplateMiddle.t, TemplateTail.t>) => TemplateLiteralTypeSpan.t = "updateTemplateLiteralTypeSpan"
    @send
    external createClassStaticBlockDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~body:Block.t) => ClassStaticBlockDeclaration.t = "createClassStaticBlockDeclaration"
    @send
    external updateClassStaticBlockDeclaration: (this<'tags, 'base>, ~node:ClassStaticBlockDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~body:Block.t) => ClassStaticBlockDeclaration.t = "updateClassStaticBlockDeclaration"
    @send
    external createKeywordTypeNode: (this<'tags, 'base>, ~kind:'TKind) => KeywordTypeNode.t<'TKind> = "createKeywordTypeNode"
    @send
    external createTypePredicateNode: (this<'tags, 'base>, ~assertsModifier:undefined<AssertsKeyword.t>, ~parameterName:Union.t3<Identifier.t, ThisTypeNode.t, string>, ~\"type":undefined<TypeNode.t>) => TypePredicateNode.t = "createTypePredicateNode"
    @send
    external updateTypePredicateNode: (this<'tags, 'base>, ~node:TypePredicateNode.t, ~assertsModifier:undefined<AssertsKeyword.t>, ~parameterName:Union.t2<Identifier.t, ThisTypeNode.t>, ~\"type":undefined<TypeNode.t>) => TypePredicateNode.t = "updateTypePredicateNode"
    @send
    external createTypeReferenceNode: (this<'tags, 'base>, ~typeName:Union.t2<string, EntityName.t>, ~typeArguments:array<TypeNode.t>=?, unit) => TypeReferenceNode.t = "createTypeReferenceNode"
    @send
    external updateTypeReferenceNode: (this<'tags, 'base>, ~node:TypeReferenceNode.t, ~typeName:EntityName.t, ~typeArguments:undefined<NodeArray.t<TypeNode.t>>) => TypeReferenceNode.t = "updateTypeReferenceNode"
    @send
    external createFunctionTypeNode: (this<'tags, 'base>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":TypeNode.t) => FunctionTypeNode.t = "createFunctionTypeNode"
    @send
    external updateFunctionTypeNode: (this<'tags, 'base>, ~node:FunctionTypeNode.t, ~typeParameters:undefined<NodeArray.t<TypeParameterDeclaration.t>>, ~parameters:NodeArray.t<ParameterDeclaration.t>, ~\"type":TypeNode.t) => FunctionTypeNode.t = "updateFunctionTypeNode"
    @send
    external createConstructorTypeNode: (this<'tags, 'base>, ~modifiers:undefined<array<Modifier.t>>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":TypeNode.t) => ConstructorTypeNode.t = "createConstructorTypeNode"
    @send
    external createConstructorTypeNode': (this<'tags, 'base>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":TypeNode.t) => ConstructorTypeNode.t = "createConstructorTypeNode"
    @send
    external updateConstructorTypeNode: (this<'tags, 'base>, ~node:ConstructorTypeNode.t, ~modifiers:undefined<array<Modifier.t>>, ~typeParameters:undefined<NodeArray.t<TypeParameterDeclaration.t>>, ~parameters:NodeArray.t<ParameterDeclaration.t>, ~\"type":TypeNode.t) => ConstructorTypeNode.t = "updateConstructorTypeNode"
    @send
    external updateConstructorTypeNode': (this<'tags, 'base>, ~node:ConstructorTypeNode.t, ~typeParameters:undefined<NodeArray.t<TypeParameterDeclaration.t>>, ~parameters:NodeArray.t<ParameterDeclaration.t>, ~\"type":TypeNode.t) => ConstructorTypeNode.t = "updateConstructorTypeNode"
    @send
    external createTypeQueryNode: (this<'tags, 'base>, ~exprName:EntityName.t) => TypeQueryNode.t = "createTypeQueryNode"
    @send
    external updateTypeQueryNode: (this<'tags, 'base>, ~node:TypeQueryNode.t, ~exprName:EntityName.t) => TypeQueryNode.t = "updateTypeQueryNode"
    @send
    external createTypeLiteralNode: (this<'tags, 'base>, ~members:undefined<array<TypeElement.t>>) => TypeLiteralNode.t = "createTypeLiteralNode"
    @send
    external updateTypeLiteralNode: (this<'tags, 'base>, ~node:TypeLiteralNode.t, ~members:NodeArray.t<TypeElement.t>) => TypeLiteralNode.t = "updateTypeLiteralNode"
    @send
    external createArrayTypeNode: (this<'tags, 'base>, ~elementType:TypeNode.t) => ArrayTypeNode.t = "createArrayTypeNode"
    @send
    external updateArrayTypeNode: (this<'tags, 'base>, ~node:ArrayTypeNode.t, ~elementType:TypeNode.t) => ArrayTypeNode.t = "updateArrayTypeNode"
    @send
    external createTupleTypeNode: (this<'tags, 'base>, ~elements:array<Union.t2<TypeNode.t, NamedTupleMember.t>>) => TupleTypeNode.t = "createTupleTypeNode"
    @send
    external updateTupleTypeNode: (this<'tags, 'base>, ~node:TupleTypeNode.t, ~elements:array<Union.t2<TypeNode.t, NamedTupleMember.t>>) => TupleTypeNode.t = "updateTupleTypeNode"
    @send
    external createNamedTupleMember: (this<'tags, 'base>, ~dotDotDotToken:undefined<DotDotDotToken.t>, ~name:Identifier.t, ~questionToken:undefined<QuestionToken.t>, ~\"type":TypeNode.t) => NamedTupleMember.t = "createNamedTupleMember"
    @send
    external updateNamedTupleMember: (this<'tags, 'base>, ~node:NamedTupleMember.t, ~dotDotDotToken:undefined<DotDotDotToken.t>, ~name:Identifier.t, ~questionToken:undefined<QuestionToken.t>, ~\"type":TypeNode.t) => NamedTupleMember.t = "updateNamedTupleMember"
    @send
    external createOptionalTypeNode: (this<'tags, 'base>, ~\"type":TypeNode.t) => OptionalTypeNode.t = "createOptionalTypeNode"
    @send
    external updateOptionalTypeNode: (this<'tags, 'base>, ~node:OptionalTypeNode.t, ~\"type":TypeNode.t) => OptionalTypeNode.t = "updateOptionalTypeNode"
    @send
    external createRestTypeNode: (this<'tags, 'base>, ~\"type":TypeNode.t) => RestTypeNode.t = "createRestTypeNode"
    @send
    external updateRestTypeNode: (this<'tags, 'base>, ~node:RestTypeNode.t, ~\"type":TypeNode.t) => RestTypeNode.t = "updateRestTypeNode"
    @send
    external createUnionTypeNode: (this<'tags, 'base>, ~types:array<TypeNode.t>) => UnionTypeNode.t = "createUnionTypeNode"
    @send
    external updateUnionTypeNode: (this<'tags, 'base>, ~node:UnionTypeNode.t, ~types:NodeArray.t<TypeNode.t>) => UnionTypeNode.t = "updateUnionTypeNode"
    @send
    external createIntersectionTypeNode: (this<'tags, 'base>, ~types:array<TypeNode.t>) => IntersectionTypeNode.t = "createIntersectionTypeNode"
    @send
    external updateIntersectionTypeNode: (this<'tags, 'base>, ~node:IntersectionTypeNode.t, ~types:NodeArray.t<TypeNode.t>) => IntersectionTypeNode.t = "updateIntersectionTypeNode"
    @send
    external createConditionalTypeNode: (this<'tags, 'base>, ~checkType:TypeNode.t, ~extendsType:TypeNode.t, ~trueType:TypeNode.t, ~falseType:TypeNode.t) => ConditionalTypeNode.t = "createConditionalTypeNode"
    @send
    external updateConditionalTypeNode: (this<'tags, 'base>, ~node:ConditionalTypeNode.t, ~checkType:TypeNode.t, ~extendsType:TypeNode.t, ~trueType:TypeNode.t, ~falseType:TypeNode.t) => ConditionalTypeNode.t = "updateConditionalTypeNode"
    @send
    external createInferTypeNode: (this<'tags, 'base>, ~typeParameter:TypeParameterDeclaration.t) => InferTypeNode.t = "createInferTypeNode"
    @send
    external updateInferTypeNode: (this<'tags, 'base>, ~node:InferTypeNode.t, ~typeParameter:TypeParameterDeclaration.t) => InferTypeNode.t = "updateInferTypeNode"
    @send
    external createImportTypeNode: (this<'tags, 'base>, ~argument:TypeNode.t, ~qualifier:EntityName.t=?, ~typeArguments:array<TypeNode.t>=?, ~isTypeOf:bool=?, unit) => ImportTypeNode.t = "createImportTypeNode"
    @send
    external updateImportTypeNode: (this<'tags, 'base>, ~node:ImportTypeNode.t, ~argument:TypeNode.t, ~qualifier:undefined<EntityName.t>, ~typeArguments:undefined<array<TypeNode.t>>, ~isTypeOf:bool=?, unit) => ImportTypeNode.t = "updateImportTypeNode"
    @send
    external createParenthesizedType: (this<'tags, 'base>, ~\"type":TypeNode.t) => ParenthesizedTypeNode.t = "createParenthesizedType"
    @send
    external updateParenthesizedType: (this<'tags, 'base>, ~node:ParenthesizedTypeNode.t, ~\"type":TypeNode.t) => ParenthesizedTypeNode.t = "updateParenthesizedType"
    @send
    external createThisTypeNode: this<'tags, 'base> => ThisTypeNode.t = "createThisTypeNode"
    @send
    external createTypeOperatorNode: (this<'tags, 'base>, ~operator:Union.t3<SyntaxKind.KeyOfKeyword.t, SyntaxKind.UniqueKeyword.t, SyntaxKind.ReadonlyKeyword.t>, ~\"type":TypeNode.t) => TypeOperatorNode.t = "createTypeOperatorNode"
    @send
    external updateTypeOperatorNode: (this<'tags, 'base>, ~node:TypeOperatorNode.t, ~\"type":TypeNode.t) => TypeOperatorNode.t = "updateTypeOperatorNode"
    @send
    external createIndexedAccessTypeNode: (this<'tags, 'base>, ~objectType:TypeNode.t, ~indexType:TypeNode.t) => IndexedAccessTypeNode.t = "createIndexedAccessTypeNode"
    @send
    external updateIndexedAccessTypeNode: (this<'tags, 'base>, ~node:IndexedAccessTypeNode.t, ~objectType:TypeNode.t, ~indexType:TypeNode.t) => IndexedAccessTypeNode.t = "updateIndexedAccessTypeNode"
    @send
    external createMappedTypeNode: (this<'tags, 'base>, ~readonlyToken:undefined<Union.t3<ReadonlyKeyword.t, PlusToken.t, MinusToken.t>>, ~typeParameter:TypeParameterDeclaration.t, ~nameType:undefined<TypeNode.t>, ~questionToken:undefined<Union.t3<QuestionToken.t, PlusToken.t, MinusToken.t>>, ~\"type":undefined<TypeNode.t>, ~members:undefined<NodeArray.t<TypeElement.t>>) => MappedTypeNode.t = "createMappedTypeNode"
    @send
    external updateMappedTypeNode: (this<'tags, 'base>, ~node:MappedTypeNode.t, ~readonlyToken:undefined<Union.t3<ReadonlyKeyword.t, PlusToken.t, MinusToken.t>>, ~typeParameter:TypeParameterDeclaration.t, ~nameType:undefined<TypeNode.t>, ~questionToken:undefined<Union.t3<QuestionToken.t, PlusToken.t, MinusToken.t>>, ~\"type":undefined<TypeNode.t>, ~members:undefined<NodeArray.t<TypeElement.t>>) => MappedTypeNode.t = "updateMappedTypeNode"
    @send
    external createLiteralTypeNode: (this<'tags, 'base>, ~literal:Union.t4<NullLiteral.t, BooleanLiteral.t, LiteralExpression.t, PrefixUnaryExpression.t>) => LiteralTypeNode.t = "createLiteralTypeNode"
    @send
    external updateLiteralTypeNode: (this<'tags, 'base>, ~node:LiteralTypeNode.t, ~literal:Union.t4<NullLiteral.t, BooleanLiteral.t, LiteralExpression.t, PrefixUnaryExpression.t>) => LiteralTypeNode.t = "updateLiteralTypeNode"
    @send
    external createTemplateLiteralType: (this<'tags, 'base>, ~head:TemplateHead.t, ~templateSpans:array<TemplateLiteralTypeSpan.t>) => TemplateLiteralTypeNode.t = "createTemplateLiteralType"
    @send
    external updateTemplateLiteralType: (this<'tags, 'base>, ~node:TemplateLiteralTypeNode.t, ~head:TemplateHead.t, ~templateSpans:array<TemplateLiteralTypeSpan.t>) => TemplateLiteralTypeNode.t = "updateTemplateLiteralType"
    @send
    external createObjectBindingPattern: (this<'tags, 'base>, ~elements:array<BindingElement.t>) => ObjectBindingPattern.t = "createObjectBindingPattern"
    @send
    external updateObjectBindingPattern: (this<'tags, 'base>, ~node:ObjectBindingPattern.t, ~elements:array<BindingElement.t>) => ObjectBindingPattern.t = "updateObjectBindingPattern"
    @send
    external createArrayBindingPattern: (this<'tags, 'base>, ~elements:array<ArrayBindingElement.t>) => ArrayBindingPattern.t = "createArrayBindingPattern"
    @send
    external updateArrayBindingPattern: (this<'tags, 'base>, ~node:ArrayBindingPattern.t, ~elements:array<ArrayBindingElement.t>) => ArrayBindingPattern.t = "updateArrayBindingPattern"
    @send
    external createBindingElement: (this<'tags, 'base>, ~dotDotDotToken:undefined<DotDotDotToken.t>, ~propertyName:undefined<Union.t2<string, PropertyName.t>>, ~name:Union.t2<string, BindingName.t>, ~initializer:Expression.t=?, unit) => BindingElement.t = "createBindingElement"
    @send
    external updateBindingElement: (this<'tags, 'base>, ~node:BindingElement.t, ~dotDotDotToken:undefined<DotDotDotToken.t>, ~propertyName:undefined<PropertyName.t>, ~name:BindingName.t, ~initializer:undefined<Expression.t>) => BindingElement.t = "updateBindingElement"
    @send
    external createArrayLiteralExpression: (this<'tags, 'base>, ~elements:array<Expression.t>=?, ~multiLine:bool=?, unit) => ArrayLiteralExpression.t = "createArrayLiteralExpression"
    @send
    external updateArrayLiteralExpression: (this<'tags, 'base>, ~node:ArrayLiteralExpression.t, ~elements:array<Expression.t>) => ArrayLiteralExpression.t = "updateArrayLiteralExpression"
    @send
    external createObjectLiteralExpression: (this<'tags, 'base>, ~properties:array<ObjectLiteralElementLike.t>=?, ~multiLine:bool=?, unit) => ObjectLiteralExpression.t = "createObjectLiteralExpression"
    @send
    external updateObjectLiteralExpression: (this<'tags, 'base>, ~node:ObjectLiteralExpression.t, ~properties:array<ObjectLiteralElementLike.t>) => ObjectLiteralExpression.t = "updateObjectLiteralExpression"
    @send
    external createPropertyAccessExpression: (this<'tags, 'base>, ~expression:Expression.t, ~name:Union.t2<string, MemberName.t>) => PropertyAccessExpression.t = "createPropertyAccessExpression"
    @send
    external updatePropertyAccessExpression: (this<'tags, 'base>, ~node:PropertyAccessExpression.t, ~expression:Expression.t, ~name:MemberName.t) => PropertyAccessExpression.t = "updatePropertyAccessExpression"
    @send
    external createPropertyAccessChain: (this<'tags, 'base>, ~expression:Expression.t, ~questionDotToken:undefined<QuestionDotToken.t>, ~name:Union.t2<string, MemberName.t>) => PropertyAccessChain.t = "createPropertyAccessChain"
    @send
    external updatePropertyAccessChain: (this<'tags, 'base>, ~node:PropertyAccessChain.t, ~expression:Expression.t, ~questionDotToken:undefined<QuestionDotToken.t>, ~name:MemberName.t) => PropertyAccessChain.t = "updatePropertyAccessChain"
    @send
    external createElementAccessExpression: (this<'tags, 'base>, ~expression:Expression.t, ~index:Union.t2<float, Expression.t>) => ElementAccessExpression.t = "createElementAccessExpression"
    @send
    external updateElementAccessExpression: (this<'tags, 'base>, ~node:ElementAccessExpression.t, ~expression:Expression.t, ~argumentExpression:Expression.t) => ElementAccessExpression.t = "updateElementAccessExpression"
    @send
    external createElementAccessChain: (this<'tags, 'base>, ~expression:Expression.t, ~questionDotToken:undefined<QuestionDotToken.t>, ~index:Union.t2<float, Expression.t>) => ElementAccessChain.t = "createElementAccessChain"
    @send
    external updateElementAccessChain: (this<'tags, 'base>, ~node:ElementAccessChain.t, ~expression:Expression.t, ~questionDotToken:undefined<QuestionDotToken.t>, ~argumentExpression:Expression.t) => ElementAccessChain.t = "updateElementAccessChain"
    @send
    external createCallExpression: (this<'tags, 'base>, ~expression:Expression.t, ~typeArguments:undefined<array<TypeNode.t>>, ~argumentsArray:undefined<array<Expression.t>>) => CallExpression.t = "createCallExpression"
    @send
    external updateCallExpression: (this<'tags, 'base>, ~node:CallExpression.t, ~expression:Expression.t, ~typeArguments:undefined<array<TypeNode.t>>, ~argumentsArray:array<Expression.t>) => CallExpression.t = "updateCallExpression"
    @send
    external createCallChain: (this<'tags, 'base>, ~expression:Expression.t, ~questionDotToken:undefined<QuestionDotToken.t>, ~typeArguments:undefined<array<TypeNode.t>>, ~argumentsArray:undefined<array<Expression.t>>) => CallChain.t = "createCallChain"
    @send
    external updateCallChain: (this<'tags, 'base>, ~node:CallChain.t, ~expression:Expression.t, ~questionDotToken:undefined<QuestionDotToken.t>, ~typeArguments:undefined<array<TypeNode.t>>, ~argumentsArray:array<Expression.t>) => CallChain.t = "updateCallChain"
    @send
    external createNewExpression: (this<'tags, 'base>, ~expression:Expression.t, ~typeArguments:undefined<array<TypeNode.t>>, ~argumentsArray:undefined<array<Expression.t>>) => NewExpression.t = "createNewExpression"
    @send
    external updateNewExpression: (this<'tags, 'base>, ~node:NewExpression.t, ~expression:Expression.t, ~typeArguments:undefined<array<TypeNode.t>>, ~argumentsArray:undefined<array<Expression.t>>) => NewExpression.t = "updateNewExpression"
    @send
    external createTaggedTemplateExpression: (this<'tags, 'base>, ~tag:Expression.t, ~typeArguments:undefined<array<TypeNode.t>>, ~template:TemplateLiteral.t) => TaggedTemplateExpression.t = "createTaggedTemplateExpression"
    @send
    external updateTaggedTemplateExpression: (this<'tags, 'base>, ~node:TaggedTemplateExpression.t, ~tag:Expression.t, ~typeArguments:undefined<array<TypeNode.t>>, ~template:TemplateLiteral.t) => TaggedTemplateExpression.t = "updateTaggedTemplateExpression"
    @send
    external createTypeAssertion: (this<'tags, 'base>, ~\"type":TypeNode.t, ~expression:Expression.t) => TypeAssertion.t = "createTypeAssertion"
    @send
    external updateTypeAssertion: (this<'tags, 'base>, ~node:TypeAssertion.t, ~\"type":TypeNode.t, ~expression:Expression.t) => TypeAssertion.t = "updateTypeAssertion"
    @send
    external createParenthesizedExpression: (this<'tags, 'base>, ~expression:Expression.t) => ParenthesizedExpression.t = "createParenthesizedExpression"
    @send
    external updateParenthesizedExpression: (this<'tags, 'base>, ~node:ParenthesizedExpression.t, ~expression:Expression.t) => ParenthesizedExpression.t = "updateParenthesizedExpression"
    @send
    external createFunctionExpression: (this<'tags, 'base>, ~modifiers:undefined<array<Modifier.t>>, ~asteriskToken:undefined<AsteriskToken.t>, ~name:undefined<Union.t2<string, Identifier.t>>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:undefined<array<ParameterDeclaration.t>>, ~\"type":undefined<TypeNode.t>, ~body:Block.t) => FunctionExpression.t = "createFunctionExpression"
    @send
    external updateFunctionExpression: (this<'tags, 'base>, ~node:FunctionExpression.t, ~modifiers:undefined<array<Modifier.t>>, ~asteriskToken:undefined<AsteriskToken.t>, ~name:undefined<Identifier.t>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>, ~body:Block.t) => FunctionExpression.t = "updateFunctionExpression"
    @send
    external createArrowFunction: (this<'tags, 'base>, ~modifiers:undefined<array<Modifier.t>>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>, ~equalsGreaterThanToken:undefined<EqualsGreaterThanToken.t>, ~body:ConciseBody.t) => ArrowFunction.t = "createArrowFunction"
    @send
    external updateArrowFunction: (this<'tags, 'base>, ~node:ArrowFunction.t, ~modifiers:undefined<array<Modifier.t>>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>, ~equalsGreaterThanToken:EqualsGreaterThanToken.t, ~body:ConciseBody.t) => ArrowFunction.t = "updateArrowFunction"
    @send
    external createDeleteExpression: (this<'tags, 'base>, ~expression:Expression.t) => DeleteExpression.t = "createDeleteExpression"
    @send
    external updateDeleteExpression: (this<'tags, 'base>, ~node:DeleteExpression.t, ~expression:Expression.t) => DeleteExpression.t = "updateDeleteExpression"
    @send
    external createTypeOfExpression: (this<'tags, 'base>, ~expression:Expression.t) => TypeOfExpression.t = "createTypeOfExpression"
    @send
    external updateTypeOfExpression: (this<'tags, 'base>, ~node:TypeOfExpression.t, ~expression:Expression.t) => TypeOfExpression.t = "updateTypeOfExpression"
    @send
    external createVoidExpression: (this<'tags, 'base>, ~expression:Expression.t) => VoidExpression.t = "createVoidExpression"
    @send
    external updateVoidExpression: (this<'tags, 'base>, ~node:VoidExpression.t, ~expression:Expression.t) => VoidExpression.t = "updateVoidExpression"
    @send
    external createAwaitExpression: (this<'tags, 'base>, ~expression:Expression.t) => AwaitExpression.t = "createAwaitExpression"
    @send
    external updateAwaitExpression: (this<'tags, 'base>, ~node:AwaitExpression.t, ~expression:Expression.t) => AwaitExpression.t = "updateAwaitExpression"
    @send
    external createPrefixUnaryExpression: (this<'tags, 'base>, ~operator:PrefixUnaryOperator.t, ~operand:Expression.t) => PrefixUnaryExpression.t = "createPrefixUnaryExpression"
    @send
    external updatePrefixUnaryExpression: (this<'tags, 'base>, ~node:PrefixUnaryExpression.t, ~operand:Expression.t) => PrefixUnaryExpression.t = "updatePrefixUnaryExpression"
    @send
    external createPostfixUnaryExpression: (this<'tags, 'base>, ~operand:Expression.t, ~operator:PostfixUnaryOperator.t) => PostfixUnaryExpression.t = "createPostfixUnaryExpression"
    @send
    external updatePostfixUnaryExpression: (this<'tags, 'base>, ~node:PostfixUnaryExpression.t, ~operand:Expression.t) => PostfixUnaryExpression.t = "updatePostfixUnaryExpression"
    @send
    external createBinaryExpression: (this<'tags, 'base>, ~left:Expression.t, ~operator:Union.t2<BinaryOperator.t, BinaryOperatorToken.t>, ~right:Expression.t) => BinaryExpression.t = "createBinaryExpression"
    @send
    external updateBinaryExpression: (this<'tags, 'base>, ~node:BinaryExpression.t, ~left:Expression.t, ~operator:Union.t2<BinaryOperator.t, BinaryOperatorToken.t>, ~right:Expression.t) => BinaryExpression.t = "updateBinaryExpression"
    @send
    external createConditionalExpression: (this<'tags, 'base>, ~condition:Expression.t, ~questionToken:undefined<QuestionToken.t>, ~whenTrue:Expression.t, ~colonToken:undefined<ColonToken.t>, ~whenFalse:Expression.t) => ConditionalExpression.t = "createConditionalExpression"
    @send
    external updateConditionalExpression: (this<'tags, 'base>, ~node:ConditionalExpression.t, ~condition:Expression.t, ~questionToken:QuestionToken.t, ~whenTrue:Expression.t, ~colonToken:ColonToken.t, ~whenFalse:Expression.t) => ConditionalExpression.t = "updateConditionalExpression"
    @send
    external createTemplateExpression: (this<'tags, 'base>, ~head:TemplateHead.t, ~templateSpans:array<TemplateSpan.t>) => TemplateExpression.t = "createTemplateExpression"
    @send
    external updateTemplateExpression: (this<'tags, 'base>, ~node:TemplateExpression.t, ~head:TemplateHead.t, ~templateSpans:array<TemplateSpan.t>) => TemplateExpression.t = "updateTemplateExpression"
    @send
    external createTemplateHead: (this<'tags, 'base>, ~text:string, ~rawText:string=?, ~templateFlags:TokenFlags.t=?, unit) => TemplateHead.t = "createTemplateHead"
    @send
    external createTemplateHead': (this<'tags, 'base>, ~text:undefined<string>, ~rawText:string, ~templateFlags:TokenFlags.t=?, unit) => TemplateHead.t = "createTemplateHead"
    @send
    external createTemplateMiddle: (this<'tags, 'base>, ~text:string, ~rawText:string=?, ~templateFlags:TokenFlags.t=?, unit) => TemplateMiddle.t = "createTemplateMiddle"
    @send
    external createTemplateMiddle': (this<'tags, 'base>, ~text:undefined<string>, ~rawText:string, ~templateFlags:TokenFlags.t=?, unit) => TemplateMiddle.t = "createTemplateMiddle"
    @send
    external createTemplateTail: (this<'tags, 'base>, ~text:string, ~rawText:string=?, ~templateFlags:TokenFlags.t=?, unit) => TemplateTail.t = "createTemplateTail"
    @send
    external createTemplateTail': (this<'tags, 'base>, ~text:undefined<string>, ~rawText:string, ~templateFlags:TokenFlags.t=?, unit) => TemplateTail.t = "createTemplateTail"
    @send
    external createNoSubstitutionTemplateLiteral: (this<'tags, 'base>, ~text:string, ~rawText:string=?, unit) => NoSubstitutionTemplateLiteral.t = "createNoSubstitutionTemplateLiteral"
    @send
    external createNoSubstitutionTemplateLiteral': (this<'tags, 'base>, ~text:undefined<string>, ~rawText:string) => NoSubstitutionTemplateLiteral.t = "createNoSubstitutionTemplateLiteral"
    @send
    external createYieldExpression: (this<'tags, 'base>, ~asteriskToken:AsteriskToken.t, ~expression:Expression.t) => YieldExpression.t = "createYieldExpression"
    @send
    external createYieldExpression': (this<'tags, 'base>, ~asteriskToken:unit, ~expression:undefined<Expression.t>) => YieldExpression.t = "createYieldExpression"
    @send
    external updateYieldExpression: (this<'tags, 'base>, ~node:YieldExpression.t, ~asteriskToken:undefined<AsteriskToken.t>, ~expression:undefined<Expression.t>) => YieldExpression.t = "updateYieldExpression"
    @send
    external createSpreadElement: (this<'tags, 'base>, ~expression:Expression.t) => SpreadElement.t = "createSpreadElement"
    @send
    external updateSpreadElement: (this<'tags, 'base>, ~node:SpreadElement.t, ~expression:Expression.t) => SpreadElement.t = "updateSpreadElement"
    @send
    external createClassExpression: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:undefined<Union.t2<string, Identifier.t>>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~heritageClauses:undefined<array<HeritageClause.t>>, ~members:array<ClassElement.t>) => ClassExpression.t = "createClassExpression"
    @send
    external updateClassExpression: (this<'tags, 'base>, ~node:ClassExpression.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:undefined<Identifier.t>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~heritageClauses:undefined<array<HeritageClause.t>>, ~members:array<ClassElement.t>) => ClassExpression.t = "updateClassExpression"
    @send
    external createOmittedExpression: this<'tags, 'base> => OmittedExpression.t = "createOmittedExpression"
    @send
    external createExpressionWithTypeArguments: (this<'tags, 'base>, ~expression:Expression.t, ~typeArguments:undefined<array<TypeNode.t>>) => ExpressionWithTypeArguments.t = "createExpressionWithTypeArguments"
    @send
    external updateExpressionWithTypeArguments: (this<'tags, 'base>, ~node:ExpressionWithTypeArguments.t, ~expression:Expression.t, ~typeArguments:undefined<array<TypeNode.t>>) => ExpressionWithTypeArguments.t = "updateExpressionWithTypeArguments"
    @send
    external createAsExpression: (this<'tags, 'base>, ~expression:Expression.t, ~\"type":TypeNode.t) => AsExpression.t = "createAsExpression"
    @send
    external updateAsExpression: (this<'tags, 'base>, ~node:AsExpression.t, ~expression:Expression.t, ~\"type":TypeNode.t) => AsExpression.t = "updateAsExpression"
    @send
    external createNonNullExpression: (this<'tags, 'base>, ~expression:Expression.t) => NonNullExpression.t = "createNonNullExpression"
    @send
    external updateNonNullExpression: (this<'tags, 'base>, ~node:NonNullExpression.t, ~expression:Expression.t) => NonNullExpression.t = "updateNonNullExpression"
    @send
    external createNonNullChain: (this<'tags, 'base>, ~expression:Expression.t) => NonNullChain.t = "createNonNullChain"
    @send
    external updateNonNullChain: (this<'tags, 'base>, ~node:NonNullChain.t, ~expression:Expression.t) => NonNullChain.t = "updateNonNullChain"
    @send
    external createMetaProperty: (this<'tags, 'base>, ~keywordToken:Union.t2<SyntaxKind.NewKeyword.t, SyntaxKind.ImportKeyword.t>, ~name:Identifier.t) => MetaProperty.t = "createMetaProperty"
    @send
    external updateMetaProperty: (this<'tags, 'base>, ~node:MetaProperty.t, ~name:Identifier.t) => MetaProperty.t = "updateMetaProperty"
    @send
    external createTemplateSpan: (this<'tags, 'base>, ~expression:Expression.t, ~literal:Union.t2<TemplateMiddle.t, TemplateTail.t>) => TemplateSpan.t = "createTemplateSpan"
    @send
    external updateTemplateSpan: (this<'tags, 'base>, ~node:TemplateSpan.t, ~expression:Expression.t, ~literal:Union.t2<TemplateMiddle.t, TemplateTail.t>) => TemplateSpan.t = "updateTemplateSpan"
    @send
    external createSemicolonClassElement: this<'tags, 'base> => SemicolonClassElement.t = "createSemicolonClassElement"
    @send
    external createBlock: (this<'tags, 'base>, ~statements:array<Statement.t>, ~multiLine:bool=?, unit) => Block.t = "createBlock"
    @send
    external updateBlock: (this<'tags, 'base>, ~node:Block.t, ~statements:array<Statement.t>) => Block.t = "updateBlock"
    @send
    external createVariableStatement: (this<'tags, 'base>, ~modifiers:undefined<array<Modifier.t>>, ~declarationList:Union.t2<VariableDeclarationList.t, array<VariableDeclaration.t>>) => VariableStatement.t = "createVariableStatement"
    @send
    external updateVariableStatement: (this<'tags, 'base>, ~node:VariableStatement.t, ~modifiers:undefined<array<Modifier.t>>, ~declarationList:VariableDeclarationList.t) => VariableStatement.t = "updateVariableStatement"
    @send
    external createEmptyStatement: this<'tags, 'base> => EmptyStatement.t = "createEmptyStatement"
    @send
    external createExpressionStatement: (this<'tags, 'base>, ~expression:Expression.t) => ExpressionStatement.t = "createExpressionStatement"
    @send
    external updateExpressionStatement: (this<'tags, 'base>, ~node:ExpressionStatement.t, ~expression:Expression.t) => ExpressionStatement.t = "updateExpressionStatement"
    @send
    external createIfStatement: (this<'tags, 'base>, ~expression:Expression.t, ~thenStatement:Statement.t, ~elseStatement:Statement.t=?, unit) => IfStatement.t = "createIfStatement"
    @send
    external updateIfStatement: (this<'tags, 'base>, ~node:IfStatement.t, ~expression:Expression.t, ~thenStatement:Statement.t, ~elseStatement:undefined<Statement.t>) => IfStatement.t = "updateIfStatement"
    @send
    external createDoStatement: (this<'tags, 'base>, ~statement:Statement.t, ~expression:Expression.t) => DoStatement.t = "createDoStatement"
    @send
    external updateDoStatement: (this<'tags, 'base>, ~node:DoStatement.t, ~statement:Statement.t, ~expression:Expression.t) => DoStatement.t = "updateDoStatement"
    @send
    external createWhileStatement: (this<'tags, 'base>, ~expression:Expression.t, ~statement:Statement.t) => WhileStatement.t = "createWhileStatement"
    @send
    external updateWhileStatement: (this<'tags, 'base>, ~node:WhileStatement.t, ~expression:Expression.t, ~statement:Statement.t) => WhileStatement.t = "updateWhileStatement"
    @send
    external createForStatement: (this<'tags, 'base>, ~initializer:undefined<ForInitializer.t>, ~condition:undefined<Expression.t>, ~incrementor:undefined<Expression.t>, ~statement:Statement.t) => ForStatement.t = "createForStatement"
    @send
    external updateForStatement: (this<'tags, 'base>, ~node:ForStatement.t, ~initializer:undefined<ForInitializer.t>, ~condition:undefined<Expression.t>, ~incrementor:undefined<Expression.t>, ~statement:Statement.t) => ForStatement.t = "updateForStatement"
    @send
    external createForInStatement: (this<'tags, 'base>, ~initializer:ForInitializer.t, ~expression:Expression.t, ~statement:Statement.t) => ForInStatement.t = "createForInStatement"
    @send
    external updateForInStatement: (this<'tags, 'base>, ~node:ForInStatement.t, ~initializer:ForInitializer.t, ~expression:Expression.t, ~statement:Statement.t) => ForInStatement.t = "updateForInStatement"
    @send
    external createForOfStatement: (this<'tags, 'base>, ~awaitModifier:undefined<AwaitKeyword.t>, ~initializer:ForInitializer.t, ~expression:Expression.t, ~statement:Statement.t) => ForOfStatement.t = "createForOfStatement"
    @send
    external updateForOfStatement: (this<'tags, 'base>, ~node:ForOfStatement.t, ~awaitModifier:undefined<AwaitKeyword.t>, ~initializer:ForInitializer.t, ~expression:Expression.t, ~statement:Statement.t) => ForOfStatement.t = "updateForOfStatement"
    @send
    external createContinueStatement: (this<'tags, 'base>, ~label:Union.t2<string, Identifier.t>=?, unit) => ContinueStatement.t = "createContinueStatement"
    @send
    external updateContinueStatement: (this<'tags, 'base>, ~node:ContinueStatement.t, ~label:undefined<Identifier.t>) => ContinueStatement.t = "updateContinueStatement"
    @send
    external createBreakStatement: (this<'tags, 'base>, ~label:Union.t2<string, Identifier.t>=?, unit) => BreakStatement.t = "createBreakStatement"
    @send
    external updateBreakStatement: (this<'tags, 'base>, ~node:BreakStatement.t, ~label:undefined<Identifier.t>) => BreakStatement.t = "updateBreakStatement"
    @send
    external createReturnStatement: (this<'tags, 'base>, ~expression:Expression.t=?, unit) => ReturnStatement.t = "createReturnStatement"
    @send
    external updateReturnStatement: (this<'tags, 'base>, ~node:ReturnStatement.t, ~expression:undefined<Expression.t>) => ReturnStatement.t = "updateReturnStatement"
    @send
    external createWithStatement: (this<'tags, 'base>, ~expression:Expression.t, ~statement:Statement.t) => WithStatement.t = "createWithStatement"
    @send
    external updateWithStatement: (this<'tags, 'base>, ~node:WithStatement.t, ~expression:Expression.t, ~statement:Statement.t) => WithStatement.t = "updateWithStatement"
    @send
    external createSwitchStatement: (this<'tags, 'base>, ~expression:Expression.t, ~caseBlock:CaseBlock.t) => SwitchStatement.t = "createSwitchStatement"
    @send
    external updateSwitchStatement: (this<'tags, 'base>, ~node:SwitchStatement.t, ~expression:Expression.t, ~caseBlock:CaseBlock.t) => SwitchStatement.t = "updateSwitchStatement"
    @send
    external createLabeledStatement: (this<'tags, 'base>, ~label:Union.t2<string, Identifier.t>, ~statement:Statement.t) => LabeledStatement.t = "createLabeledStatement"
    @send
    external updateLabeledStatement: (this<'tags, 'base>, ~node:LabeledStatement.t, ~label:Identifier.t, ~statement:Statement.t) => LabeledStatement.t = "updateLabeledStatement"
    @send
    external createThrowStatement: (this<'tags, 'base>, ~expression:Expression.t) => ThrowStatement.t = "createThrowStatement"
    @send
    external updateThrowStatement: (this<'tags, 'base>, ~node:ThrowStatement.t, ~expression:Expression.t) => ThrowStatement.t = "updateThrowStatement"
    @send
    external createTryStatement: (this<'tags, 'base>, ~tryBlock:Block.t, ~catchClause:undefined<CatchClause.t>, ~finallyBlock:undefined<Block.t>) => TryStatement.t = "createTryStatement"
    @send
    external updateTryStatement: (this<'tags, 'base>, ~node:TryStatement.t, ~tryBlock:Block.t, ~catchClause:undefined<CatchClause.t>, ~finallyBlock:undefined<Block.t>) => TryStatement.t = "updateTryStatement"
    @send
    external createDebuggerStatement: this<'tags, 'base> => DebuggerStatement.t = "createDebuggerStatement"
    @send
    external createVariableDeclaration: (this<'tags, 'base>, ~name:Union.t2<string, BindingName.t>, ~exclamationToken:ExclamationToken.t=?, ~\"type":TypeNode.t=?, ~initializer:Expression.t=?, unit) => VariableDeclaration.t = "createVariableDeclaration"
    @send
    external updateVariableDeclaration: (this<'tags, 'base>, ~node:VariableDeclaration.t, ~name:BindingName.t, ~exclamationToken:undefined<ExclamationToken.t>, ~\"type":undefined<TypeNode.t>, ~initializer:undefined<Expression.t>) => VariableDeclaration.t = "updateVariableDeclaration"
    @send
    external createVariableDeclarationList: (this<'tags, 'base>, ~declarations:array<VariableDeclaration.t>, ~flags:NodeFlags.t=?, unit) => VariableDeclarationList.t = "createVariableDeclarationList"
    @send
    external updateVariableDeclarationList: (this<'tags, 'base>, ~node:VariableDeclarationList.t, ~declarations:array<VariableDeclaration.t>) => VariableDeclarationList.t = "updateVariableDeclarationList"
    @send
    external createFunctionDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~asteriskToken:undefined<AsteriskToken.t>, ~name:undefined<Union.t2<string, Identifier.t>>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>, ~body:undefined<Block.t>) => FunctionDeclaration.t = "createFunctionDeclaration"
    @send
    external updateFunctionDeclaration: (this<'tags, 'base>, ~node:FunctionDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~asteriskToken:undefined<AsteriskToken.t>, ~name:undefined<Identifier.t>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>, ~body:undefined<Block.t>) => FunctionDeclaration.t = "updateFunctionDeclaration"
    @send
    external createClassDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:undefined<Union.t2<string, Identifier.t>>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~heritageClauses:undefined<array<HeritageClause.t>>, ~members:array<ClassElement.t>) => ClassDeclaration.t = "createClassDeclaration"
    @send
    external updateClassDeclaration: (this<'tags, 'base>, ~node:ClassDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:undefined<Identifier.t>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~heritageClauses:undefined<array<HeritageClause.t>>, ~members:array<ClassElement.t>) => ClassDeclaration.t = "updateClassDeclaration"
    @send
    external createInterfaceDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:Union.t2<string, Identifier.t>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~heritageClauses:undefined<array<HeritageClause.t>>, ~members:array<TypeElement.t>) => InterfaceDeclaration.t = "createInterfaceDeclaration"
    @send
    external updateInterfaceDeclaration: (this<'tags, 'base>, ~node:InterfaceDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:Identifier.t, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~heritageClauses:undefined<array<HeritageClause.t>>, ~members:array<TypeElement.t>) => InterfaceDeclaration.t = "updateInterfaceDeclaration"
    @send
    external createTypeAliasDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:Union.t2<string, Identifier.t>, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~\"type":TypeNode.t) => TypeAliasDeclaration.t = "createTypeAliasDeclaration"
    @send
    external updateTypeAliasDeclaration: (this<'tags, 'base>, ~node:TypeAliasDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:Identifier.t, ~typeParameters:undefined<array<TypeParameterDeclaration.t>>, ~\"type":TypeNode.t) => TypeAliasDeclaration.t = "updateTypeAliasDeclaration"
    @send
    external createEnumDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:Union.t2<string, Identifier.t>, ~members:array<EnumMember.t>) => EnumDeclaration.t = "createEnumDeclaration"
    @send
    external updateEnumDeclaration: (this<'tags, 'base>, ~node:EnumDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:Identifier.t, ~members:array<EnumMember.t>) => EnumDeclaration.t = "updateEnumDeclaration"
    @send
    external createModuleDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:ModuleName.t, ~body:undefined<ModuleBody.t>, ~flags:NodeFlags.t=?, unit) => ModuleDeclaration.t = "createModuleDeclaration"
    @send
    external updateModuleDeclaration: (this<'tags, 'base>, ~node:ModuleDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~name:ModuleName.t, ~body:undefined<ModuleBody.t>) => ModuleDeclaration.t = "updateModuleDeclaration"
    @send
    external createModuleBlock: (this<'tags, 'base>, ~statements:array<Statement.t>) => ModuleBlock.t = "createModuleBlock"
    @send
    external updateModuleBlock: (this<'tags, 'base>, ~node:ModuleBlock.t, ~statements:array<Statement.t>) => ModuleBlock.t = "updateModuleBlock"
    @send
    external createCaseBlock: (this<'tags, 'base>, ~clauses:array<CaseOrDefaultClause.t>) => CaseBlock.t = "createCaseBlock"
    @send
    external updateCaseBlock: (this<'tags, 'base>, ~node:CaseBlock.t, ~clauses:array<CaseOrDefaultClause.t>) => CaseBlock.t = "updateCaseBlock"
    @send
    external createNamespaceExportDeclaration: (this<'tags, 'base>, ~name:Union.t2<string, Identifier.t>) => NamespaceExportDeclaration.t = "createNamespaceExportDeclaration"
    @send
    external updateNamespaceExportDeclaration: (this<'tags, 'base>, ~node:NamespaceExportDeclaration.t, ~name:Identifier.t) => NamespaceExportDeclaration.t = "updateNamespaceExportDeclaration"
    @send
    external createImportEqualsDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~isTypeOnly:bool, ~name:Union.t2<string, Identifier.t>, ~moduleReference:ModuleReference.t) => ImportEqualsDeclaration.t = "createImportEqualsDeclaration"
    @send
    external updateImportEqualsDeclaration: (this<'tags, 'base>, ~node:ImportEqualsDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~isTypeOnly:bool, ~name:Identifier.t, ~moduleReference:ModuleReference.t) => ImportEqualsDeclaration.t = "updateImportEqualsDeclaration"
    @send
    external createImportDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~importClause:undefined<ImportClause.t>, ~moduleSpecifier:Expression.t, ~assertClause:AssertClause.t=?, unit) => ImportDeclaration.t = "createImportDeclaration"
    @send
    external updateImportDeclaration: (this<'tags, 'base>, ~node:ImportDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~importClause:undefined<ImportClause.t>, ~moduleSpecifier:Expression.t, ~assertClause:undefined<AssertClause.t>) => ImportDeclaration.t = "updateImportDeclaration"
    @send
    external createImportClause: (this<'tags, 'base>, ~isTypeOnly:bool, ~name:undefined<Identifier.t>, ~namedBindings:undefined<NamedImportBindings.t>) => ImportClause.t = "createImportClause"
    @send
    external updateImportClause: (this<'tags, 'base>, ~node:ImportClause.t, ~isTypeOnly:bool, ~name:undefined<Identifier.t>, ~namedBindings:undefined<NamedImportBindings.t>) => ImportClause.t = "updateImportClause"
    @send
    external createAssertClause: (this<'tags, 'base>, ~elements:NodeArray.t<AssertEntry.t>, ~multiLine:bool=?, unit) => AssertClause.t = "createAssertClause"
    @send
    external updateAssertClause: (this<'tags, 'base>, ~node:AssertClause.t, ~elements:NodeArray.t<AssertEntry.t>, ~multiLine:bool=?, unit) => AssertClause.t = "updateAssertClause"
    @send
    external createAssertEntry: (this<'tags, 'base>, ~name:AssertionKey.t, ~value:Expression.t) => AssertEntry.t = "createAssertEntry"
    @send
    external updateAssertEntry: (this<'tags, 'base>, ~node:AssertEntry.t, ~name:AssertionKey.t, ~value:Expression.t) => AssertEntry.t = "updateAssertEntry"
    @send
    external createNamespaceImport: (this<'tags, 'base>, ~name:Identifier.t) => NamespaceImport.t = "createNamespaceImport"
    @send
    external updateNamespaceImport: (this<'tags, 'base>, ~node:NamespaceImport.t, ~name:Identifier.t) => NamespaceImport.t = "updateNamespaceImport"
    @send
    external createNamespaceExport: (this<'tags, 'base>, ~name:Identifier.t) => NamespaceExport.t = "createNamespaceExport"
    @send
    external updateNamespaceExport: (this<'tags, 'base>, ~node:NamespaceExport.t, ~name:Identifier.t) => NamespaceExport.t = "updateNamespaceExport"
    @send
    external createNamedImports: (this<'tags, 'base>, ~elements:array<ImportSpecifier.t>) => NamedImports.t = "createNamedImports"
    @send
    external updateNamedImports: (this<'tags, 'base>, ~node:NamedImports.t, ~elements:array<ImportSpecifier.t>) => NamedImports.t = "updateNamedImports"
    @send
    external createImportSpecifier: (this<'tags, 'base>, ~isTypeOnly:bool, ~propertyName:undefined<Identifier.t>, ~name:Identifier.t) => ImportSpecifier.t = "createImportSpecifier"
    @send
    external updateImportSpecifier: (this<'tags, 'base>, ~node:ImportSpecifier.t, ~isTypeOnly:bool, ~propertyName:undefined<Identifier.t>, ~name:Identifier.t) => ImportSpecifier.t = "updateImportSpecifier"
    @send
    external createExportAssignment: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~isExportEquals:undefined<bool>, ~expression:Expression.t) => ExportAssignment.t = "createExportAssignment"
    @send
    external updateExportAssignment: (this<'tags, 'base>, ~node:ExportAssignment.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~expression:Expression.t) => ExportAssignment.t = "updateExportAssignment"
    @send
    external createExportDeclaration: (this<'tags, 'base>, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~isTypeOnly:bool, ~exportClause:undefined<NamedExportBindings.t>, ~moduleSpecifier:Expression.t=?, ~assertClause:AssertClause.t=?, unit) => ExportDeclaration.t = "createExportDeclaration"
    @send
    external updateExportDeclaration: (this<'tags, 'base>, ~node:ExportDeclaration.t, ~decorators:undefined<array<Decorator.t>>, ~modifiers:undefined<array<Modifier.t>>, ~isTypeOnly:bool, ~exportClause:undefined<NamedExportBindings.t>, ~moduleSpecifier:undefined<Expression.t>, ~assertClause:undefined<AssertClause.t>) => ExportDeclaration.t = "updateExportDeclaration"
    @send
    external createNamedExports: (this<'tags, 'base>, ~elements:array<ExportSpecifier.t>) => NamedExports.t = "createNamedExports"
    @send
    external updateNamedExports: (this<'tags, 'base>, ~node:NamedExports.t, ~elements:array<ExportSpecifier.t>) => NamedExports.t = "updateNamedExports"
    @send
    external createExportSpecifier: (this<'tags, 'base>, ~isTypeOnly:bool, ~propertyName:undefined<Union.t2<string, Identifier.t>>, ~name:Union.t2<string, Identifier.t>) => ExportSpecifier.t = "createExportSpecifier"
    @send
    external updateExportSpecifier: (this<'tags, 'base>, ~node:ExportSpecifier.t, ~isTypeOnly:bool, ~propertyName:undefined<Identifier.t>, ~name:Identifier.t) => ExportSpecifier.t = "updateExportSpecifier"
    @send
    external createExternalModuleReference: (this<'tags, 'base>, ~expression:Expression.t) => ExternalModuleReference.t = "createExternalModuleReference"
    @send
    external updateExternalModuleReference: (this<'tags, 'base>, ~node:ExternalModuleReference.t, ~expression:Expression.t) => ExternalModuleReference.t = "updateExternalModuleReference"
    @send
    external createJSDocAllType: this<'tags, 'base> => JSDocAllType.t = "createJSDocAllType"
    @send
    external createJSDocUnknownType: this<'tags, 'base> => JSDocUnknownType.t = "createJSDocUnknownType"
    @send
    external createJSDocNonNullableType: (this<'tags, 'base>, ~\"type":TypeNode.t) => JSDocNonNullableType.t = "createJSDocNonNullableType"
    @send
    external updateJSDocNonNullableType: (this<'tags, 'base>, ~node:JSDocNonNullableType.t, ~\"type":TypeNode.t) => JSDocNonNullableType.t = "updateJSDocNonNullableType"
    @send
    external createJSDocNullableType: (this<'tags, 'base>, ~\"type":TypeNode.t) => JSDocNullableType.t = "createJSDocNullableType"
    @send
    external updateJSDocNullableType: (this<'tags, 'base>, ~node:JSDocNullableType.t, ~\"type":TypeNode.t) => JSDocNullableType.t = "updateJSDocNullableType"
    @send
    external createJSDocOptionalType: (this<'tags, 'base>, ~\"type":TypeNode.t) => JSDocOptionalType.t = "createJSDocOptionalType"
    @send
    external updateJSDocOptionalType: (this<'tags, 'base>, ~node:JSDocOptionalType.t, ~\"type":TypeNode.t) => JSDocOptionalType.t = "updateJSDocOptionalType"
    @send
    external createJSDocFunctionType: (this<'tags, 'base>, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>) => JSDocFunctionType.t = "createJSDocFunctionType"
    @send
    external updateJSDocFunctionType: (this<'tags, 'base>, ~node:JSDocFunctionType.t, ~parameters:array<ParameterDeclaration.t>, ~\"type":undefined<TypeNode.t>) => JSDocFunctionType.t = "updateJSDocFunctionType"
    @send
    external createJSDocVariadicType: (this<'tags, 'base>, ~\"type":TypeNode.t) => JSDocVariadicType.t = "createJSDocVariadicType"
    @send
    external updateJSDocVariadicType: (this<'tags, 'base>, ~node:JSDocVariadicType.t, ~\"type":TypeNode.t) => JSDocVariadicType.t = "updateJSDocVariadicType"
    @send
    external createJSDocNamepathType: (this<'tags, 'base>, ~\"type":TypeNode.t) => JSDocNamepathType.t = "createJSDocNamepathType"
    @send
    external updateJSDocNamepathType: (this<'tags, 'base>, ~node:JSDocNamepathType.t, ~\"type":TypeNode.t) => JSDocNamepathType.t = "updateJSDocNamepathType"
    @send
    external createJSDocTypeExpression: (this<'tags, 'base>, ~\"type":TypeNode.t) => JSDocTypeExpression.t = "createJSDocTypeExpression"
    @send
    external updateJSDocTypeExpression: (this<'tags, 'base>, ~node:JSDocTypeExpression.t, ~\"type":TypeNode.t) => JSDocTypeExpression.t = "updateJSDocTypeExpression"
    @send
    external createJSDocNameReference: (this<'tags, 'base>, ~name:Union.t2<EntityName.t, JSDocMemberName.t>) => JSDocNameReference.t = "createJSDocNameReference"
    @send
    external updateJSDocNameReference: (this<'tags, 'base>, ~node:JSDocNameReference.t, ~name:Union.t2<EntityName.t, JSDocMemberName.t>) => JSDocNameReference.t = "updateJSDocNameReference"
    @send
    external createJSDocMemberName: (this<'tags, 'base>, ~left:Union.t2<EntityName.t, JSDocMemberName.t>, ~right:Identifier.t) => JSDocMemberName.t = "createJSDocMemberName"
    @send
    external updateJSDocMemberName: (this<'tags, 'base>, ~node:JSDocMemberName.t, ~left:Union.t2<EntityName.t, JSDocMemberName.t>, ~right:Identifier.t) => JSDocMemberName.t = "updateJSDocMemberName"
    @send
    external createJSDocLink: (this<'tags, 'base>, ~name:undefined<Union.t2<EntityName.t, JSDocMemberName.t>>, ~text:string) => JSDocLink.t = "createJSDocLink"
    @send
    external updateJSDocLink: (this<'tags, 'base>, ~node:JSDocLink.t, ~name:undefined<Union.t2<EntityName.t, JSDocMemberName.t>>, ~text:string) => JSDocLink.t = "updateJSDocLink"
    @send
    external createJSDocLinkCode: (this<'tags, 'base>, ~name:undefined<Union.t2<EntityName.t, JSDocMemberName.t>>, ~text:string) => JSDocLinkCode.t = "createJSDocLinkCode"
    @send
    external updateJSDocLinkCode: (this<'tags, 'base>, ~node:JSDocLinkCode.t, ~name:undefined<Union.t2<EntityName.t, JSDocMemberName.t>>, ~text:string) => JSDocLinkCode.t = "updateJSDocLinkCode"
    @send
    external createJSDocLinkPlain: (this<'tags, 'base>, ~name:undefined<Union.t2<EntityName.t, JSDocMemberName.t>>, ~text:string) => JSDocLinkPlain.t = "createJSDocLinkPlain"
    @send
    external updateJSDocLinkPlain: (this<'tags, 'base>, ~node:JSDocLinkPlain.t, ~name:undefined<Union.t2<EntityName.t, JSDocMemberName.t>>, ~text:string) => JSDocLinkPlain.t = "updateJSDocLinkPlain"
    @send
    external createJSDocTypeLiteral: (this<'tags, 'base>, ~jsDocPropertyTags:array<JSDocPropertyLikeTag.t>=?, ~isArrayType:bool=?, unit) => JSDocTypeLiteral.t = "createJSDocTypeLiteral"
    @send
    external updateJSDocTypeLiteral: (this<'tags, 'base>, ~node:JSDocTypeLiteral.t, ~jsDocPropertyTags:undefined<array<JSDocPropertyLikeTag.t>>, ~isArrayType:undefined<bool>) => JSDocTypeLiteral.t = "updateJSDocTypeLiteral"
    @send
    external createJSDocSignature: (this<'tags, 'base>, ~typeParameters:undefined<array<JSDocTemplateTag.t>>, ~parameters:array<JSDocParameterTag.t>, ~\"type":JSDocReturnTag.t=?, unit) => JSDocSignature.t = "createJSDocSignature"
    @send
    external updateJSDocSignature: (this<'tags, 'base>, ~node:JSDocSignature.t, ~typeParameters:undefined<array<JSDocTemplateTag.t>>, ~parameters:array<JSDocParameterTag.t>, ~\"type":undefined<JSDocReturnTag.t>) => JSDocSignature.t = "updateJSDocSignature"
    @send
    external createJSDocTemplateTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~\"constraint":undefined<JSDocTypeExpression.t>, ~typeParameters:array<TypeParameterDeclaration.t>, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocTemplateTag.t = "createJSDocTemplateTag"
    @send
    external updateJSDocTemplateTag: (this<'tags, 'base>, ~node:JSDocTemplateTag.t, ~tagName:undefined<Identifier.t>, ~\"constraint":undefined<JSDocTypeExpression.t>, ~typeParameters:array<TypeParameterDeclaration.t>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocTemplateTag.t = "updateJSDocTemplateTag"
    @send
    external createJSDocTypedefTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~typeExpression:Union.t2<JSDocTypeExpression.t, JSDocTypeLiteral.t>=?, ~fullName:Union.t2<Identifier.t, JSDocNamespaceDeclaration.t>=?, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocTypedefTag.t = "createJSDocTypedefTag"
    @send
    external updateJSDocTypedefTag: (this<'tags, 'base>, ~node:JSDocTypedefTag.t, ~tagName:undefined<Identifier.t>, ~typeExpression:undefined<Union.t2<JSDocTypeExpression.t, JSDocTypeLiteral.t>>, ~fullName:undefined<Union.t2<Identifier.t, JSDocNamespaceDeclaration.t>>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocTypedefTag.t = "updateJSDocTypedefTag"
    @send
    external createJSDocParameterTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~name:EntityName.t, ~isBracketed:bool, ~typeExpression:JSDocTypeExpression.t=?, ~isNameFirst:bool=?, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocParameterTag.t = "createJSDocParameterTag"
    @send
    external updateJSDocParameterTag: (this<'tags, 'base>, ~node:JSDocParameterTag.t, ~tagName:undefined<Identifier.t>, ~name:EntityName.t, ~isBracketed:bool, ~typeExpression:undefined<JSDocTypeExpression.t>, ~isNameFirst:bool, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocParameterTag.t = "updateJSDocParameterTag"
    @send
    external createJSDocPropertyTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~name:EntityName.t, ~isBracketed:bool, ~typeExpression:JSDocTypeExpression.t=?, ~isNameFirst:bool=?, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocPropertyTag.t = "createJSDocPropertyTag"
    @send
    external updateJSDocPropertyTag: (this<'tags, 'base>, ~node:JSDocPropertyTag.t, ~tagName:undefined<Identifier.t>, ~name:EntityName.t, ~isBracketed:bool, ~typeExpression:undefined<JSDocTypeExpression.t>, ~isNameFirst:bool, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocPropertyTag.t = "updateJSDocPropertyTag"
    @send
    external createJSDocTypeTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~typeExpression:JSDocTypeExpression.t, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocTypeTag.t = "createJSDocTypeTag"
    @send
    external updateJSDocTypeTag: (this<'tags, 'base>, ~node:JSDocTypeTag.t, ~tagName:undefined<Identifier.t>, ~typeExpression:JSDocTypeExpression.t, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocTypeTag.t = "updateJSDocTypeTag"
    @send
    external createJSDocSeeTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~nameExpression:undefined<JSDocNameReference.t>, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocSeeTag.t = "createJSDocSeeTag"
    @send
    external updateJSDocSeeTag: (this<'tags, 'base>, ~node:JSDocSeeTag.t, ~tagName:undefined<Identifier.t>, ~nameExpression:undefined<JSDocNameReference.t>, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocSeeTag.t = "updateJSDocSeeTag"
    @send
    external createJSDocReturnTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~typeExpression:JSDocTypeExpression.t=?, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocReturnTag.t = "createJSDocReturnTag"
    @send
    external updateJSDocReturnTag: (this<'tags, 'base>, ~node:JSDocReturnTag.t, ~tagName:undefined<Identifier.t>, ~typeExpression:undefined<JSDocTypeExpression.t>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocReturnTag.t = "updateJSDocReturnTag"
    @send
    external createJSDocThisTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~typeExpression:JSDocTypeExpression.t, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocThisTag.t = "createJSDocThisTag"
    @send
    external updateJSDocThisTag: (this<'tags, 'base>, ~node:JSDocThisTag.t, ~tagName:undefined<Identifier.t>, ~typeExpression:undefined<JSDocTypeExpression.t>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocThisTag.t = "updateJSDocThisTag"
    @send
    external createJSDocEnumTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~typeExpression:JSDocTypeExpression.t, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocEnumTag.t = "createJSDocEnumTag"
    @send
    external updateJSDocEnumTag: (this<'tags, 'base>, ~node:JSDocEnumTag.t, ~tagName:undefined<Identifier.t>, ~typeExpression:JSDocTypeExpression.t, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocEnumTag.t = "updateJSDocEnumTag"
    @send
    external createJSDocCallbackTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~typeExpression:JSDocSignature.t, ~fullName:Union.t2<Identifier.t, JSDocNamespaceDeclaration.t>=?, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocCallbackTag.t = "createJSDocCallbackTag"
    @send
    external updateJSDocCallbackTag: (this<'tags, 'base>, ~node:JSDocCallbackTag.t, ~tagName:undefined<Identifier.t>, ~typeExpression:JSDocSignature.t, ~fullName:undefined<Union.t2<Identifier.t, JSDocNamespaceDeclaration.t>>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocCallbackTag.t = "updateJSDocCallbackTag"
    @send
    external createJSDocAugmentsTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~className:Intersection.t2<ExpressionWithTypeArguments.t, AnonymousInterface14.t>, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocAugmentsTag.t = "createJSDocAugmentsTag"
    @send
    external updateJSDocAugmentsTag: (this<'tags, 'base>, ~node:JSDocAugmentsTag.t, ~tagName:undefined<Identifier.t>, ~className:Intersection.t2<ExpressionWithTypeArguments.t, AnonymousInterface14.t>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocAugmentsTag.t = "updateJSDocAugmentsTag"
    @send
    external createJSDocImplementsTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~className:Intersection.t2<ExpressionWithTypeArguments.t, AnonymousInterface14.t>, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocImplementsTag.t = "createJSDocImplementsTag"
    @send
    external updateJSDocImplementsTag: (this<'tags, 'base>, ~node:JSDocImplementsTag.t, ~tagName:undefined<Identifier.t>, ~className:Intersection.t2<ExpressionWithTypeArguments.t, AnonymousInterface14.t>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocImplementsTag.t = "updateJSDocImplementsTag"
    @send
    external createJSDocAuthorTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocAuthorTag.t = "createJSDocAuthorTag"
    @send
    external updateJSDocAuthorTag: (this<'tags, 'base>, ~node:JSDocAuthorTag.t, ~tagName:undefined<Identifier.t>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocAuthorTag.t = "updateJSDocAuthorTag"
    @send
    external createJSDocClassTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocClassTag.t = "createJSDocClassTag"
    @send
    external updateJSDocClassTag: (this<'tags, 'base>, ~node:JSDocClassTag.t, ~tagName:undefined<Identifier.t>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocClassTag.t = "updateJSDocClassTag"
    @send
    external createJSDocPublicTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocPublicTag.t = "createJSDocPublicTag"
    @send
    external updateJSDocPublicTag: (this<'tags, 'base>, ~node:JSDocPublicTag.t, ~tagName:undefined<Identifier.t>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocPublicTag.t = "updateJSDocPublicTag"
    @send
    external createJSDocPrivateTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocPrivateTag.t = "createJSDocPrivateTag"
    @send
    external updateJSDocPrivateTag: (this<'tags, 'base>, ~node:JSDocPrivateTag.t, ~tagName:undefined<Identifier.t>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocPrivateTag.t = "updateJSDocPrivateTag"
    @send
    external createJSDocProtectedTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocProtectedTag.t = "createJSDocProtectedTag"
    @send
    external updateJSDocProtectedTag: (this<'tags, 'base>, ~node:JSDocProtectedTag.t, ~tagName:undefined<Identifier.t>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocProtectedTag.t = "updateJSDocProtectedTag"
    @send
    external createJSDocReadonlyTag: (this<'tags, 'base>, ~tagName:undefined<Identifier.t>, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocReadonlyTag.t = "createJSDocReadonlyTag"
    @send
    external updateJSDocReadonlyTag: (this<'tags, 'base>, ~node:JSDocReadonlyTag.t, ~tagName:undefined<Identifier.t>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocReadonlyTag.t = "updateJSDocReadonlyTag"
    @send
    external createJSDocUnknownTag: (this<'tags, 'base>, ~tagName:Identifier.t, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocUnknownTag.t = "createJSDocUnknownTag"
    @send
    external updateJSDocUnknownTag: (this<'tags, 'base>, ~node:JSDocUnknownTag.t, ~tagName:Identifier.t, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>) => JSDocUnknownTag.t = "updateJSDocUnknownTag"
    @send
    external createJSDocDeprecatedTag: (this<'tags, 'base>, ~tagName:Identifier.t, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocDeprecatedTag.t = "createJSDocDeprecatedTag"
    @send
    external updateJSDocDeprecatedTag: (this<'tags, 'base>, ~node:JSDocDeprecatedTag.t, ~tagName:Identifier.t, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocDeprecatedTag.t = "updateJSDocDeprecatedTag"
    @send
    external createJSDocOverrideTag: (this<'tags, 'base>, ~tagName:Identifier.t, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocOverrideTag.t = "createJSDocOverrideTag"
    @send
    external updateJSDocOverrideTag: (this<'tags, 'base>, ~node:JSDocOverrideTag.t, ~tagName:Identifier.t, ~comment:Union.t2<string, NodeArray.t<JSDocComment.t>>=?, unit) => JSDocOverrideTag.t = "updateJSDocOverrideTag"
    @send
    external createJSDocText: (this<'tags, 'base>, ~text:string) => JSDocText.t = "createJSDocText"
    @send
    external updateJSDocText: (this<'tags, 'base>, ~node:JSDocText.t, ~text:string) => JSDocText.t = "updateJSDocText"
    @send
    external createJSDocComment: (this<'tags, 'base>, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>=?, ~tags:undefined<array<JSDocTag.t>>=?, unit) => JSDoc.t = "createJSDocComment"
    @send
    external updateJSDocComment: (this<'tags, 'base>, ~node:JSDoc.t, ~comment:undefined<Union.t2<string, NodeArray.t<JSDocComment.t>>>, ~tags:undefined<array<JSDocTag.t>>) => JSDoc.t = "updateJSDocComment"
    @send
    external createJsxElement: (this<'tags, 'base>, ~openingElement:JsxOpeningElement.t, ~children:array<JsxChild.t>, ~closingElement:JsxClosingElement.t) => JsxElement.t = "createJsxElement"
    @send
    external updateJsxElement: (this<'tags, 'base>, ~node:JsxElement.t, ~openingElement:JsxOpeningElement.t, ~children:array<JsxChild.t>, ~closingElement:JsxClosingElement.t) => JsxElement.t = "updateJsxElement"
    @send
    external createJsxSelfClosingElement: (this<'tags, 'base>, ~tagName:JsxTagNameExpression.t, ~typeArguments:undefined<array<TypeNode.t>>, ~attributes:JsxAttributes.t) => JsxSelfClosingElement.t = "createJsxSelfClosingElement"
    @send
    external updateJsxSelfClosingElement: (this<'tags, 'base>, ~node:JsxSelfClosingElement.t, ~tagName:JsxTagNameExpression.t, ~typeArguments:undefined<array<TypeNode.t>>, ~attributes:JsxAttributes.t) => JsxSelfClosingElement.t = "updateJsxSelfClosingElement"
    @send
    external createJsxOpeningElement: (this<'tags, 'base>, ~tagName:JsxTagNameExpression.t, ~typeArguments:undefined<array<TypeNode.t>>, ~attributes:JsxAttributes.t) => JsxOpeningElement.t = "createJsxOpeningElement"
    @send
    external updateJsxOpeningElement: (this<'tags, 'base>, ~node:JsxOpeningElement.t, ~tagName:JsxTagNameExpression.t, ~typeArguments:undefined<array<TypeNode.t>>, ~attributes:JsxAttributes.t) => JsxOpeningElement.t = "updateJsxOpeningElement"
    @send
    external createJsxClosingElement: (this<'tags, 'base>, ~tagName:JsxTagNameExpression.t) => JsxClosingElement.t = "createJsxClosingElement"
    @send
    external updateJsxClosingElement: (this<'tags, 'base>, ~node:JsxClosingElement.t, ~tagName:JsxTagNameExpression.t) => JsxClosingElement.t = "updateJsxClosingElement"
    @send
    external createJsxFragment: (this<'tags, 'base>, ~openingFragment:JsxOpeningFragment.t, ~children:array<JsxChild.t>, ~closingFragment:JsxClosingFragment.t) => JsxFragment.t = "createJsxFragment"
    @send
    external createJsxText: (this<'tags, 'base>, ~text:string, ~containsOnlyTriviaWhiteSpaces:bool=?, unit) => JsxText.t = "createJsxText"
    @send
    external updateJsxText: (this<'tags, 'base>, ~node:JsxText.t, ~text:string, ~containsOnlyTriviaWhiteSpaces:bool=?, unit) => JsxText.t = "updateJsxText"
    @send
    external createJsxOpeningFragment: this<'tags, 'base> => JsxOpeningFragment.t = "createJsxOpeningFragment"
    @send
    external createJsxJsxClosingFragment: this<'tags, 'base> => JsxClosingFragment.t = "createJsxJsxClosingFragment"
    @send
    external updateJsxFragment: (this<'tags, 'base>, ~node:JsxFragment.t, ~openingFragment:JsxOpeningFragment.t, ~children:array<JsxChild.t>, ~closingFragment:JsxClosingFragment.t) => JsxFragment.t = "updateJsxFragment"
    @send
    external createJsxAttribute: (this<'tags, 'base>, ~name:Identifier.t, ~initializer:undefined<Union.t2<StringLiteral.t, JsxExpression.t>>) => JsxAttribute.t = "createJsxAttribute"
    @send
    external updateJsxAttribute: (this<'tags, 'base>, ~node:JsxAttribute.t, ~name:Identifier.t, ~initializer:undefined<Union.t2<StringLiteral.t, JsxExpression.t>>) => JsxAttribute.t = "updateJsxAttribute"
    @send
    external createJsxAttributes: (this<'tags, 'base>, ~properties:array<JsxAttributeLike.t>) => JsxAttributes.t = "createJsxAttributes"
    @send
    external updateJsxAttributes: (this<'tags, 'base>, ~node:JsxAttributes.t, ~properties:array<JsxAttributeLike.t>) => JsxAttributes.t = "updateJsxAttributes"
    @send
    external createJsxSpreadAttribute: (this<'tags, 'base>, ~expression:Expression.t) => JsxSpreadAttribute.t = "createJsxSpreadAttribute"
    @send
    external updateJsxSpreadAttribute: (this<'tags, 'base>, ~node:JsxSpreadAttribute.t, ~expression:Expression.t) => JsxSpreadAttribute.t = "updateJsxSpreadAttribute"
    @send
    external createJsxExpression: (this<'tags, 'base>, ~dotDotDotToken:undefined<DotDotDotToken.t>, ~expression:undefined<Expression.t>) => JsxExpression.t = "createJsxExpression"
    @send
    external updateJsxExpression: (this<'tags, 'base>, ~node:JsxExpression.t, ~expression:undefined<Expression.t>) => JsxExpression.t = "updateJsxExpression"
    @send
    external createCaseClause: (this<'tags, 'base>, ~expression:Expression.t, ~statements:array<Statement.t>) => CaseClause.t = "createCaseClause"
    @send
    external updateCaseClause: (this<'tags, 'base>, ~node:CaseClause.t, ~expression:Expression.t, ~statements:array<Statement.t>) => CaseClause.t = "updateCaseClause"
    @send
    external createDefaultClause: (this<'tags, 'base>, ~statements:array<Statement.t>) => DefaultClause.t = "createDefaultClause"
    @send
    external updateDefaultClause: (this<'tags, 'base>, ~node:DefaultClause.t, ~statements:array<Statement.t>) => DefaultClause.t = "updateDefaultClause"
    @send
    external createHeritageClause: (this<'tags, 'base>, ~token:Union.t2<SyntaxKind.ExtendsKeyword.t, SyntaxKind.ImplementsKeyword.t>, ~types:array<ExpressionWithTypeArguments.t>) => HeritageClause.t = "createHeritageClause"
    @send
    external updateHeritageClause: (this<'tags, 'base>, ~node:HeritageClause.t, ~types:array<ExpressionWithTypeArguments.t>) => HeritageClause.t = "updateHeritageClause"
    @send
    external createCatchClause: (this<'tags, 'base>, ~variableDeclaration:undefined<Union.t3<string, BindingName.t, VariableDeclaration.t>>, ~block:Block.t) => CatchClause.t = "createCatchClause"
    @send
    external updateCatchClause: (this<'tags, 'base>, ~node:CatchClause.t, ~variableDeclaration:undefined<VariableDeclaration.t>, ~block:Block.t) => CatchClause.t = "updateCatchClause"
    @send
    external createPropertyAssignment: (this<'tags, 'base>, ~name:Union.t2<string, PropertyName.t>, ~initializer:Expression.t) => PropertyAssignment.t = "createPropertyAssignment"
    @send
    external updatePropertyAssignment: (this<'tags, 'base>, ~node:PropertyAssignment.t, ~name:PropertyName.t, ~initializer:Expression.t) => PropertyAssignment.t = "updatePropertyAssignment"
    @send
    external createShorthandPropertyAssignment: (this<'tags, 'base>, ~name:Union.t2<string, Identifier.t>, ~objectAssignmentInitializer:Expression.t=?, unit) => ShorthandPropertyAssignment.t = "createShorthandPropertyAssignment"
    @send
    external updateShorthandPropertyAssignment: (this<'tags, 'base>, ~node:ShorthandPropertyAssignment.t, ~name:Identifier.t, ~objectAssignmentInitializer:undefined<Expression.t>) => ShorthandPropertyAssignment.t = "updateShorthandPropertyAssignment"
    @send
    external createSpreadAssignment: (this<'tags, 'base>, ~expression:Expression.t) => SpreadAssignment.t = "createSpreadAssignment"
    @send
    external updateSpreadAssignment: (this<'tags, 'base>, ~node:SpreadAssignment.t, ~expression:Expression.t) => SpreadAssignment.t = "updateSpreadAssignment"
    @send
    external createEnumMember: (this<'tags, 'base>, ~name:Union.t2<string, PropertyName.t>, ~initializer:Expression.t=?, unit) => EnumMember.t = "createEnumMember"
    @send
    external updateEnumMember: (this<'tags, 'base>, ~node:EnumMember.t, ~name:PropertyName.t, ~initializer:undefined<Expression.t>) => EnumMember.t = "updateEnumMember"
    @send
    external createSourceFile: (this<'tags, 'base>, ~statements:array<Statement.t>, ~endOfFileToken:EndOfFileToken.t, ~flags:NodeFlags.t) => SourceFile.t = "createSourceFile"
    @send
    external updateSourceFile: (this<'tags, 'base>, ~node:SourceFile.t, ~statements:array<Statement.t>, ~isDeclarationFile:bool=?, ~referencedFiles:array<FileReference.t>=?, ~typeReferences:array<FileReference.t>=?, ~hasNoDefaultLib:bool=?, ~libReferences:array<FileReference.t>=?, unit) => SourceFile.t = "updateSourceFile"
    @send
    external createNotEmittedStatement: (this<'tags, 'base>, ~original:Dom.node) => NotEmittedStatement.t = "createNotEmittedStatement"
    @send
    external createPartiallyEmittedExpression: (this<'tags, 'base>, ~expression:Expression.t, ~original:Dom.node=?, unit) => PartiallyEmittedExpression.t = "createPartiallyEmittedExpression"
    @send
    external updatePartiallyEmittedExpression: (this<'tags, 'base>, ~node:PartiallyEmittedExpression.t, ~expression:Expression.t) => PartiallyEmittedExpression.t = "updatePartiallyEmittedExpression"
    @send
    external createCommaListExpression: (this<'tags, 'base>, ~elements:array<Expression.t>) => CommaListExpression.t = "createCommaListExpression"
    @send
    external updateCommaListExpression: (this<'tags, 'base>, ~node:CommaListExpression.t, ~elements:array<Expression.t>) => CommaListExpression.t = "updateCommaListExpression"
    @send
    external createBundle: (this<'tags, 'base>, ~sourceFiles:array<SourceFile.t>, ~prepends:array<Union.t2<UnparsedSource.t, InputFiles.t>>=?, unit) => Bundle.t = "createBundle"
    @send
    external updateBundle: (this<'tags, 'base>, ~node:Bundle.t, ~sourceFiles:array<SourceFile.t>, ~prepends:array<Union.t2<UnparsedSource.t, InputFiles.t>>=?, unit) => Bundle.t = "updateBundle"
    @send
    external createComma: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createComma"
    @send
    external createAssignment: (this<'tags, 'base>, ~left:Union.t2<ObjectLiteralExpression.t, ArrayLiteralExpression.t>, ~right:Expression.t) => DestructuringAssignment.t = "createAssignment"
    @send
    external createAssignment': (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => AssignmentExpression.t<EqualsToken.t> = "createAssignment"
    @send
    external createLogicalOr: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createLogicalOr"
    @send
    external createLogicalAnd: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createLogicalAnd"
    @send
    external createBitwiseOr: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createBitwiseOr"
    @send
    external createBitwiseXor: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createBitwiseXor"
    @send
    external createBitwiseAnd: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createBitwiseAnd"
    @send
    external createStrictEquality: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createStrictEquality"
    @send
    external createStrictInequality: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createStrictInequality"
    @send
    external createEquality: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createEquality"
    @send
    external createInequality: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createInequality"
    @send
    external createLessThan: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createLessThan"
    @send
    external createLessThanEquals: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createLessThanEquals"
    @send
    external createGreaterThan: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createGreaterThan"
    @send
    external createGreaterThanEquals: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createGreaterThanEquals"
    @send
    external createLeftShift: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createLeftShift"
    @send
    external createRightShift: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createRightShift"
    @send
    external createUnsignedRightShift: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createUnsignedRightShift"
    @send
    external createAdd: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createAdd"
    @send
    external createSubtract: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createSubtract"
    @send
    external createMultiply: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createMultiply"
    @send
    external createDivide: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createDivide"
    @send
    external createModulo: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createModulo"
    @send
    external createExponent: (this<'tags, 'base>, ~left:Expression.t, ~right:Expression.t) => BinaryExpression.t = "createExponent"
    @send
    external createPrefixPlus: (this<'tags, 'base>, ~operand:Expression.t) => PrefixUnaryExpression.t = "createPrefixPlus"
    @send
    external createPrefixMinus: (this<'tags, 'base>, ~operand:Expression.t) => PrefixUnaryExpression.t = "createPrefixMinus"
    @send
    external createPrefixIncrement: (this<'tags, 'base>, ~operand:Expression.t) => PrefixUnaryExpression.t = "createPrefixIncrement"
    @send
    external createPrefixDecrement: (this<'tags, 'base>, ~operand:Expression.t) => PrefixUnaryExpression.t = "createPrefixDecrement"
    @send
    external createBitwiseNot: (this<'tags, 'base>, ~operand:Expression.t) => PrefixUnaryExpression.t = "createBitwiseNot"
    @send
    external createLogicalNot: (this<'tags, 'base>, ~operand:Expression.t) => PrefixUnaryExpression.t = "createLogicalNot"
    @send
    external createPostfixIncrement: (this<'tags, 'base>, ~operand:Expression.t) => PostfixUnaryExpression.t = "createPostfixIncrement"
    @send
    external createPostfixDecrement: (this<'tags, 'base>, ~operand:Expression.t) => PostfixUnaryExpression.t = "createPostfixDecrement"
    @send
    external createImmediatelyInvokedFunctionExpression: (this<'tags, 'base>, ~statements:array<Statement.t>) => CallExpression.t = "createImmediatelyInvokedFunctionExpression"
    @send
    external createImmediatelyInvokedFunctionExpression': (this<'tags, 'base>, ~statements:array<Statement.t>, ~param:ParameterDeclaration.t, ~paramValue:Expression.t) => CallExpression.t = "createImmediatelyInvokedFunctionExpression"
    @send
    external createImmediatelyInvokedArrowFunction: (this<'tags, 'base>, ~statements:array<Statement.t>) => CallExpression.t = "createImmediatelyInvokedArrowFunction"
    @send
    external createImmediatelyInvokedArrowFunction': (this<'tags, 'base>, ~statements:array<Statement.t>, ~param:ParameterDeclaration.t, ~paramValue:Expression.t) => CallExpression.t = "createImmediatelyInvokedArrowFunction"
    @send
    external createVoidZero: this<'tags, 'base> => VoidExpression.t = "createVoidZero"
    @send
    external createExportDefault: (this<'tags, 'base>, ~expression:Expression.t) => ExportAssignment.t = "createExportDefault"
    @send
    external createExternalModuleExport: (this<'tags, 'base>, ~exportName:Identifier.t) => ExportDeclaration.t = "createExternalModuleExport"
    @send
    external restoreOuterExpressions: (this<'tags, 'base>, ~outerExpression:undefined<Expression.t>, ~innerExpression:Expression.t, ~kinds:OuterExpressionKinds.t=?, unit) => Expression.t = "restoreOuterExpressions"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module NodeFlags = {
    open NodeFlags
    type t = t
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "None"
    }
    module Let = {
      open Let
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "Let"
    }
    module Const = {
      open Const
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "Const"
    }
    module NestedNamespace = {
      open NestedNamespace
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "NestedNamespace"
    }
    module Synthesized = {
      open Synthesized
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "Synthesized"
    }
    module Namespace = {
      open Namespace
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "Namespace"
    }
    module OptionalChain = {
      open OptionalChain
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "OptionalChain"
    }
    module ExportContext = {
      open ExportContext
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "ExportContext"
    }
    module ContainsThis = {
      open ContainsThis
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "ContainsThis"
    }
    module HasImplicitReturn = {
      open HasImplicitReturn
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "HasImplicitReturn"
    }
    module HasExplicitReturn = {
      open HasExplicitReturn
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "HasExplicitReturn"
    }
    module GlobalAugmentation = {
      open GlobalAugmentation
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "GlobalAugmentation"
    }
    module HasAsyncFunctions = {
      open HasAsyncFunctions
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "HasAsyncFunctions"
    }
    module DisallowInContext = {
      open DisallowInContext
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "DisallowInContext"
    }
    module YieldContext = {
      open YieldContext
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "YieldContext"
    }
    module DecoratorContext = {
      open DecoratorContext
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "DecoratorContext"
    }
    module AwaitContext = {
      open AwaitContext
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "AwaitContext"
    }
    module ThisNodeHasError = {
      open ThisNodeHasError
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "ThisNodeHasError"
    }
    module JavaScriptFile = {
      open JavaScriptFile
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "JavaScriptFile"
    }
    module ThisNodeOrAnySubNodesHasError = {
      open ThisNodeOrAnySubNodesHasError
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "ThisNodeOrAnySubNodesHasError"
    }
    module HasAggregatedChildData = {
      open HasAggregatedChildData
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "HasAggregatedChildData"
    }
    module JSDoc = {
      open JSDoc
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "JSDoc"
    }
    module JsonFile = {
      open JsonFile
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "JsonFile"
    }
    module BlockScoped = {
      open BlockScoped
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "BlockScoped"
    }
    module ReachabilityCheckFlags = {
      open ReachabilityCheckFlags
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "ReachabilityCheckFlags"
    }
    module ReachabilityAndEmitFlags = {
      open ReachabilityAndEmitFlags
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "ReachabilityAndEmitFlags"
    }
    module ContextFlags = {
      open ContextFlags
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "ContextFlags"
    }
    module TypeExcludesFlags = {
      open TypeExcludesFlags
      type t = t
      type t0 = t
      @module("typescript") @scope("NodeFlags") @val
      external value: t = "TypeExcludesFlags"
    }
  }
  module NodeVisitor = {
    open NodeVisitor
    type t = t
    type t0 = t
    type tags = [#Ts_NodeVisitor]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NodeVisitor ]
    let apply: (this<'tags, 'base>, ~nodes:'T, ~visitor:undefined<Visitor.t>, ~test:(Dom.node => bool)=?, ~lift:(array<Dom.node> => 'T)=?, unit) => 'T = (t, ~nodes, ~visitor, ~test=?, ~lift=?, unit) => %raw(`t(nodes, visitor, test, lift)`)
    let apply': (this<'tags, 'base>, ~nodes:undefined<'T>, ~visitor:undefined<Visitor.t>, ~test:(Dom.node => bool)=?, ~lift:(array<Dom.node> => 'T)=?, unit) => undefined<'T> = (t, ~nodes, ~visitor, ~test=?, ~lift=?, unit) => %raw(`t(nodes, visitor, test, lift)`)
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module NodeWithTypeArguments = {
    open NodeWithTypeArguments
    type t = t
    type t0 = t
    type tags = [#Ts_Node | #Ts_NodeWithTypeArguments | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NodeWithTypeArguments ]
    @get
    external typeArguments: this<'tags, 'base> => NodeArray.t<TypeNode.t> = "typeArguments"
    @obj
    external make: ~typeArguments: NodeArray.t<TypeNode.t> => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
  }
  module NodesVisitor = {
    open NodesVisitor
    type t = t
    type t0 = t
    type tags = [#Ts_NodesVisitor]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NodesVisitor ]
    let apply: (this<'tags, 'base>, ~nodes:NodeArray.t<'T>, ~visitor:undefined<Visitor.t>, ~test:(Dom.node => bool)=?, ~start:float=?, ~count:float=?, unit) => NodeArray.t<'T> = (t, ~nodes, ~visitor, ~test=?, ~start=?, ~count=?, unit) => %raw(`t(nodes, visitor, test, start, count)`)
    let apply': (this<'tags, 'base>, ~nodes:undefined<NodeArray.t<'T>>, ~visitor:undefined<Visitor.t>, ~test:(Dom.node => bool)=?, ~start:float=?, ~count:float=?, unit) => undefined<NodeArray.t<'T>> = (t, ~nodes, ~visitor, ~test=?, ~start=?, ~count=?, unit) => %raw(`t(nodes, visitor, test, start, count)`)
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module NonNullChain = {
    open NonNullChain
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_NonNullChain | #Ts_NonNullExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NonNullChain ]
    @get
    external get_optionalChainBrand: this<'tags, 'base> => any = "_optionalChainBrand"
    @set
    external set_optionalChainBrand: (this<'tags, 'base>, any) => unit = "_optionalChainBrand"
    @obj
    external make: ~\"_optionalChainBrand": any => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNonNullExpression: t => NonNullExpression.t = "%identity"
  }
  module NonNullExpression = {
    open NonNullExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_NonNullExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NonNullExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.NonNullExpression.t = "kind"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.NonNullExpression.t, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLeftHandSideExpression: t => LeftHandSideExpression.t = "%identity"
  }
  module NonRelativeModuleNameResolutionCache = {
    open NonRelativeModuleNameResolutionCache
    type t = t
    type t0 = t
    type tags = [#Ts_NonRelativeModuleNameResolutionCache | #Ts_PackageJsonInfoCache]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NonRelativeModuleNameResolutionCache ]
    @send
    external getOrCreateCacheForModuleName: (this<'tags, 'base>, ~nonRelativeModuleName:string, ~mode:undefined<Union.t2<ModuleKind.CommonJS.t, ModuleKind.ESNext.t>>, ~redirectedReference:ResolvedProjectReference.t=?, unit) => PerModuleNameCache.t = "getOrCreateCacheForModuleName"
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPackageJsonInfoCache: t => PackageJsonInfoCache.t = "%identity"
  }
  module NotEmittedStatement = {
    open NotEmittedStatement
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocContainer | #Ts_Node | #Ts_NotEmittedStatement | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NotEmittedStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.NotEmittedStatement.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.NotEmittedStatement.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module NullLiteral = {
    open NullLiteral
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_NullLiteral | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NullLiteral ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.NullKeyword.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.NullKeyword.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
  }
  module NumberLiteralType = {
    open NumberLiteralType
    type t = t
    type t0 = t
    type tags = [#Ts_LiteralType | #Ts_NumberLiteralType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NumberLiteralType ]
    @get
    external getValue: this<'tags, 'base> => float = "value"
    @set
    external setValue: (this<'tags, 'base>, float) => unit = "value"
    @obj
    external make: ~value: float => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLiteralType: t => LiteralType.t = "%identity"
  }
  module NumericLiteral = {
    open NumericLiteral
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_LiteralExpression | #Ts_LiteralLikeNode | #Ts_MemberExpression | #Ts_Node | #Ts_NumericLiteral | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_NumericLiteral ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.NumericLiteral.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.NumericLiteral.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLiteralExpression: t => LiteralExpression.t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module ObjectBindingOrAssignmentElement = {
    open ObjectBindingOrAssignmentElement
    type t = Union.t4<BindingElement.t, PropertyAssignment.t, ShorthandPropertyAssignment.t, SpreadAssignment.t>
    type t0 = t
  }
  module ObjectBindingOrAssignmentPattern = {
    open ObjectBindingOrAssignmentPattern
    type t = Union.t2<ObjectBindingPattern.t, ObjectLiteralExpression.t>
    type t0 = t
  }
  module ObjectBindingPattern = {
    open ObjectBindingPattern
    type t = t
    type t0 = t
    type tags = [#Ts_Node | #Ts_ObjectBindingPattern | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ObjectBindingPattern ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ObjectBindingPattern.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t3<VariableDeclaration.t, ParameterDeclaration.t, BindingElement.t> = "parent"
    @get
    external elements: this<'tags, 'base> => NodeArray.t<BindingElement.t> = "elements"
    @obj
    external make: (~kind: SyntaxKind.ObjectBindingPattern.t, ~parent: Union.t3<VariableDeclaration.t, ParameterDeclaration.t, BindingElement.t>, ~elements: NodeArray.t<BindingElement.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module ObjectDestructuringAssignment = {
    open ObjectDestructuringAssignment
    type t = t
    type t0 = t
    type tags = [#Ts_AssignmentExpression(EqualsToken.t) | #Ts_BinaryExpression | #Ts_Declaration | #Ts_Expression | #Ts_Node | #Ts_ObjectDestructuringAssignment | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ObjectDestructuringAssignment ]
    @get
    external left: this<'tags, 'base> => ObjectLiteralExpression.t = "left"
    @obj
    external make: ~left: ObjectLiteralExpression.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asAssignmentExpression: t => AssignmentExpression.t<EqualsToken.t> = "%identity"
  }
  module ObjectFlags = {
    open ObjectFlags
    type t = t
    type t_0 = t
    module Class = {
      open Class
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "Class"
    }
    module Interface = {
      open Interface
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "Interface"
    }
    module Reference = {
      open Reference
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "Reference"
    }
    module Tuple = {
      open Tuple
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "Tuple"
    }
    module Anonymous = {
      open Anonymous
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "Anonymous"
    }
    module Mapped = {
      open Mapped
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "Mapped"
    }
    module Instantiated = {
      open Instantiated
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "Instantiated"
    }
    module ObjectLiteral = {
      open ObjectLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "ObjectLiteral"
    }
    module EvolvingArray = {
      open EvolvingArray
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "EvolvingArray"
    }
    module ObjectLiteralPatternWithComputedProperties = {
      open ObjectLiteralPatternWithComputedProperties
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "ObjectLiteralPatternWithComputedProperties"
    }
    module ReverseMapped = {
      open ReverseMapped
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "ReverseMapped"
    }
    module JsxAttributes = {
      open JsxAttributes
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "JsxAttributes"
    }
    module MarkerType = {
      open MarkerType
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "MarkerType"
    }
    module JSLiteral = {
      open JSLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "JSLiteral"
    }
    module FreshLiteral = {
      open FreshLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "FreshLiteral"
    }
    module ArrayLiteral = {
      open ArrayLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "ArrayLiteral"
    }
    module ClassOrInterface = {
      open ClassOrInterface
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "ClassOrInterface"
    }
    module ContainsSpread = {
      open ContainsSpread
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "ContainsSpread"
    }
    module ObjectRestType = {
      open ObjectRestType
      type t = t
      type t0 = t
      @module("typescript") @scope("ObjectFlags") @val
      external value: t = "ObjectRestType"
    }
  }
  module ObjectLiteralElement = {
    open ObjectLiteralElement
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ObjectLiteralElement ]
    @get
    external get_objectLiteralBrand: this<'tags, 'base> => any = "_objectLiteralBrand"
    @set
    external set_objectLiteralBrand: (this<'tags, 'base>, any) => unit = "_objectLiteralBrand"
    @get
    external name: this<'tags, 'base> => PropertyName.t = "name"
    @obj
    external make: (~\"_objectLiteralBrand": any, ~name: PropertyName.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
  }
  module ObjectLiteralElementLike = {
    open ObjectLiteralElementLike
    type t = Union.t5<PropertyAssignment.t, ShorthandPropertyAssignment.t, SpreadAssignment.t, MethodDeclaration.t, AccessorDeclaration.t>
    type t0 = t
  }
  module ObjectLiteralExpression = {
    open ObjectLiteralExpression
    type t = t
    type t0 = t
    type tags = [#Ts_ObjectLiteralExpressionBase(ObjectLiteralElementLike.t) | #Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ObjectLiteralExpression | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ObjectLiteralExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ObjectLiteralExpression.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.ObjectLiteralExpression.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asObjectLiteralExpressionBase: t => ObjectLiteralExpressionBase.t<ObjectLiteralElementLike.t> = "%identity"
  }
  module ObjectLiteralExpressionBase = {
    open ObjectLiteralExpressionBase
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_ObjectLiteralExpressionBase('T) | #Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_ObjectLiteralExpressionBase('T) ]
    @get
    external properties: this<'tags, 'base, 'T> => NodeArray.t<'T> = "properties"
    @obj
    external make: ~properties: NodeArray.t<'T> => t<'T> = ""
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asPrimaryExpression: t<'T> => PrimaryExpression.t = "%identity"
    external asDeclaration: t<'T> => Declaration.t = "%identity"
  }
  module ObjectType = {
    open ObjectType
    type t = t
    type t0 = t
    type tags = [#Ts_ObjectType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ObjectType ]
    @get
    external getObjectFlags: this<'tags, 'base> => ObjectFlags.t = "objectFlags"
    @set
    external setObjectFlags: (this<'tags, 'base>, ObjectFlags.t) => unit = "objectFlags"
    @obj
    external make: ~objectFlags: ObjectFlags.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asType: t => Type.t = "%identity"
  }
  module ObjectTypeDeclaration = {
    open ObjectTypeDeclaration
    type t = Union.t3<ClassLikeDeclaration.t, InterfaceDeclaration.t, TypeLiteralNode.t>
    type t0 = t
  }
  module OmittedExpression = {
    open OmittedExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_Node | #Ts_OmittedExpression | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_OmittedExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.OmittedExpression.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.OmittedExpression.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asExpression: t => Expression.t = "%identity"
  }
  module OperationCanceledException = {
    open OperationCanceledException
    type t = t
    type t0 = t
    type tags = [#Ts_OperationCanceledException]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_OperationCanceledException ]
    @module("typescript") @new
    external make: () => t = "OperationCanceledException"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module OptionalChain = {
    open OptionalChain
    type t = Union.t4<PropertyAccessChain.t, ElementAccessChain.t, CallChain.t, NonNullChain.t>
    type t0 = t
  }
  module OptionalTypeNode = {
    open OptionalTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_Node | #Ts_OptionalTypeNode | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_OptionalTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.OptionalType.t = "kind"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: SyntaxKind.OptionalType.t, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
  }
  module OrganizeImportsArgs = {
    open OrganizeImportsArgs
    type t = t
    type t0 = t
    type tags = [#Ts_CombinedCodeFixScope | #Ts_OrganizeImportsArgs]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_OrganizeImportsArgs ]
    @get
    external getSkipDestructiveCodeActions: this<'tags, 'base> => bool = "skipDestructiveCodeActions"
    @set
    external setSkipDestructiveCodeActions: (this<'tags, 'base>, bool) => unit = "skipDestructiveCodeActions"
    @obj
    external make: ~skipDestructiveCodeActions: bool => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asCombinedCodeFixScope: t => CombinedCodeFixScope.t = "%identity"
  }
  module OuterExpressionKinds = {
    open OuterExpressionKinds
    type t = t
    type t_0 = t
    module Parentheses = {
      open Parentheses
      type t = t
      type t0 = t
      @module("typescript") @scope("OuterExpressionKinds") @val
      external value: t = "Parentheses"
    }
    module TypeAssertions = {
      open TypeAssertions
      type t = t
      type t0 = t
      @module("typescript") @scope("OuterExpressionKinds") @val
      external value: t = "TypeAssertions"
    }
    module NonNullAssertions = {
      open NonNullAssertions
      type t = t
      type t0 = t
      @module("typescript") @scope("OuterExpressionKinds") @val
      external value: t = "NonNullAssertions"
    }
    module PartiallyEmittedExpressions = {
      open PartiallyEmittedExpressions
      type t = t
      type t0 = t
      @module("typescript") @scope("OuterExpressionKinds") @val
      external value: t = "PartiallyEmittedExpressions"
    }
    module Assertions = {
      open Assertions
      type t = t
      type t0 = t
      @module("typescript") @scope("OuterExpressionKinds") @val
      external value: t = "Assertions"
    }
    module All = {
      open All
      type t = t
      type t0 = t
      @module("typescript") @scope("OuterExpressionKinds") @val
      external value: t = "All"
    }
    module ExcludeJSDocTypeAssertion = {
      open ExcludeJSDocTypeAssertion
      type t = t
      type t0 = t
      @module("typescript") @scope("OuterExpressionKinds") @val
      external value: t = "ExcludeJSDocTypeAssertion"
    }
  }
  module OutliningSpan = {
    open OutliningSpan
    type t = t
    type t0 = t
    type tags = [#Ts_OutliningSpan]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_OutliningSpan ]
    @get
    external getTextSpan: this<'tags, 'base> => TextSpan.t = "textSpan"
    @set
    external setTextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "textSpan"
    @get
    external getHintSpan: this<'tags, 'base> => TextSpan.t = "hintSpan"
    @set
    external setHintSpan: (this<'tags, 'base>, TextSpan.t) => unit = "hintSpan"
    @get
    external getBannerText: this<'tags, 'base> => string = "bannerText"
    @set
    external setBannerText: (this<'tags, 'base>, string) => unit = "bannerText"
    @get
    external getAutoCollapse: this<'tags, 'base> => bool = "autoCollapse"
    @set
    external setAutoCollapse: (this<'tags, 'base>, bool) => unit = "autoCollapse"
    @get
    external getKind: this<'tags, 'base> => OutliningSpanKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, OutliningSpanKind.t) => unit = "kind"
    @obj
    external make: (~textSpan: TextSpan.t, ~hintSpan: TextSpan.t, ~bannerText: string, ~autoCollapse: bool, ~kind: OutliningSpanKind.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module OutliningSpanKind = {
    open OutliningSpanKind
    type t = t
    type t_0 = t
    module Comment = {
      open Comment
      type t = t
      type t0 = t
      @module("typescript") @scope("OutliningSpanKind") @val
      external value: t = "Comment"
    }
    module Region = {
      open Region
      type t = t
      type t0 = t
      @module("typescript") @scope("OutliningSpanKind") @val
      external value: t = "Region"
    }
    module Code = {
      open Code
      type t = t
      type t0 = t
      @module("typescript") @scope("OutliningSpanKind") @val
      external value: t = "Code"
    }
    module Imports = {
      open Imports
      type t = t
      type t0 = t
      @module("typescript") @scope("OutliningSpanKind") @val
      external value: t = "Imports"
    }
  }
  module OutputFile = {
    open OutputFile
    type t = t
    type t0 = t
    type tags = [#Ts_OutputFile]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_OutputFile ]
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @get
    external getWriteByteOrderMark: this<'tags, 'base> => bool = "writeByteOrderMark"
    @set
    external setWriteByteOrderMark: (this<'tags, 'base>, bool) => unit = "writeByteOrderMark"
    @get
    external getText: this<'tags, 'base> => string = "text"
    @set
    external setText: (this<'tags, 'base>, string) => unit = "text"
    @obj
    external make: (~name: string, ~writeByteOrderMark: bool, ~text: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module OutputFileType = {
    open OutputFileType
    type t = t = JavaScript | SourceMap | Declaration
    type t_0 = t
    module JavaScript = {
      open JavaScript
      type t = t
      type t0 = t
      @module("typescript") @scope("OutputFileType") @val
      external value: t = "JavaScript"
    }
    module SourceMap = {
      open SourceMap
      type t = t
      type t0 = t
      @module("typescript") @scope("OutputFileType") @val
      external value: t = "SourceMap"
    }
    module Declaration = {
      open Declaration
      type t = t
      type t0 = t
      @module("typescript") @scope("OutputFileType") @val
      external value: t = "Declaration"
    }
  }
  module OverrideKeyword = {
    open OverrideKeyword
    type t = ModifierToken.t<SyntaxKind.OverrideKeyword.t>
    type t0 = t
  }
  module PackageId = {
    open PackageId
    type t = t
    type t0 = t
    type tags = [#Ts_PackageId]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PackageId ]
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @get
    external getSubModuleName: this<'tags, 'base> => string = "subModuleName"
    @set
    external setSubModuleName: (this<'tags, 'base>, string) => unit = "subModuleName"
    @get
    external getVersion: this<'tags, 'base> => string = "version"
    @set
    external setVersion: (this<'tags, 'base>, string) => unit = "version"
    @obj
    external make: (~name: string, ~subModuleName: string, ~version: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module PackageJsonInfoCache = {
    open PackageJsonInfoCache
    type t = t
    type t0 = t
    type tags = [#Ts_PackageJsonInfoCache]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PackageJsonInfoCache ]
    @send
    external clear: this<'tags, 'base> => unit = "clear"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ParameterDeclaration = {
    open ParameterDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ParameterDeclaration | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ParameterDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.Parameter.t = "kind"
    @get
    external parent: this<'tags, 'base> => SignatureDeclaration.t = "parent"
    @get
    external dotDotDotToken: this<'tags, 'base> => DotDotDotToken.t = "dotDotDotToken"
    @get
    external name: this<'tags, 'base> => BindingName.t = "name"
    @get
    external questionToken: this<'tags, 'base> => QuestionToken.t = "questionToken"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @get
    external initializer: this<'tags, 'base> => Expression.t = "initializer"
    @obj
    external make: (~kind: SyntaxKind.Parameter.t, ~parent: SignatureDeclaration.t, ~dotDotDotToken: DotDotDotToken.t, ~name: BindingName.t, ~questionToken: QuestionToken.t, ~\"type": TypeNode.t, ~initializer: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module ParameterPropertyDeclaration = {
    open ParameterPropertyDeclaration
    module AnonymousInterface22 = {
      open AnonymousInterface22
      type t = t
      @get
      external getParent: t => ConstructorDeclaration.t = "parent"
      @set
      external setParent: (t, ConstructorDeclaration.t) => unit = "parent"
      @get
      external getName: t => Identifier.t = "name"
      @set
      external setName: (t, Identifier.t) => unit = "name"
      @obj
      external make: (~parent: ConstructorDeclaration.t, ~name: Identifier.t) => t = ""
    }
    type t = Intersection.t2<ParameterDeclaration.t, AnonymousInterface22.t>
    type t0 = t
  }
  module ParameterPropertyModifier = {
    open ParameterPropertyModifier
    type t = Union.t2<AccessibilityModifier.t, ReadonlyKeyword.t>
    type t0 = t
  }
  module ParenthesizedExpression = {
    open ParenthesizedExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_JSDocContainer | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ParenthesizedExpression | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ParenthesizedExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ParenthesizedExpression.t = "kind"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.ParenthesizedExpression.t, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module ParenthesizedTypeNode = {
    open ParenthesizedTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_Node | #Ts_ParenthesizedTypeNode | #Ts_ReadonlyTextRange | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ParenthesizedTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ParenthesizedType.t = "kind"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: SyntaxKind.ParenthesizedType.t, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
  }
  module ParseConfigFileHost = {
    open ParseConfigFileHost
    type t = t
    type t0 = t
    type tags = [#Ts_ConfigFileDiagnosticsReporter | #Ts_ParseConfigFileHost | #Ts_ParseConfigHost]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ParseConfigFileHost ]
    @send
    external getCurrentDirectory: this<'tags, 'base> => string = "getCurrentDirectory"
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asParseConfigHost: t => ParseConfigHost.t = "%identity"
    external asConfigFileDiagnosticsReporter: t => ConfigFileDiagnosticsReporter.t = "%identity"
  }
  module ParseConfigHost = {
    open ParseConfigHost
    type t = t
    type t0 = t
    type tags = [#Ts_ParseConfigHost]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ParseConfigHost ]
    @get
    external getUseCaseSensitiveFileNames: this<'tags, 'base> => bool = "useCaseSensitiveFileNames"
    @set
    external setUseCaseSensitiveFileNames: (this<'tags, 'base>, bool) => unit = "useCaseSensitiveFileNames"
    @send
    external readDirectory: (this<'tags, 'base>, ~rootDir:string, ~extensions:array<string>, ~excludes:undefined<array<string>>, ~includes:array<string>, ~depth:float=?, unit) => array<string> = "readDirectory"
    @send
    external fileExists: (this<'tags, 'base>, ~path:string) => bool = "fileExists"
    @send @return(nullable)
    external readFile: (this<'tags, 'base>, ~path:string) => option<string> = "readFile"
    @send
    external trace: (this<'tags, 'base>, ~s:string) => unit = "trace"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ParsedCommandLine = {
    open ParsedCommandLine
    type t = t
    type t0 = t
    type tags = [#Ts_ParsedCommandLine]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ParsedCommandLine ]
    @get
    external getOptions: this<'tags, 'base> => CompilerOptions.t = "options"
    @set
    external setOptions: (this<'tags, 'base>, CompilerOptions.t) => unit = "options"
    @get
    external getTypeAcquisition: this<'tags, 'base> => TypeAcquisition.t = "typeAcquisition"
    @set
    external setTypeAcquisition: (this<'tags, 'base>, TypeAcquisition.t) => unit = "typeAcquisition"
    @get
    external getFileNames: this<'tags, 'base> => array<string> = "fileNames"
    @set
    external setFileNames: (this<'tags, 'base>, array<string>) => unit = "fileNames"
    @get
    external getProjectReferences: this<'tags, 'base> => array<ProjectReference.t> = "projectReferences"
    @set
    external setProjectReferences: (this<'tags, 'base>, array<ProjectReference.t>) => unit = "projectReferences"
    @get
    external getWatchOptions: this<'tags, 'base> => WatchOptions.t = "watchOptions"
    @set
    external setWatchOptions: (this<'tags, 'base>, WatchOptions.t) => unit = "watchOptions"
    @get
    external getRaw: this<'tags, 'base> => any = "raw"
    @set
    external setRaw: (this<'tags, 'base>, any) => unit = "raw"
    @get
    external getErrors: this<'tags, 'base> => array<Diagnostic.t> = "errors"
    @set
    external setErrors: (this<'tags, 'base>, array<Diagnostic.t>) => unit = "errors"
    @get
    external getWildcardDirectories: this<'tags, 'base> => MapLike.t<WatchDirectoryFlags.t> = "wildcardDirectories"
    @set
    external setWildcardDirectories: (this<'tags, 'base>, MapLike.t<WatchDirectoryFlags.t>) => unit = "wildcardDirectories"
    @get
    external getCompileOnSave: this<'tags, 'base> => bool = "compileOnSave"
    @set
    external setCompileOnSave: (this<'tags, 'base>, bool) => unit = "compileOnSave"
    @obj
    external make: (~options: CompilerOptions.t, ~typeAcquisition: TypeAcquisition.t, ~fileNames: array<string>, ~projectReferences: array<ProjectReference.t>, ~watchOptions: WatchOptions.t, ~raw: any, ~errors: array<Diagnostic.t>, ~wildcardDirectories: MapLike.t<WatchDirectoryFlags.t>, ~compileOnSave: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ParsedTsconfig = {
    open ParsedTsconfig
    type t = t
    type t0 = t
    type tags = [#Ts_ParsedTsconfig]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ParsedTsconfig ]
    @get
    external getRaw: this<'tags, 'base> => any = "raw"
    @set
    external setRaw: (this<'tags, 'base>, any) => unit = "raw"
    @get
    external getOptions: this<'tags, 'base> => CompilerOptions.t = "options"
    @set
    external setOptions: (this<'tags, 'base>, CompilerOptions.t) => unit = "options"
    @get
    external getWatchOptions: this<'tags, 'base> => WatchOptions.t = "watchOptions"
    @set
    external setWatchOptions: (this<'tags, 'base>, WatchOptions.t) => unit = "watchOptions"
    @get
    external getTypeAcquisition: this<'tags, 'base> => TypeAcquisition.t = "typeAcquisition"
    @set
    external setTypeAcquisition: (this<'tags, 'base>, TypeAcquisition.t) => unit = "typeAcquisition"
    @get
    external getExtendedConfigPath: this<'tags, 'base> => string = "extendedConfigPath"
    @set
    external setExtendedConfigPath: (this<'tags, 'base>, string) => unit = "extendedConfigPath"
    @obj
    external make: (~raw: any, ~options: CompilerOptions.t, ~watchOptions: WatchOptions.t, ~typeAcquisition: TypeAcquisition.t, ~extendedConfigPath: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module PartiallyEmittedExpression = {
    open PartiallyEmittedExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_PartiallyEmittedExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PartiallyEmittedExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.PartiallyEmittedExpression.t = "kind"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.PartiallyEmittedExpression.t, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLeftHandSideExpression: t => LeftHandSideExpression.t = "%identity"
  }
  module Path = {
    open Path
    module AnonymousInterface2 = {
      open AnonymousInterface2
      type t = t
      @get
      external get__pathBrand: t => any = "__pathBrand"
      @set
      external set__pathBrand: (t, any) => unit = "__pathBrand"
      @obj
      external make: ~\"__pathBrand": any => t = ""
    }
    type t = Intersection.t2<string, AnonymousInterface2.t>
    type t0 = t
  }
  module PerDirectoryResolutionCache = {
    open PerDirectoryResolutionCache
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_PerDirectoryResolutionCache('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_PerDirectoryResolutionCache('T) ]
    @send
    external getOrCreateCacheForDirectory: (this<'tags, 'base, 'T>, ~directoryName:string, ~redirectedReference:ResolvedProjectReference.t=?, unit) => ModeAwareCache.t<'T> = "getOrCreateCacheForDirectory"
    @send
    external clear: this<'tags, 'base, 'T> => unit = "clear"
    @send
    external update: (this<'tags, 'base, 'T>, ~options:CompilerOptions.t) => unit = "update"
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
  }
  module PerModuleNameCache = {
    open PerModuleNameCache
    type t = t
    type t0 = t
    type tags = [#Ts_PerModuleNameCache]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PerModuleNameCache ]
    @send @return(nullable)
    external get: (this<'tags, 'base>, ~directory:string) => option<ResolvedModuleWithFailedLookupLocations.t> = "get"
    @send
    external set: (this<'tags, 'base>, ~directory:string, ~result:ResolvedModuleWithFailedLookupLocations.t) => unit = "set"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module PerformanceEvent = {
    open PerformanceEvent
    type t = t
    type t0 = t
    type tags = [#Ts_PerformanceEvent]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PerformanceEvent ]
    @get
    external getKind: this<'tags, 'base> => Union.t2<[#UpdateGraph], [#CreatePackageJsonAutoImportProvider]> = "kind"
    @set
    external setKind: (this<'tags, 'base>, Union.t2<[#UpdateGraph], [#CreatePackageJsonAutoImportProvider]>) => unit = "kind"
    @get
    external getDurationMs: this<'tags, 'base> => float = "durationMs"
    @set
    external setDurationMs: (this<'tags, 'base>, float) => unit = "durationMs"
    @obj
    external make: (~kind: Union.t2<[#UpdateGraph], [#CreatePackageJsonAutoImportProvider]>, ~durationMs: float) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module PluginImport = {
    open PluginImport
    type t = t
    type t0 = t
    type tags = [#Ts_PluginImport]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PluginImport ]
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @obj
    external make: ~name: string => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module PlusToken = {
    open PlusToken
    type t = PunctuationToken.t<SyntaxKind.PlusToken.t>
    type t0 = t
  }
  module PollingWatchKind = {
    open PollingWatchKind
    type t = t = FixedInterval | PriorityInterval | DynamicPriority | FixedChunkSize
    type t_0 = t
    module FixedInterval = {
      open FixedInterval
      type t = t
      type t0 = t
      @module("typescript") @scope("PollingWatchKind") @val
      external value: t = "FixedInterval"
    }
    module PriorityInterval = {
      open PriorityInterval
      type t = t
      type t0 = t
      @module("typescript") @scope("PollingWatchKind") @val
      external value: t = "PriorityInterval"
    }
    module DynamicPriority = {
      open DynamicPriority
      type t = t
      type t0 = t
      @module("typescript") @scope("PollingWatchKind") @val
      external value: t = "DynamicPriority"
    }
    module FixedChunkSize = {
      open FixedChunkSize
      type t = t
      type t0 = t
      @module("typescript") @scope("PollingWatchKind") @val
      external value: t = "FixedChunkSize"
    }
  }
  module PostfixUnaryExpression = {
    open PostfixUnaryExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_Node | #Ts_PostfixUnaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PostfixUnaryExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.PostfixUnaryExpression.t = "kind"
    @get
    external operand: this<'tags, 'base> => LeftHandSideExpression.t = "operand"
    @get
    external operator: this<'tags, 'base> => PostfixUnaryOperator.t = "operator"
    @obj
    external make: (~kind: SyntaxKind.PostfixUnaryExpression.t, ~operand: LeftHandSideExpression.t, ~operator: PostfixUnaryOperator.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asUpdateExpression: t => UpdateExpression.t = "%identity"
  }
  module PostfixUnaryOperator = {
    open PostfixUnaryOperator
    type t = Union.t2<SyntaxKind.PlusPlusToken.t, SyntaxKind.MinusMinusToken.t>
    type t0 = t
  }
  module PreProcessedFileInfo = {
    open PreProcessedFileInfo
    type t = t
    type t0 = t
    type tags = [#Ts_PreProcessedFileInfo]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PreProcessedFileInfo ]
    @get
    external getReferencedFiles: this<'tags, 'base> => array<FileReference.t> = "referencedFiles"
    @set
    external setReferencedFiles: (this<'tags, 'base>, array<FileReference.t>) => unit = "referencedFiles"
    @get
    external getTypeReferenceDirectives: this<'tags, 'base> => array<FileReference.t> = "typeReferenceDirectives"
    @set
    external setTypeReferenceDirectives: (this<'tags, 'base>, array<FileReference.t>) => unit = "typeReferenceDirectives"
    @get
    external getLibReferenceDirectives: this<'tags, 'base> => array<FileReference.t> = "libReferenceDirectives"
    @set
    external setLibReferenceDirectives: (this<'tags, 'base>, array<FileReference.t>) => unit = "libReferenceDirectives"
    @get
    external getImportedFiles: this<'tags, 'base> => array<FileReference.t> = "importedFiles"
    @set
    external setImportedFiles: (this<'tags, 'base>, array<FileReference.t>) => unit = "importedFiles"
    @get
    external getAmbientExternalModules: this<'tags, 'base> => array<string> = "ambientExternalModules"
    @set
    external setAmbientExternalModules: (this<'tags, 'base>, array<string>) => unit = "ambientExternalModules"
    @get
    external getIsLibFile: this<'tags, 'base> => bool = "isLibFile"
    @set
    external setIsLibFile: (this<'tags, 'base>, bool) => unit = "isLibFile"
    @obj
    external make: (~referencedFiles: array<FileReference.t>, ~typeReferenceDirectives: array<FileReference.t>, ~libReferenceDirectives: array<FileReference.t>, ~importedFiles: array<FileReference.t>, ~ambientExternalModules: array<string>, ~isLibFile: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module PrefixUnaryExpression = {
    open PrefixUnaryExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_Node | #Ts_PrefixUnaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PrefixUnaryExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.PrefixUnaryExpression.t = "kind"
    @get
    external operator: this<'tags, 'base> => PrefixUnaryOperator.t = "operator"
    @get
    external operand: this<'tags, 'base> => UnaryExpression.t = "operand"
    @obj
    external make: (~kind: SyntaxKind.PrefixUnaryExpression.t, ~operator: PrefixUnaryOperator.t, ~operand: UnaryExpression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asUpdateExpression: t => UpdateExpression.t = "%identity"
  }
  module PrefixUnaryOperator = {
    open PrefixUnaryOperator
    type t = Union.t6<SyntaxKind.PlusPlusToken.t, SyntaxKind.MinusMinusToken.t, SyntaxKind.PlusToken.t, SyntaxKind.MinusToken.t, SyntaxKind.TildeToken.t, SyntaxKind.ExclamationToken.t>
    type t0 = t
  }
  module PrimaryExpression = {
    open PrimaryExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PrimaryExpression ]
    @get
    external get_primaryExpressionBrand: this<'tags, 'base> => any = "_primaryExpressionBrand"
    @set
    external set_primaryExpressionBrand: (this<'tags, 'base>, any) => unit = "_primaryExpressionBrand"
    @obj
    external make: ~\"_primaryExpressionBrand": any => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asMemberExpression: t => MemberExpression.t = "%identity"
  }
  module PrintHandlers = {
    open PrintHandlers
    type t = t
    type t0 = t
    type tags = [#Ts_PrintHandlers]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PrintHandlers ]
    @send
    external hasGlobalName: (this<'tags, 'base>, ~name:string) => bool = "hasGlobalName"
    @send
    external onEmitNode: (this<'tags, 'base>, ~hint:EmitHint.t, ~node:Dom.node, ~emitCallback:(@uncurry (~hint:EmitHint.t, ~node:Dom.node) => unit)) => unit = "onEmitNode"
    @send
    external isEmitNotificationEnabled: (this<'tags, 'base>, ~node:Dom.node) => bool = "isEmitNotificationEnabled"
    @send
    external substituteNode: (this<'tags, 'base>, ~hint:EmitHint.t, ~node:Dom.node) => Dom.node = "substituteNode"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module Printer = {
    open Printer
    type t = t
    type t0 = t
    type tags = [#Ts_Printer]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Printer ]
    @send
    external printNode: (this<'tags, 'base>, ~hint:EmitHint.t, ~node:Dom.node, ~sourceFile:SourceFile.t) => string = "printNode"
    @send
    external printList: (this<'tags, 'base>, ~format:ListFormat.t, ~list:NodeArray.t<'T>, ~sourceFile:SourceFile.t) => string = "printList"
    @send
    external printFile: (this<'tags, 'base>, ~sourceFile:SourceFile.t) => string = "printFile"
    @send
    external printBundle: (this<'tags, 'base>, ~bundle:Bundle.t) => string = "printBundle"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module PrinterOptions = {
    open PrinterOptions
    type t = t
    type t0 = t
    type tags = [#Ts_PrinterOptions]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PrinterOptions ]
    @get
    external getRemoveComments: this<'tags, 'base> => bool = "removeComments"
    @set
    external setRemoveComments: (this<'tags, 'base>, bool) => unit = "removeComments"
    @get
    external getNewLine: this<'tags, 'base> => NewLineKind.t = "newLine"
    @set
    external setNewLine: (this<'tags, 'base>, NewLineKind.t) => unit = "newLine"
    @get
    external getOmitTrailingSemicolon: this<'tags, 'base> => bool = "omitTrailingSemicolon"
    @set
    external setOmitTrailingSemicolon: (this<'tags, 'base>, bool) => unit = "omitTrailingSemicolon"
    @get
    external getNoEmitHelpers: this<'tags, 'base> => bool = "noEmitHelpers"
    @set
    external setNoEmitHelpers: (this<'tags, 'base>, bool) => unit = "noEmitHelpers"
    @obj
    external make: (~removeComments: bool, ~newLine: NewLineKind.t, ~omitTrailingSemicolon: bool, ~noEmitHelpers: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module PrivateIdentifier = {
    open PrivateIdentifier
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_PrivateIdentifier | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PrivateIdentifier ]
    @get
    external text: this<'tags, 'base> => string = "text"
    @get
    external kind: this<'tags, 'base> => SyntaxKind.PrivateIdentifier.t = "kind"
    @get
    external escapedText: this<'tags, 'base> => M__String.t = "escapedText"
    @obj
    external make: (~text: string, ~kind: SyntaxKind.PrivateIdentifier.t, ~escapedText: M__String.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
  }
  module PrivateKeyword = {
    open PrivateKeyword
    type t = ModifierToken.t<SyntaxKind.PrivateKeyword.t>
    type t0 = t
  }
  module Program = {
    open Program
    module AnonymousInterface4 = {
      open AnonymousInterface4
      type t = t
      @get
      external getAssignable: t => float = "assignable"
      @set
      external setAssignable: (t, float) => unit = "assignable"
      @get
      external getIdentity: t => float = "identity"
      @set
      external setIdentity: (t, float) => unit = "identity"
      @get
      external getSubtype: t => float = "subtype"
      @set
      external setSubtype: (t, float) => unit = "subtype"
      @get
      external getStrictSubtype: t => float = "strictSubtype"
      @set
      external setStrictSubtype: (t, float) => unit = "strictSubtype"
      @obj
      external make: (~assignable: float, ~identity: float, ~subtype: float, ~strictSubtype: float) => t = ""
    }
    type t = t
    type t0 = t
    type tags = [#Ts_Program | #Ts_ScriptReferenceHost]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Program ]
    @send
    external getCurrentDirectory: this<'tags, 'base> => string = "getCurrentDirectory"
    @send
    external getRootFileNames: this<'tags, 'base> => array<string> = "getRootFileNames"
    @send
    external getSourceFiles: this<'tags, 'base> => array<SourceFile.t> = "getSourceFiles"
    @send
    external emit: (this<'tags, 'base>, ~targetSourceFile:SourceFile.t=?, ~writeFile:WriteFileCallback.t=?, ~cancellationToken:CancellationToken.t=?, ~emitOnlyDtsFiles:bool=?, ~customTransformers:CustomTransformers.t=?, unit) => EmitResult.t = "emit"
    @send
    external getOptionsDiagnostics: (this<'tags, 'base>, ~cancellationToken:CancellationToken.t=?, unit) => array<Diagnostic.t> = "getOptionsDiagnostics"
    @send
    external getGlobalDiagnostics: (this<'tags, 'base>, ~cancellationToken:CancellationToken.t=?, unit) => array<Diagnostic.t> = "getGlobalDiagnostics"
    @send
    external getSyntacticDiagnostics: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, ~cancellationToken:CancellationToken.t=?, unit) => array<DiagnosticWithLocation.t> = "getSyntacticDiagnostics"
    @send
    external getSemanticDiagnostics: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, ~cancellationToken:CancellationToken.t=?, unit) => array<Diagnostic.t> = "getSemanticDiagnostics"
    @send
    external getDeclarationDiagnostics: (this<'tags, 'base>, ~sourceFile:SourceFile.t=?, ~cancellationToken:CancellationToken.t=?, unit) => array<DiagnosticWithLocation.t> = "getDeclarationDiagnostics"
    @send
    external getConfigFileParsingDiagnostics: this<'tags, 'base> => array<Diagnostic.t> = "getConfigFileParsingDiagnostics"
    @send
    external getTypeChecker: this<'tags, 'base> => TypeChecker.t = "getTypeChecker"
    @send
    external getNodeCount: this<'tags, 'base> => float = "getNodeCount"
    @send
    external getIdentifierCount: this<'tags, 'base> => float = "getIdentifierCount"
    @send
    external getSymbolCount: this<'tags, 'base> => float = "getSymbolCount"
    @send
    external getTypeCount: this<'tags, 'base> => float = "getTypeCount"
    @send
    external getInstantiationCount: this<'tags, 'base> => float = "getInstantiationCount"
    @send
    external getRelationCacheSizes: this<'tags, 'base> => AnonymousInterface4.t = "getRelationCacheSizes"
    @send
    external isSourceFileFromExternalLibrary: (this<'tags, 'base>, ~file:SourceFile.t) => bool = "isSourceFileFromExternalLibrary"
    @send
    external isSourceFileDefaultLibrary: (this<'tags, 'base>, ~file:SourceFile.t) => bool = "isSourceFileDefaultLibrary"
    @send @return(nullable)
    external getProjectReferences: this<'tags, 'base> => option<array<ProjectReference.t>> = "getProjectReferences"
    @send @return(nullable)
    external getResolvedProjectReferences: this<'tags, 'base> => option<array<undefined<ResolvedProjectReference.t>>> = "getResolvedProjectReferences"
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asScriptReferenceHost: t => ScriptReferenceHost.t = "%identity"
  }
  module ProgramHost = {
    open ProgramHost
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_ProgramHost('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_ProgramHost('T) ]
    @get
    external getCreateProgram: this<'tags, 'base, 'T> => CreateProgram.t<'T> = "createProgram"
    @set
    external setCreateProgram: (this<'tags, 'base, 'T>, CreateProgram.t<'T>) => unit = "createProgram"
    @send
    external useCaseSensitiveFileNames: this<'tags, 'base, 'T> => bool = "useCaseSensitiveFileNames"
    @send
    external getNewLine: this<'tags, 'base, 'T> => string = "getNewLine"
    @send
    external getCurrentDirectory: this<'tags, 'base, 'T> => string = "getCurrentDirectory"
    @send
    external getDefaultLibFileName: (this<'tags, 'base, 'T>, ~options:CompilerOptions.t) => string = "getDefaultLibFileName"
    @send
    external getDefaultLibLocation: this<'tags, 'base, 'T> => string = "getDefaultLibLocation"
    @send
    external createHash: (this<'tags, 'base, 'T>, ~data:string) => string = "createHash"
    @send
    external fileExists: (this<'tags, 'base, 'T>, ~path:string) => bool = "fileExists"
    @send @return(nullable)
    external readFile: (this<'tags, 'base, 'T>, ~path:string, ~encoding:string=?, unit) => option<string> = "readFile"
    @send
    external directoryExists: (this<'tags, 'base, 'T>, ~path:string) => bool = "directoryExists"
    @send
    external getDirectories: (this<'tags, 'base, 'T>, ~path:string) => array<string> = "getDirectories"
    @send
    external readDirectory: (this<'tags, 'base, 'T>, ~path:string, ~extensions:array<string>=?, ~exclude:array<string>=?, ~\"include":array<string>=?, ~depth:float=?, unit) => array<string> = "readDirectory"
    @send
    external realpath: (this<'tags, 'base, 'T>, ~path:string) => string = "realpath"
    @send
    external trace: (this<'tags, 'base, 'T>, ~s:string) => unit = "trace"
    @send @return(nullable)
    external getEnvironmentVariable: (this<'tags, 'base, 'T>, ~name:string) => option<string> = "getEnvironmentVariable"
    @send
    external resolveModuleNames: (this<'tags, 'base, 'T>, ~moduleNames:array<string>, ~containingFile:string, ~reusedNames:undefined<array<string>>, ~redirectedReference:undefined<ResolvedProjectReference.t>, ~options:CompilerOptions.t, ~containingSourceFile:SourceFile.t=?, unit) => array<undefined<ResolvedModule.t>> = "resolveModuleNames"
    @send
    external resolveTypeReferenceDirectives: (this<'tags, 'base, 'T>, ~typeReferenceDirectiveNames:array<string>, ~containingFile:string, ~redirectedReference:undefined<ResolvedProjectReference.t>, ~options:CompilerOptions.t) => array<undefined<ResolvedTypeReferenceDirective.t>> = "resolveTypeReferenceDirectives"
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
  }
  module ProjectReference = {
    open ProjectReference
    type t = t
    type t0 = t
    type tags = [#Ts_ProjectReference]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ProjectReference ]
    @get
    external getPath: this<'tags, 'base> => string = "path"
    @set
    external setPath: (this<'tags, 'base>, string) => unit = "path"
    @get
    external getOriginalPath: this<'tags, 'base> => string = "originalPath"
    @set
    external setOriginalPath: (this<'tags, 'base>, string) => unit = "originalPath"
    @get
    external getPrepend: this<'tags, 'base> => bool = "prepend"
    @set
    external setPrepend: (this<'tags, 'base>, bool) => unit = "prepend"
    @get
    external getCircular: this<'tags, 'base> => bool = "circular"
    @set
    external setCircular: (this<'tags, 'base>, bool) => unit = "circular"
    @obj
    external make: (~path: string, ~originalPath: string, ~prepend: bool, ~circular: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module PropertyAccessChain = {
    open PropertyAccessChain
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyAccessChain | #Ts_PropertyAccessExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PropertyAccessChain ]
    @get
    external get_optionalChainBrand: this<'tags, 'base> => any = "_optionalChainBrand"
    @set
    external set_optionalChainBrand: (this<'tags, 'base>, any) => unit = "_optionalChainBrand"
    @get
    external name: this<'tags, 'base> => MemberName.t = "name"
    @obj
    external make: (~\"_optionalChainBrand": any, ~name: MemberName.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPropertyAccessExpression: t => PropertyAccessExpression.t = "%identity"
  }
  module PropertyAccessEntityNameExpression = {
    open PropertyAccessEntityNameExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyAccessEntityNameExpression | #Ts_PropertyAccessExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PropertyAccessEntityNameExpression ]
    @get
    external get_propertyAccessExpressionLikeQualifiedNameBrand: this<'tags, 'base> => any = "_propertyAccessExpressionLikeQualifiedNameBrand"
    @set
    external set_propertyAccessExpressionLikeQualifiedNameBrand: (this<'tags, 'base>, any) => unit = "_propertyAccessExpressionLikeQualifiedNameBrand"
    @get
    external expression: this<'tags, 'base> => EntityNameExpression.t = "expression"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @obj
    external make: (~\"_propertyAccessExpressionLikeQualifiedNameBrand": any, ~expression: EntityNameExpression.t, ~name: Identifier.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPropertyAccessExpression: t => PropertyAccessExpression.t = "%identity"
  }
  module PropertyAccessExpression = {
    open PropertyAccessExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyAccessExpression | #Ts_ReadonlyTextRange | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PropertyAccessExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.PropertyAccessExpression.t = "kind"
    @get
    external expression: this<'tags, 'base> => LeftHandSideExpression.t = "expression"
    @get
    external questionDotToken: this<'tags, 'base> => QuestionDotToken.t = "questionDotToken"
    @get
    external name: this<'tags, 'base> => MemberName.t = "name"
    @obj
    external make: (~kind: SyntaxKind.PropertyAccessExpression.t, ~expression: LeftHandSideExpression.t, ~questionDotToken: QuestionDotToken.t, ~name: MemberName.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asMemberExpression: t => MemberExpression.t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
  }
  module PropertyAssignment = {
    open PropertyAssignment
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_PropertyAssignment | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PropertyAssignment ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.PropertyAssignment.t = "kind"
    @get
    external parent: this<'tags, 'base> => ObjectLiteralExpression.t = "parent"
    @get
    external name: this<'tags, 'base> => PropertyName.t = "name"
    @get
    external questionToken: this<'tags, 'base> => QuestionToken.t = "questionToken"
    @get
    external exclamationToken: this<'tags, 'base> => ExclamationToken.t = "exclamationToken"
    @get
    external initializer: this<'tags, 'base> => Expression.t = "initializer"
    @obj
    external make: (~kind: SyntaxKind.PropertyAssignment.t, ~parent: ObjectLiteralExpression.t, ~name: PropertyName.t, ~questionToken: QuestionToken.t, ~exclamationToken: ExclamationToken.t, ~initializer: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asObjectLiteralElement: t => ObjectLiteralElement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module PropertyDeclaration = {
    open PropertyDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_ClassElement | #Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyDeclaration | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PropertyDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.PropertyDeclaration.t = "kind"
    @get
    external parent: this<'tags, 'base> => ClassLikeDeclaration.t = "parent"
    @get
    external name: this<'tags, 'base> => PropertyName.t = "name"
    @get
    external questionToken: this<'tags, 'base> => QuestionToken.t = "questionToken"
    @get
    external exclamationToken: this<'tags, 'base> => ExclamationToken.t = "exclamationToken"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @get
    external initializer: this<'tags, 'base> => Expression.t = "initializer"
    @obj
    external make: (~kind: SyntaxKind.PropertyDeclaration.t, ~parent: ClassLikeDeclaration.t, ~name: PropertyName.t, ~questionToken: QuestionToken.t, ~exclamationToken: ExclamationToken.t, ~\"type": TypeNode.t, ~initializer: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asClassElement: t => ClassElement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module PropertyLikeDeclaration = {
    open PropertyLikeDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyLikeDeclaration | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PropertyLikeDeclaration ]
    @get
    external name: this<'tags, 'base> => PropertyName.t = "name"
    @obj
    external make: ~name: PropertyName.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
  }
  module PropertyName = {
    open PropertyName
    type t = Union.t5<Identifier.t, StringLiteral.t, NumericLiteral.t, ComputedPropertyName.t, PrivateIdentifier.t>
    type t0 = t
  }
  module PropertyNameLiteral = {
    open PropertyNameLiteral
    type t = Union.t3<Identifier.t, StringLiteralLike.t, NumericLiteral.t>
    type t0 = t
  }
  module PropertySignature = {
    open PropertySignature
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertySignature | #Ts_ReadonlyTextRange | #Ts_TypeElement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PropertySignature ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.PropertySignature.t = "kind"
    @get
    external name: this<'tags, 'base> => PropertyName.t = "name"
    @get
    external questionToken: this<'tags, 'base> => QuestionToken.t = "questionToken"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @get
    external getInitializer: this<'tags, 'base> => Expression.t = "initializer"
    @set
    external setInitializer: (this<'tags, 'base>, Expression.t) => unit = "initializer"
    @obj
    external make: (~kind: SyntaxKind.PropertySignature.t, ~name: PropertyName.t, ~questionToken: QuestionToken.t, ~\"type": TypeNode.t, ~initializer: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeElement: t => TypeElement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module ProtectedKeyword = {
    open ProtectedKeyword
    type t = ModifierToken.t<SyntaxKind.ProtectedKeyword.t>
    type t0 = t
  }
  module PseudoBigInt = {
    open PseudoBigInt
    type t = t
    type t0 = t
    type tags = [#Ts_PseudoBigInt]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_PseudoBigInt ]
    @get
    external getNegative: this<'tags, 'base> => bool = "negative"
    @set
    external setNegative: (this<'tags, 'base>, bool) => unit = "negative"
    @get
    external getBase10Value: this<'tags, 'base> => string = "base10Value"
    @set
    external setBase10Value: (this<'tags, 'base>, string) => unit = "base10Value"
    @obj
    external make: (~negative: bool, ~base10Value: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module PseudoLiteralSyntaxKind = {
    open PseudoLiteralSyntaxKind
    type t = Union.t3<SyntaxKind.TemplateHead.t, SyntaxKind.TemplateMiddle.t, SyntaxKind.TemplateTail.t>
    type t0 = t
  }
  module PseudoLiteralToken = {
    open PseudoLiteralToken
    type t = Union.t3<TemplateHead.t, TemplateMiddle.t, TemplateTail.t>
    type t0 = t
  }
  module PublicKeyword = {
    open PublicKeyword
    type t = ModifierToken.t<SyntaxKind.PublicKeyword.t>
    type t0 = t
  }
  module PunctuationSyntaxKind = {
    open PunctuationSyntaxKind
    type t = Union.t8<SyntaxKind.OpenBraceToken.t, SyntaxKind.CloseBraceToken.t, SyntaxKind.OpenParenToken.t, SyntaxKind.CloseParenToken.t, SyntaxKind.OpenBracketToken.t, SyntaxKind.CloseBracketToken.t, SyntaxKind.DotToken.t, Union.t8<SyntaxKind.DotDotDotToken.t, SyntaxKind.SemicolonToken.t, SyntaxKind.CommaToken.t, SyntaxKind.QuestionDotToken.t, SyntaxKind.LessThanToken.t, SyntaxKind.LessThanSlashToken.t, SyntaxKind.GreaterThanToken.t, Union.t8<SyntaxKind.LessThanEqualsToken.t, SyntaxKind.GreaterThanEqualsToken.t, SyntaxKind.EqualsEqualsToken.t, SyntaxKind.ExclamationEqualsToken.t, SyntaxKind.EqualsEqualsEqualsToken.t, SyntaxKind.ExclamationEqualsEqualsToken.t, SyntaxKind.EqualsGreaterThanToken.t, Union.t8<SyntaxKind.PlusToken.t, SyntaxKind.MinusToken.t, SyntaxKind.AsteriskToken.t, SyntaxKind.AsteriskAsteriskToken.t, SyntaxKind.SlashToken.t, SyntaxKind.PercentToken.t, SyntaxKind.PlusPlusToken.t, Union.t8<SyntaxKind.MinusMinusToken.t, SyntaxKind.LessThanLessThanToken.t, SyntaxKind.GreaterThanGreaterThanToken.t, SyntaxKind.GreaterThanGreaterThanGreaterThanToken.t, SyntaxKind.AmpersandToken.t, SyntaxKind.BarToken.t, SyntaxKind.CaretToken.t, Union.t8<SyntaxKind.ExclamationToken.t, SyntaxKind.TildeToken.t, SyntaxKind.AmpersandAmpersandToken.t, SyntaxKind.BarBarToken.t, SyntaxKind.QuestionQuestionToken.t, SyntaxKind.QuestionToken.t, SyntaxKind.ColonToken.t, Union.t8<SyntaxKind.AtToken.t, SyntaxKind.BacktickToken.t, SyntaxKind.HashToken.t, SyntaxKind.EqualsToken.t, SyntaxKind.PlusEqualsToken.t, SyntaxKind.MinusEqualsToken.t, SyntaxKind.AsteriskEqualsToken.t, Union.t8<SyntaxKind.AsteriskAsteriskEqualsToken.t, SyntaxKind.SlashEqualsToken.t, SyntaxKind.PercentEqualsToken.t, SyntaxKind.LessThanLessThanEqualsToken.t, SyntaxKind.GreaterThanGreaterThanEqualsToken.t, SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken.t, SyntaxKind.AmpersandEqualsToken.t, Union.t2<SyntaxKind.BarEqualsToken.t, SyntaxKind.CaretEqualsToken.t>>>>>>>>>
    type t0 = t
  }
  module PunctuationToken = {
    open PunctuationToken
    type t<'TKind> = t<'TKind>
    type t1<'TKind> = t<'TKind>
    type tags<'TKind> = [#Ts_PunctuationToken('TKind) | #Ts_Token('TKind) | #Ts_Node | #Ts_ReadonlyTextRange]
    type tags1<'TKind> = tags<'TKind>
    type this<'tags, 'base, 'TKind> = intf<'tags, 'base> constraint 'tags = [> #Ts_PunctuationToken('TKind) ]
    external castFrom: this<'tags, 'base, 'TKind> => t<'TKind> = "%identity"
    external asToken: t<'TKind> => Token.t<'TKind> = "%identity"
  }
  module Push = {
    open Push
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_Push('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_Push('T) ]
    @send @variadic
    external push: (this<'tags, 'base, 'T>, ~values:array<'T>) => unit = "push"
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
  }
  module QualifiedName = {
    open QualifiedName
    type t = t
    type t0 = t
    type tags = [#Ts_Node | #Ts_QualifiedName | #Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_QualifiedName ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.QualifiedName.t = "kind"
    @get
    external left: this<'tags, 'base> => EntityName.t = "left"
    @get
    external right: this<'tags, 'base> => Identifier.t = "right"
    @obj
    external make: (~kind: SyntaxKind.QualifiedName.t, ~left: EntityName.t, ~right: Identifier.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
  }
  module QuestionDotToken = {
    open QuestionDotToken
    type t = PunctuationToken.t<SyntaxKind.QuestionDotToken.t>
    type t0 = t
  }
  module QuestionToken = {
    open QuestionToken
    type t = PunctuationToken.t<SyntaxKind.QuestionToken.t>
    type t0 = t
  }
  module QuickInfo = {
    open QuickInfo
    type t = t
    type t0 = t
    type tags = [#Ts_QuickInfo]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_QuickInfo ]
    @get
    external getKind: this<'tags, 'base> => ScriptElementKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, ScriptElementKind.t) => unit = "kind"
    @get
    external getKindModifiers: this<'tags, 'base> => string = "kindModifiers"
    @set
    external setKindModifiers: (this<'tags, 'base>, string) => unit = "kindModifiers"
    @get
    external getTextSpan: this<'tags, 'base> => TextSpan.t = "textSpan"
    @set
    external setTextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "textSpan"
    @get
    external getDisplayParts: this<'tags, 'base> => array<SymbolDisplayPart.t> = "displayParts"
    @set
    external setDisplayParts: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "displayParts"
    @get
    external getDocumentation: this<'tags, 'base> => array<SymbolDisplayPart.t> = "documentation"
    @set
    external setDocumentation: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "documentation"
    @get
    external getTags: this<'tags, 'base> => array<JSDocTagInfo.t> = "tags"
    @set
    external setTags: (this<'tags, 'base>, array<JSDocTagInfo.t>) => unit = "tags"
    @obj
    external make: (~kind: ScriptElementKind.t, ~kindModifiers: string, ~textSpan: TextSpan.t, ~displayParts: array<SymbolDisplayPart.t>, ~documentation: array<SymbolDisplayPart.t>, ~tags: array<JSDocTagInfo.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ReadBuildProgramHost = {
    open ReadBuildProgramHost
    type t = t
    type t0 = t
    type tags = [#Ts_ReadBuildProgramHost]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ReadBuildProgramHost ]
    @send
    external useCaseSensitiveFileNames: this<'tags, 'base> => bool = "useCaseSensitiveFileNames"
    @send
    external getCurrentDirectory: this<'tags, 'base> => string = "getCurrentDirectory"
    @send @return(nullable)
    external readFile: (this<'tags, 'base>, ~fileName:string) => option<string> = "readFile"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ReadonlyCollection = {
    open ReadonlyCollection
    type t<'K> = t<'K>
    type t1<'K> = t<'K>
    type tags<'K> = [#Ts_ReadonlyCollection('K)]
    type tags1<'K> = tags<'K>
    type this<'tags, 'base, 'K> = intf<'tags, 'base> constraint 'tags = [> #Ts_ReadonlyCollection('K) ]
    @get
    external size: this<'tags, 'base, 'K> => float = "size"
    @send
    external has: (this<'tags, 'base, 'K>, ~key:'K) => bool = "has"
    @send
    external keys: this<'tags, 'base, 'K> => Iterator.t<'K> = "keys"
    external castFrom: this<'tags, 'base, 'K> => t<'K> = "%identity"
  }
  module ReadonlyESMap = {
    open ReadonlyESMap
    type t<'K, 'V> = t<'K, 'V>
    type t2<'K, 'V> = t<'K, 'V>
    type tags<'K, 'V> = [#Ts_ReadonlyCollection('K) | #Ts_ReadonlyESMap('K, 'V)]
    type tags2<'K, 'V> = tags<'K, 'V>
    type this<'tags, 'base, 'K, 'V> = intf<'tags, 'base> constraint 'tags = [> #Ts_ReadonlyESMap('K, 'V) ]
    @send @return(nullable)
    external get: (this<'tags, 'base, 'K, 'V>, ~key:'K) => option<'V> = "get"
    @send
    external values: this<'tags, 'base, 'K, 'V> => Iterator.t<'V> = "values"
    @send
    external entries: this<'tags, 'base, 'K, 'V> => Iterator.t<('K, 'V)> = "entries"
    @send
    external forEach: (this<'tags, 'base, 'K, 'V>, ~action:(@uncurry (~value:'V, ~key:'K) => unit)) => unit = "forEach"
    external castFrom: this<'tags, 'base, 'K, 'V> => t<'K, 'V> = "%identity"
    external asReadonlyCollection: t<'K, 'V> => ReadonlyCollection.t<'K> = "%identity"
  }
  module ReadonlyKeyword = {
    open ReadonlyKeyword
    type t = ModifierToken.t<SyntaxKind.ReadonlyKeyword.t>
    type t0 = t
  }
  module ReadonlyMap = {
    open ReadonlyMap
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_ReadonlyCollection(string) | #Ts_ReadonlyMap('T) | #Ts_ReadonlyESMap(string, 'T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_ReadonlyMap('T) ]
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asReadonlyESMap: t<'T> => ReadonlyESMap.t<string, 'T> = "%identity"
    external asReadonlyESMap': t<'T> => ReadonlyESMap.t<string, 'T> = "%identity"
  }
  module ReadonlySet = {
    open ReadonlySet
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_ReadonlyCollection('T) | #Ts_ReadonlySet('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_ReadonlySet('T) ]
    @send
    external has: (this<'tags, 'base, 'T>, ~value:'T) => bool = "has"
    @send
    external values: this<'tags, 'base, 'T> => Iterator.t<'T> = "values"
    @send
    external entries: this<'tags, 'base, 'T> => Iterator.t<('T, 'T)> = "entries"
    @send
    external forEach: (this<'tags, 'base, 'T>, ~action:(@uncurry (~value:'T, ~key:'T) => unit)) => unit = "forEach"
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asReadonlyCollection: t<'T> => ReadonlyCollection.t<'T> = "%identity"
  }
  module ReadonlyTextRange = {
    open ReadonlyTextRange
    type t = t
    type t0 = t
    type tags = [#Ts_ReadonlyTextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ReadonlyTextRange ]
    @get
    external pos: this<'tags, 'base> => float = "pos"
    @get
    external end: this<'tags, 'base> => float = "end"
    @obj
    external make: (~pos: float, ~end: float) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ReadonlyToken = {
    open ReadonlyToken
    type t = ReadonlyKeyword.t
    type t0 = t
  }
  module ReadonlyUnderscoreEscapedMap = {
    open ReadonlyUnderscoreEscapedMap
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_ReadonlyCollection(M__String.t) | #Ts_ReadonlyUnderscoreEscapedMap('T) | #Ts_ReadonlyESMap(M__String.t, 'T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_ReadonlyUnderscoreEscapedMap('T) ]
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asReadonlyESMap: t<'T> => ReadonlyESMap.t<M__String.t, 'T> = "%identity"
  }
  module RefactorActionInfo = {
    open RefactorActionInfo
    type t = t
    type t0 = t
    type tags = [#Ts_RefactorActionInfo]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_RefactorActionInfo ]
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @get
    external getDescription: this<'tags, 'base> => string = "description"
    @set
    external setDescription: (this<'tags, 'base>, string) => unit = "description"
    @get
    external getNotApplicableReason: this<'tags, 'base> => string = "notApplicableReason"
    @set
    external setNotApplicableReason: (this<'tags, 'base>, string) => unit = "notApplicableReason"
    @get
    external getKind: this<'tags, 'base> => string = "kind"
    @set
    external setKind: (this<'tags, 'base>, string) => unit = "kind"
    @obj
    external make: (~name: string, ~description: string, ~notApplicableReason: string, ~kind: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module RefactorEditInfo = {
    open RefactorEditInfo
    type t = t
    type t0 = t
    type tags = [#Ts_RefactorEditInfo]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_RefactorEditInfo ]
    @get
    external getEdits: this<'tags, 'base> => array<FileTextChanges.t> = "edits"
    @set
    external setEdits: (this<'tags, 'base>, array<FileTextChanges.t>) => unit = "edits"
    @get
    external getRenameFilename: this<'tags, 'base> => string = "renameFilename"
    @set
    external setRenameFilename: (this<'tags, 'base>, string) => unit = "renameFilename"
    @get
    external getRenameLocation: this<'tags, 'base> => float = "renameLocation"
    @set
    external setRenameLocation: (this<'tags, 'base>, float) => unit = "renameLocation"
    @get
    external getCommands: this<'tags, 'base> => array<CodeActionCommand.t> = "commands"
    @set
    external setCommands: (this<'tags, 'base>, array<CodeActionCommand.t>) => unit = "commands"
    @obj
    external make: (~edits: array<FileTextChanges.t>, ~renameFilename: string, ~renameLocation: float, ~commands: array<CodeActionCommand.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module RefactorTriggerReason = {
    open RefactorTriggerReason
    type t = Union.t2<[#implicit], [#invoked]>
    type t0 = t
  }
  module ReferenceEntry = {
    open ReferenceEntry
    type t = t
    type t0 = t
    type tags = [#Ts_DocumentSpan | #Ts_ReferenceEntry]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ReferenceEntry ]
    @get
    external getIsWriteAccess: this<'tags, 'base> => bool = "isWriteAccess"
    @set
    external setIsWriteAccess: (this<'tags, 'base>, bool) => unit = "isWriteAccess"
    @get
    external getIsDefinition: this<'tags, 'base> => bool = "isDefinition"
    @set
    external setIsDefinition: (this<'tags, 'base>, bool) => unit = "isDefinition"
    @get
    external getIsInString: this<'tags, 'base> => \"true" = "isInString"
    @set
    external setIsInString: (this<'tags, 'base>, \"true") => unit = "isInString"
    @obj
    external make: (~isWriteAccess: bool, ~isDefinition: bool, ~isInString: \"true") => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDocumentSpan: t => DocumentSpan.t = "%identity"
  }
  module ReferencedSymbol = {
    open ReferencedSymbol
    type t = t
    type t0 = t
    type tags = [#Ts_ReferencedSymbol]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ReferencedSymbol ]
    @get
    external getDefinition: this<'tags, 'base> => ReferencedSymbolDefinitionInfo.t = "definition"
    @set
    external setDefinition: (this<'tags, 'base>, ReferencedSymbolDefinitionInfo.t) => unit = "definition"
    @get
    external getReferences: this<'tags, 'base> => array<ReferenceEntry.t> = "references"
    @set
    external setReferences: (this<'tags, 'base>, array<ReferenceEntry.t>) => unit = "references"
    @obj
    external make: (~definition: ReferencedSymbolDefinitionInfo.t, ~references: array<ReferenceEntry.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ReferencedSymbolDefinitionInfo = {
    open ReferencedSymbolDefinitionInfo
    type t = t
    type t0 = t
    type tags = [#Ts_DefinitionInfo | #Ts_DocumentSpan | #Ts_ReferencedSymbolDefinitionInfo]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ReferencedSymbolDefinitionInfo ]
    @get
    external getDisplayParts: this<'tags, 'base> => array<SymbolDisplayPart.t> = "displayParts"
    @set
    external setDisplayParts: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "displayParts"
    @obj
    external make: ~displayParts: array<SymbolDisplayPart.t> => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDefinitionInfo: t => DefinitionInfo.t = "%identity"
  }
  module RegularExpressionLiteral = {
    open RegularExpressionLiteral
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_LiteralExpression | #Ts_LiteralLikeNode | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_RegularExpressionLiteral | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_RegularExpressionLiteral ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.RegularExpressionLiteral.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.RegularExpressionLiteral.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLiteralExpression: t => LiteralExpression.t = "%identity"
  }
  module RelationalOperator = {
    open RelationalOperator
    type t = Union.t6<SyntaxKind.LessThanToken.t, SyntaxKind.LessThanEqualsToken.t, SyntaxKind.GreaterThanToken.t, SyntaxKind.GreaterThanEqualsToken.t, SyntaxKind.InstanceOfKeyword.t, SyntaxKind.InKeyword.t>
    type t0 = t
  }
  module RelationalOperatorOrHigher = {
    open RelationalOperatorOrHigher
    type t = Union.t2<ShiftOperatorOrHigher.t, RelationalOperator.t>
    type t0 = t
  }
  module RenameInfo = {
    open RenameInfo
    type t = Union.t2<RenameInfoSuccess.t, RenameInfoFailure.t>
    type t0 = t
  }
  module RenameInfoFailure = {
    open RenameInfoFailure
    type t = t
    type t0 = t
    type tags = [#Ts_RenameInfoFailure]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_RenameInfoFailure ]
    @get
    external getCanRename: this<'tags, 'base> => \"false" = "canRename"
    @set
    external setCanRename: (this<'tags, 'base>, \"false") => unit = "canRename"
    @get
    external getLocalizedErrorMessage: this<'tags, 'base> => string = "localizedErrorMessage"
    @set
    external setLocalizedErrorMessage: (this<'tags, 'base>, string) => unit = "localizedErrorMessage"
    @obj
    external make: (~canRename: \"false", ~localizedErrorMessage: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module RenameInfoOptions = {
    open RenameInfoOptions
    type t = t
    type t0 = t
    type tags = [#Ts_RenameInfoOptions]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_RenameInfoOptions ]
    @get
    external allowRenameOfImportPath: this<'tags, 'base> => bool = "allowRenameOfImportPath"
    @obj
    external make: ~allowRenameOfImportPath: bool => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module RenameInfoSuccess = {
    open RenameInfoSuccess
    type t = t
    type t0 = t
    type tags = [#Ts_RenameInfoSuccess]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_RenameInfoSuccess ]
    @get
    external getCanRename: this<'tags, 'base> => \"true" = "canRename"
    @set
    external setCanRename: (this<'tags, 'base>, \"true") => unit = "canRename"
    @get
    external getFileToRename: this<'tags, 'base> => string = "fileToRename"
    @set
    external setFileToRename: (this<'tags, 'base>, string) => unit = "fileToRename"
    @get
    external getDisplayName: this<'tags, 'base> => string = "displayName"
    @set
    external setDisplayName: (this<'tags, 'base>, string) => unit = "displayName"
    @get
    external getFullDisplayName: this<'tags, 'base> => string = "fullDisplayName"
    @set
    external setFullDisplayName: (this<'tags, 'base>, string) => unit = "fullDisplayName"
    @get
    external getKind: this<'tags, 'base> => ScriptElementKind.t = "kind"
    @set
    external setKind: (this<'tags, 'base>, ScriptElementKind.t) => unit = "kind"
    @get
    external getKindModifiers: this<'tags, 'base> => string = "kindModifiers"
    @set
    external setKindModifiers: (this<'tags, 'base>, string) => unit = "kindModifiers"
    @get
    external getTriggerSpan: this<'tags, 'base> => TextSpan.t = "triggerSpan"
    @set
    external setTriggerSpan: (this<'tags, 'base>, TextSpan.t) => unit = "triggerSpan"
    @obj
    external make: (~canRename: \"true", ~fileToRename: string, ~displayName: string, ~fullDisplayName: string, ~kind: ScriptElementKind.t, ~kindModifiers: string, ~triggerSpan: TextSpan.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module RenameLocation = {
    open RenameLocation
    type t = t
    type t0 = t
    type tags = [#Ts_DocumentSpan | #Ts_RenameLocation]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_RenameLocation ]
    @get
    external prefixText: this<'tags, 'base> => string = "prefixText"
    @get
    external suffixText: this<'tags, 'base> => string = "suffixText"
    @obj
    external make: (~prefixText: string, ~suffixText: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDocumentSpan: t => DocumentSpan.t = "%identity"
  }
  module ReportEmitErrorSummary = {
    open ReportEmitErrorSummary
    type t = (~errorCount:float, ~filesInError:array<undefined<ReportFileInError.t>>) => unit
    type t0 = t
  }
  module ReportFileInError = {
    open ReportFileInError
    type t = t
    type t0 = t
    type tags = [#Ts_ReportFileInError]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ReportFileInError ]
    @get
    external getFileName: this<'tags, 'base> => string = "fileName"
    @set
    external setFileName: (this<'tags, 'base>, string) => unit = "fileName"
    @get
    external getLine: this<'tags, 'base> => float = "line"
    @set
    external setLine: (this<'tags, 'base>, float) => unit = "line"
    @obj
    external make: (~fileName: string, ~line: float) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ResolveProjectReferencePathHost = {
    open ResolveProjectReferencePathHost
    type t = t
    type t0 = t
    type tags = [#Ts_ResolveProjectReferencePathHost]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ResolveProjectReferencePathHost ]
    @send
    external fileExists: (this<'tags, 'base>, ~fileName:string) => bool = "fileExists"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ResolvedConfigFileName = {
    open ResolvedConfigFileName
    module AnonymousInterface3 = {
      open AnonymousInterface3
      type t = t
      @get
      external get_isResolvedConfigFileName: t => never = "_isResolvedConfigFileName"
      @set
      external set_isResolvedConfigFileName: (t, never) => unit = "_isResolvedConfigFileName"
      @obj
      external make: ~\"_isResolvedConfigFileName": never => t = ""
    }
    type t = Intersection.t2<string, AnonymousInterface3.t>
    type t0 = t
  }
  module ResolvedModule = {
    open ResolvedModule
    type t = t
    type t0 = t
    type tags = [#Ts_ResolvedModule]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ResolvedModule ]
    @get
    external getResolvedFileName: this<'tags, 'base> => string = "resolvedFileName"
    @set
    external setResolvedFileName: (this<'tags, 'base>, string) => unit = "resolvedFileName"
    @get
    external getIsExternalLibraryImport: this<'tags, 'base> => bool = "isExternalLibraryImport"
    @set
    external setIsExternalLibraryImport: (this<'tags, 'base>, bool) => unit = "isExternalLibraryImport"
    @obj
    external make: (~resolvedFileName: string, ~isExternalLibraryImport: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ResolvedModuleFull = {
    open ResolvedModuleFull
    type t = t
    type t0 = t
    type tags = [#Ts_ResolvedModule | #Ts_ResolvedModuleFull]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ResolvedModuleFull ]
    @get
    external getExtension: this<'tags, 'base> => Extension.t = "extension"
    @set
    external setExtension: (this<'tags, 'base>, Extension.t) => unit = "extension"
    @get
    external getPackageId: this<'tags, 'base> => PackageId.t = "packageId"
    @set
    external setPackageId: (this<'tags, 'base>, PackageId.t) => unit = "packageId"
    @obj
    external make: (~extension: Extension.t, ~packageId: PackageId.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asResolvedModule: t => ResolvedModule.t = "%identity"
  }
  module ResolvedModuleWithFailedLookupLocations = {
    open ResolvedModuleWithFailedLookupLocations
    type t = t
    type t0 = t
    type tags = [#Ts_ResolvedModuleWithFailedLookupLocations]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ResolvedModuleWithFailedLookupLocations ]
    @get @return(nullable)
    external resolvedModule: this<'tags, 'base> => option<ResolvedModuleFull.t> = "resolvedModule"
    @obj
    external make: (~resolvedModule: ResolvedModuleFull.t=?, unit) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ResolvedProjectReference = {
    open ResolvedProjectReference
    type t = t
    type t0 = t
    type tags = [#Ts_ResolvedProjectReference]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ResolvedProjectReference ]
    @get
    external getCommandLine: this<'tags, 'base> => ParsedCommandLine.t = "commandLine"
    @set
    external setCommandLine: (this<'tags, 'base>, ParsedCommandLine.t) => unit = "commandLine"
    @get
    external getSourceFile: this<'tags, 'base> => SourceFile.t = "sourceFile"
    @set
    external setSourceFile: (this<'tags, 'base>, SourceFile.t) => unit = "sourceFile"
    @get
    external getReferences: this<'tags, 'base> => array<undefined<t>> = "references"
    @set
    external setReferences: (this<'tags, 'base>, array<undefined<t>>) => unit = "references"
    @obj
    external make: (~commandLine: ParsedCommandLine.t, ~sourceFile: SourceFile.t, ~references: array<undefined<t>>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ResolvedTypeReferenceDirective = {
    open ResolvedTypeReferenceDirective
    type t = t
    type t0 = t
    type tags = [#Ts_ResolvedTypeReferenceDirective]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ResolvedTypeReferenceDirective ]
    @get
    external getPrimary: this<'tags, 'base> => bool = "primary"
    @set
    external setPrimary: (this<'tags, 'base>, bool) => unit = "primary"
    @get @return(nullable)
    external getResolvedFileName: this<'tags, 'base> => option<string> = "resolvedFileName"
    @set
    external setResolvedFileName: (this<'tags, 'base>, undefined<string>) => unit = "resolvedFileName"
    @get
    external getPackageId: this<'tags, 'base> => PackageId.t = "packageId"
    @set
    external setPackageId: (this<'tags, 'base>, PackageId.t) => unit = "packageId"
    @get
    external getIsExternalLibraryImport: this<'tags, 'base> => bool = "isExternalLibraryImport"
    @set
    external setIsExternalLibraryImport: (this<'tags, 'base>, bool) => unit = "isExternalLibraryImport"
    @obj
    external make: (~primary: bool, ~resolvedFileName: string=?, ~packageId: PackageId.t, ~isExternalLibraryImport: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ResolvedTypeReferenceDirectiveWithFailedLookupLocations = {
    open ResolvedTypeReferenceDirectiveWithFailedLookupLocations
    type t = t
    type t0 = t
    type tags = [#Ts_ResolvedTypeReferenceDirectiveWithFailedLookupLocations]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ResolvedTypeReferenceDirectiveWithFailedLookupLocations ]
    @get @return(nullable)
    external resolvedTypeReferenceDirective: this<'tags, 'base> => option<ResolvedTypeReferenceDirective.t> = "resolvedTypeReferenceDirective"
    @get
    external failedLookupLocations: this<'tags, 'base> => array<string> = "failedLookupLocations"
    @obj
    external make: (~resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective.t=?, ~failedLookupLocations: array<string>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module RestTypeNode = {
    open RestTypeNode
    type t = t
    type t0 = t
    type tags = [#Ts_Node | #Ts_ReadonlyTextRange | #Ts_RestTypeNode | #Ts_TypeNode]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_RestTypeNode ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.RestType.t = "kind"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: SyntaxKind.RestType.t, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTypeNode: t => TypeNode.t = "%identity"
  }
  module ReturnStatement = {
    open ReturnStatement
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_ReturnStatement | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ReturnStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ReturnStatement.t = "kind"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.ReturnStatement.t, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module Scanner = {
    open Scanner
    type t = t
    type t0 = t
    type tags = [#Ts_Scanner]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Scanner ]
    @send
    external getStartPos: this<'tags, 'base> => float = "getStartPos"
    @send
    external getToken: this<'tags, 'base> => SyntaxKind.t = "getToken"
    @send
    external getTextPos: this<'tags, 'base> => float = "getTextPos"
    @send
    external getTokenPos: this<'tags, 'base> => float = "getTokenPos"
    @send
    external getTokenText: this<'tags, 'base> => string = "getTokenText"
    @send
    external getTokenValue: this<'tags, 'base> => string = "getTokenValue"
    @send
    external hasUnicodeEscape: this<'tags, 'base> => bool = "hasUnicodeEscape"
    @send
    external hasExtendedUnicodeEscape: this<'tags, 'base> => bool = "hasExtendedUnicodeEscape"
    @send
    external hasPrecedingLineBreak: this<'tags, 'base> => bool = "hasPrecedingLineBreak"
    @send
    external isIdentifier: this<'tags, 'base> => bool = "isIdentifier"
    @send
    external isReservedWord: this<'tags, 'base> => bool = "isReservedWord"
    @send
    external isUnterminated: this<'tags, 'base> => bool = "isUnterminated"
    @send
    external reScanGreaterToken: this<'tags, 'base> => SyntaxKind.t = "reScanGreaterToken"
    @send
    external reScanSlashToken: this<'tags, 'base> => SyntaxKind.t = "reScanSlashToken"
    @send
    external reScanAsteriskEqualsToken: this<'tags, 'base> => SyntaxKind.t = "reScanAsteriskEqualsToken"
    @send
    external reScanTemplateToken: (this<'tags, 'base>, ~isTaggedTemplate:bool) => SyntaxKind.t = "reScanTemplateToken"
    @send
    external reScanTemplateHeadOrNoSubstitutionTemplate: this<'tags, 'base> => SyntaxKind.t = "reScanTemplateHeadOrNoSubstitutionTemplate"
    @send
    external scanJsxIdentifier: this<'tags, 'base> => SyntaxKind.t = "scanJsxIdentifier"
    @send
    external scanJsxAttributeValue: this<'tags, 'base> => SyntaxKind.t = "scanJsxAttributeValue"
    @send
    external reScanJsxAttributeValue: this<'tags, 'base> => SyntaxKind.t = "reScanJsxAttributeValue"
    @send
    external reScanJsxToken: (this<'tags, 'base>, ~allowMultilineJsxText:bool=?, unit) => JsxTokenSyntaxKind.t = "reScanJsxToken"
    @send
    external reScanLessThanToken: this<'tags, 'base> => SyntaxKind.t = "reScanLessThanToken"
    @send
    external reScanHashToken: this<'tags, 'base> => SyntaxKind.t = "reScanHashToken"
    @send
    external reScanQuestionToken: this<'tags, 'base> => SyntaxKind.t = "reScanQuestionToken"
    @send
    external reScanInvalidIdentifier: this<'tags, 'base> => SyntaxKind.t = "reScanInvalidIdentifier"
    @send
    external scanJsxToken: this<'tags, 'base> => JsxTokenSyntaxKind.t = "scanJsxToken"
    @send
    external scanJsDocToken: this<'tags, 'base> => JSDocSyntaxKind.t = "scanJsDocToken"
    @send
    external scan: this<'tags, 'base> => SyntaxKind.t = "scan"
    @send
    external getText: this<'tags, 'base> => string = "getText"
    @send
    external setText: (this<'tags, 'base>, ~text:undefined<string>, ~start:float=?, ~length:float=?, unit) => unit = "setText"
    @send
    external setOnError: (this<'tags, 'base>, ~onError:undefined<ErrorCallback.t>) => unit = "setOnError"
    @send
    external setScriptTarget: (this<'tags, 'base>, ~scriptTarget:ScriptTarget.t) => unit = "setScriptTarget"
    @send
    external setLanguageVariant: (this<'tags, 'base>, ~variant:LanguageVariant.t) => unit = "setLanguageVariant"
    @send
    external setTextPos: (this<'tags, 'base>, ~textPos:float) => unit = "setTextPos"
    @send
    external lookAhead: (this<'tags, 'base>, ~callback:(@uncurry () => 'T)) => 'T = "lookAhead"
    @send
    external scanRange: (this<'tags, 'base>, ~start:float, ~length:float, ~callback:(@uncurry () => 'T)) => 'T = "scanRange"
    @send
    external tryScan: (this<'tags, 'base>, ~callback:(@uncurry () => 'T)) => 'T = "tryScan"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ScopedEmitHelper = {
    open ScopedEmitHelper
    type t = t
    type t0 = t
    type tags = [#Ts_EmitHelperBase | #Ts_ScopedEmitHelper]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ScopedEmitHelper ]
    @get
    external scoped: this<'tags, 'base> => \"true" = "scoped"
    @obj
    external make: ~scoped: \"true" => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asEmitHelperBase: t => EmitHelperBase.t = "%identity"
  }
  module ScriptElementKind = {
    open ScriptElementKind
    type t = t
    type t_0 = t
    module Unknown = {
      open Unknown
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "unknown"
    }
    module Warning = {
      open Warning
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "warning"
    }
    module Keyword = {
      open Keyword
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "keyword"
    }
    module ScriptElement = {
      open ScriptElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "scriptElement"
    }
    module ModuleElement = {
      open ModuleElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "moduleElement"
    }
    module ClassElement = {
      open ClassElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "classElement"
    }
    module LocalClassElement = {
      open LocalClassElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "localClassElement"
    }
    module InterfaceElement = {
      open InterfaceElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "interfaceElement"
    }
    module TypeElement = {
      open TypeElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "typeElement"
    }
    module EnumElement = {
      open EnumElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "enumElement"
    }
    module EnumMemberElement = {
      open EnumMemberElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "enumMemberElement"
    }
    module VariableElement = {
      open VariableElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "variableElement"
    }
    module LocalVariableElement = {
      open LocalVariableElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "localVariableElement"
    }
    module FunctionElement = {
      open FunctionElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "functionElement"
    }
    module LocalFunctionElement = {
      open LocalFunctionElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "localFunctionElement"
    }
    module MemberFunctionElement = {
      open MemberFunctionElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "memberFunctionElement"
    }
    module MemberGetAccessorElement = {
      open MemberGetAccessorElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "memberGetAccessorElement"
    }
    module MemberSetAccessorElement = {
      open MemberSetAccessorElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "memberSetAccessorElement"
    }
    module MemberVariableElement = {
      open MemberVariableElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "memberVariableElement"
    }
    module ConstructorImplementationElement = {
      open ConstructorImplementationElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "constructorImplementationElement"
    }
    module CallSignatureElement = {
      open CallSignatureElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "callSignatureElement"
    }
    module IndexSignatureElement = {
      open IndexSignatureElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "indexSignatureElement"
    }
    module ConstructSignatureElement = {
      open ConstructSignatureElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "constructSignatureElement"
    }
    module ParameterElement = {
      open ParameterElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "parameterElement"
    }
    module TypeParameterElement = {
      open TypeParameterElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "typeParameterElement"
    }
    module PrimitiveType = {
      open PrimitiveType
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "primitiveType"
    }
    module Label = {
      open Label
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "label"
    }
    module Alias = {
      open Alias
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "alias"
    }
    module ConstElement = {
      open ConstElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "constElement"
    }
    module LetElement = {
      open LetElement
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "letElement"
    }
    module Directory = {
      open Directory
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "directory"
    }
    module ExternalModuleName = {
      open ExternalModuleName
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "externalModuleName"
    }
    module JsxAttribute = {
      open JsxAttribute
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "jsxAttribute"
    }
    module String = {
      open String
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "string"
    }
    module Link = {
      open Link
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "link"
    }
    module LinkName = {
      open LinkName
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "linkName"
    }
    module LinkText = {
      open LinkText
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKind") @val
      external value: t = "linkText"
    }
  }
  module ScriptElementKindModifier = {
    open ScriptElementKindModifier
    type t = t
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "none"
    }
    module PublicMemberModifier = {
      open PublicMemberModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "publicMemberModifier"
    }
    module PrivateMemberModifier = {
      open PrivateMemberModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "privateMemberModifier"
    }
    module ProtectedMemberModifier = {
      open ProtectedMemberModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "protectedMemberModifier"
    }
    module ExportedModifier = {
      open ExportedModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "exportedModifier"
    }
    module AmbientModifier = {
      open AmbientModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "ambientModifier"
    }
    module StaticModifier = {
      open StaticModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "staticModifier"
    }
    module AbstractModifier = {
      open AbstractModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "abstractModifier"
    }
    module OptionalModifier = {
      open OptionalModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "optionalModifier"
    }
    module DeprecatedModifier = {
      open DeprecatedModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "deprecatedModifier"
    }
    module DtsModifier = {
      open DtsModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "dtsModifier"
    }
    module TsModifier = {
      open TsModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "tsModifier"
    }
    module TsxModifier = {
      open TsxModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "tsxModifier"
    }
    module JsModifier = {
      open JsModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "jsModifier"
    }
    module JsxModifier = {
      open JsxModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "jsxModifier"
    }
    module JsonModifier = {
      open JsonModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "jsonModifier"
    }
    module DmtsModifier = {
      open DmtsModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "dmtsModifier"
    }
    module MtsModifier = {
      open MtsModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "mtsModifier"
    }
    module MjsModifier = {
      open MjsModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "mjsModifier"
    }
    module DctsModifier = {
      open DctsModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "dctsModifier"
    }
    module CtsModifier = {
      open CtsModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "ctsModifier"
    }
    module CjsModifier = {
      open CjsModifier
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptElementKindModifier") @val
      external value: t = "cjsModifier"
    }
  }
  module ScriptKind = {
    open ScriptKind
    type t = t = Unknown | JS | JSX | TS | TSX | External | JSON | Deferred
    type t_0 = t
    module Unknown = {
      open Unknown
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptKind") @val
      external value: t = "Unknown"
    }
    module JS = {
      open JS
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptKind") @val
      external value: t = "JS"
    }
    module JSX = {
      open JSX
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptKind") @val
      external value: t = "JSX"
    }
    module TS = {
      open TS
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptKind") @val
      external value: t = "TS"
    }
    module TSX = {
      open TSX
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptKind") @val
      external value: t = "TSX"
    }
    module External = {
      open External
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptKind") @val
      external value: t = "External"
    }
    module JSON = {
      open JSON
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptKind") @val
      external value: t = "JSON"
    }
    module Deferred = {
      open Deferred
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptKind") @val
      external value: t = "Deferred"
    }
  }
  module ScriptReferenceHost = {
    open ScriptReferenceHost
    type t = t
    type t0 = t
    type tags = [#Ts_ScriptReferenceHost]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ScriptReferenceHost ]
    @send
    external getCompilerOptions: this<'tags, 'base> => CompilerOptions.t = "getCompilerOptions"
    @send @return(nullable)
    external getSourceFile: (this<'tags, 'base>, ~fileName:string) => option<SourceFile.t> = "getSourceFile"
    @send @return(nullable)
    external getSourceFileByPath: (this<'tags, 'base>, ~path:Path.t) => option<SourceFile.t> = "getSourceFileByPath"
    @send
    external getCurrentDirectory: this<'tags, 'base> => string = "getCurrentDirectory"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module ScriptSnapshot = {
    @module("typescript") @scope("ScriptSnapshot") @val
    external fromString: string => IScriptSnapshot.t = "fromString"
  }
  module ScriptTarget = {
    open ScriptTarget
    type t = t
    type t_0 = t
    module ES3 = {
      open ES3
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "ES3"
    }
    module ES5 = {
      open ES5
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "ES5"
    }
    module ES2015 = {
      open ES2015
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "ES2015"
    }
    module ES2016 = {
      open ES2016
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "ES2016"
    }
    module ES2017 = {
      open ES2017
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "ES2017"
    }
    module ES2018 = {
      open ES2018
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "ES2018"
    }
    module ES2019 = {
      open ES2019
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "ES2019"
    }
    module ES2020 = {
      open ES2020
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "ES2020"
    }
    module ES2021 = {
      open ES2021
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "ES2021"
    }
    module ES2022 = {
      open ES2022
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "ES2022"
    }
    module ESNext = {
      open ESNext
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "ESNext"
    }
    module JSON = {
      open JSON
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "JSON"
    }
    module Latest = {
      open Latest
      type t = t
      type t0 = t
      @module("typescript") @scope("ScriptTarget") @val
      external value: t = "Latest"
    }
  }
  module SelectionRange = {
    open SelectionRange
    type t = t
    type t0 = t
    type tags = [#Ts_SelectionRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SelectionRange ]
    @get
    external getTextSpan: this<'tags, 'base> => TextSpan.t = "textSpan"
    @set
    external setTextSpan: (this<'tags, 'base>, TextSpan.t) => unit = "textSpan"
    @get
    external getParent: this<'tags, 'base> => t = "parent"
    @set
    external setParent: (this<'tags, 'base>, t) => unit = "parent"
    @obj
    external make: (~textSpan: TextSpan.t, ~parent: t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SemanticClassificationFormat = {
    open SemanticClassificationFormat
    type t = t
    type t_0 = t
    module Original = {
      open Original
      type t = t
      type t0 = t
      @module("typescript") @scope("SemanticClassificationFormat") @val
      external value: t = "Original"
    }
    module TwentyTwenty = {
      open TwentyTwenty
      type t = t
      type t0 = t
      @module("typescript") @scope("SemanticClassificationFormat") @val
      external value: t = "TwentyTwenty"
    }
  }
  module SemanticDiagnosticsBuilderProgram = {
    open SemanticDiagnosticsBuilderProgram
    type t = t
    type t0 = t
    type tags = [#Ts_BuilderProgram | #Ts_SemanticDiagnosticsBuilderProgram]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SemanticDiagnosticsBuilderProgram ]
    @send
    external getSemanticDiagnosticsOfNextAffectedFile: (this<'tags, 'base>, ~cancellationToken:CancellationToken.t=?, ~ignoreSourceFile:(@uncurry SourceFile.t => bool)=?, unit) => AffectedFileResult.t<array<Diagnostic.t>> = "getSemanticDiagnosticsOfNextAffectedFile"
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asBuilderProgram: t => BuilderProgram.t = "%identity"
  }
  module SemicolonClassElement = {
    open SemicolonClassElement
    type t = t
    type t0 = t
    type tags = [#Ts_ClassElement | #Ts_Declaration | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SemicolonClassElement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SemicolonClassElement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.SemicolonClassElement.t = "kind"
    @get
    external parent: this<'tags, 'base> => ClassLikeDeclaration.t = "parent"
    @obj
    external make: (~kind: SyntaxKind.SemicolonClassElement.t, ~parent: ClassLikeDeclaration.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asClassElement: t => ClassElement.t = "%identity"
  }
  module SemicolonPreference = {
    open SemicolonPreference
    type t = t
    type t_0 = t
    module Ignore = {
      open Ignore
      type t = t
      type t0 = t
      @module("typescript") @scope("SemicolonPreference") @val
      external value: t = "Ignore"
    }
    module Insert = {
      open Insert
      type t = t
      type t0 = t
      @module("typescript") @scope("SemicolonPreference") @val
      external value: t = "Insert"
    }
    module Remove = {
      open Remove
      type t = t
      type t0 = t
      @module("typescript") @scope("SemicolonPreference") @val
      external value: t = "Remove"
    }
  }
  module Set = {
    open Set
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_Collection('T) | #Ts_ReadonlyCollection('T) | #Ts_ReadonlySet('T) | #Ts_Set('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_Set('T) ]
    @send
    external add: (this<'tags, 'base, 'T>, ~value:'T) => this<'tags, 'base, 'T> = "add"
    @send
    external delete: (this<'tags, 'base, 'T>, ~value:'T) => bool = "delete"
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asReadonlySet: t<'T> => ReadonlySet.t<'T> = "%identity"
    external asCollection: t<'T> => Collection.t<'T> = "%identity"
  }
  module SetAccessorDeclaration = {
    open SetAccessorDeclaration
    type t = t
    type t0 = t
    type tags = [#Ts_ClassElement | #Ts_Declaration | #Ts_FunctionLikeDeclarationBase | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange | #Ts_SetAccessorDeclaration | #Ts_SignatureDeclarationBase | #Ts_TypeElement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SetAccessorDeclaration ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.SetAccessor.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t4<ClassLikeDeclaration.t, ObjectLiteralExpression.t, TypeLiteralNode.t, InterfaceDeclaration.t> = "parent"
    @get
    external name: this<'tags, 'base> => PropertyName.t = "name"
    @get
    external body: this<'tags, 'base> => FunctionBody.t = "body"
    @obj
    external make: (~kind: SyntaxKind.SetAccessor.t, ~parent: Union.t4<ClassLikeDeclaration.t, ObjectLiteralExpression.t, TypeLiteralNode.t, InterfaceDeclaration.t>, ~name: PropertyName.t, ~body: FunctionBody.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asFunctionLikeDeclarationBase: t => FunctionLikeDeclarationBase.t = "%identity"
    external asClassElement: t => ClassElement.t = "%identity"
    external asTypeElement: t => TypeElement.t = "%identity"
    external asObjectLiteralElement: t => ObjectLiteralElement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module ShiftOperator = {
    open ShiftOperator
    type t = Union.t3<SyntaxKind.LessThanLessThanToken.t, SyntaxKind.GreaterThanGreaterThanToken.t, SyntaxKind.GreaterThanGreaterThanGreaterThanToken.t>
    type t0 = t
  }
  module ShiftOperatorOrHigher = {
    open ShiftOperatorOrHigher
    type t = Union.t2<AdditiveOperatorOrHigher.t, ShiftOperator.t>
    type t0 = t
  }
  module ShorthandPropertyAssignment = {
    open ShorthandPropertyAssignment
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange | #Ts_ShorthandPropertyAssignment]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_ShorthandPropertyAssignment ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.ShorthandPropertyAssignment.t = "kind"
    @get
    external parent: this<'tags, 'base> => ObjectLiteralExpression.t = "parent"
    @get
    external name: this<'tags, 'base> => Identifier.t = "name"
    @get
    external questionToken: this<'tags, 'base> => QuestionToken.t = "questionToken"
    @get
    external exclamationToken: this<'tags, 'base> => ExclamationToken.t = "exclamationToken"
    @get
    external equalsToken: this<'tags, 'base> => EqualsToken.t = "equalsToken"
    @get
    external objectAssignmentInitializer: this<'tags, 'base> => Expression.t = "objectAssignmentInitializer"
    @obj
    external make: (~kind: SyntaxKind.ShorthandPropertyAssignment.t, ~parent: ObjectLiteralExpression.t, ~name: Identifier.t, ~questionToken: QuestionToken.t, ~exclamationToken: ExclamationToken.t, ~equalsToken: EqualsToken.t, ~objectAssignmentInitializer: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asObjectLiteralElement: t => ObjectLiteralElement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module Signature = {
    open Signature
    type t = t
    type t0 = t
    type tags = [#Ts_Signature]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Signature ]
    @send
    external getDeclaration: this<'tags, 'base> => SignatureDeclaration.t = "getDeclaration"
    @send @return(nullable)
    external getTypeParameters: this<'tags, 'base> => option<array<TypeParameter.t>> = "getTypeParameters"
    @send
    external getParameters: this<'tags, 'base> => array<Symbol.t> = "getParameters"
    @send
    external getTypeParameterAtPosition: (this<'tags, 'base>, ~pos:float) => Type.t = "getTypeParameterAtPosition"
    @send
    external getReturnType: this<'tags, 'base> => Type.t = "getReturnType"
    @send
    external getDocumentationComment: (this<'tags, 'base>, ~typeChecker:undefined<TypeChecker.t>) => array<SymbolDisplayPart.t> = "getDocumentationComment"
    @send
    external getJsDocTags: this<'tags, 'base> => array<JSDocTagInfo.t> = "getJsDocTags"
    @get
    external getDeclaration': this<'tags, 'base> => Union.t2<SignatureDeclaration.t, JSDocSignature.t> = "declaration"
    @set
    external setDeclaration: (this<'tags, 'base>, Union.t2<SignatureDeclaration.t, JSDocSignature.t>) => unit = "declaration"
    @get
    external getTypeParameters': this<'tags, 'base> => array<TypeParameter.t> = "typeParameters"
    @set
    external setTypeParameters: (this<'tags, 'base>, array<TypeParameter.t>) => unit = "typeParameters"
    @get
    external getParameters': this<'tags, 'base> => array<Symbol.t> = "parameters"
    @set
    external setParameters: (this<'tags, 'base>, array<Symbol.t>) => unit = "parameters"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SignatureDeclaration = {
    open SignatureDeclaration
    type t = Union.t8<CallSignatureDeclaration.t, ConstructSignatureDeclaration.t, MethodSignature.t, IndexSignatureDeclaration.t, FunctionTypeNode.t, ConstructorTypeNode.t, JSDocFunctionType.t, Union.t6<FunctionDeclaration.t, MethodDeclaration.t, ConstructorDeclaration.t, AccessorDeclaration.t, FunctionExpression.t, ArrowFunction.t>>
    type t0 = t
  }
  module SignatureDeclarationBase = {
    open SignatureDeclarationBase
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SignatureDeclarationBase]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SignatureDeclarationBase ]
    @get
    external kind: this<'tags, 'base> => Union.t8<SyntaxKind.CallSignature.t, SyntaxKind.ConstructSignature.t, SyntaxKind.MethodSignature.t, SyntaxKind.IndexSignature.t, SyntaxKind.FunctionType.t, SyntaxKind.ConstructorType.t, SyntaxKind.JSDocFunctionType.t, Union.t6<SyntaxKind.FunctionDeclaration.t, SyntaxKind.MethodDeclaration.t, SyntaxKind.Constructor.t, Union.t2<SyntaxKind.GetAccessor.t, SyntaxKind.SetAccessor.t>, SyntaxKind.FunctionExpression.t, SyntaxKind.ArrowFunction.t>> = "kind"
    @get
    external name: this<'tags, 'base> => PropertyName.t = "name"
    @get
    external typeParameters: this<'tags, 'base> => NodeArray.t<TypeParameterDeclaration.t> = "typeParameters"
    @get
    external parameters: this<'tags, 'base> => NodeArray.t<ParameterDeclaration.t> = "parameters"
    @get
    external \"type": this<'tags, 'base> => TypeNode.t = "type"
    @obj
    external make: (~kind: Union.t8<SyntaxKind.CallSignature.t, SyntaxKind.ConstructSignature.t, SyntaxKind.MethodSignature.t, SyntaxKind.IndexSignature.t, SyntaxKind.FunctionType.t, SyntaxKind.ConstructorType.t, SyntaxKind.JSDocFunctionType.t, Union.t6<SyntaxKind.FunctionDeclaration.t, SyntaxKind.MethodDeclaration.t, SyntaxKind.Constructor.t, Union.t2<SyntaxKind.GetAccessor.t, SyntaxKind.SetAccessor.t>, SyntaxKind.FunctionExpression.t, SyntaxKind.ArrowFunction.t>>, ~name: PropertyName.t, ~typeParameters: NodeArray.t<TypeParameterDeclaration.t>, ~parameters: NodeArray.t<ParameterDeclaration.t>, ~\"type": TypeNode.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNamedDeclaration: t => NamedDeclaration.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module SignatureHelpCharacterTypedReason = {
    open SignatureHelpCharacterTypedReason
    type t = t
    type t0 = t
    type tags = [#Ts_SignatureHelpCharacterTypedReason]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SignatureHelpCharacterTypedReason ]
    @get
    external getKind: this<'tags, 'base> => [#characterTyped] = "kind"
    @set
    external setKind: (this<'tags, 'base>, [#characterTyped]) => unit = "kind"
    @get
    external getTriggerCharacter: this<'tags, 'base> => SignatureHelpTriggerCharacter.t = "triggerCharacter"
    @set
    external setTriggerCharacter: (this<'tags, 'base>, SignatureHelpTriggerCharacter.t) => unit = "triggerCharacter"
    @obj
    external make: (~kind: [#characterTyped], ~triggerCharacter: SignatureHelpTriggerCharacter.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SignatureHelpInvokedReason = {
    open SignatureHelpInvokedReason
    type t = t
    type t0 = t
    type tags = [#Ts_SignatureHelpInvokedReason]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SignatureHelpInvokedReason ]
    @get
    external getKind: this<'tags, 'base> => [#invoked] = "kind"
    @set
    external setKind: (this<'tags, 'base>, [#invoked]) => unit = "kind"
    @get
    external getTriggerCharacter: this<'tags, 'base> => unit = "triggerCharacter"
    @set
    external setTriggerCharacter: (this<'tags, 'base>, unit) => unit = "triggerCharacter"
    @obj
    external make: (~kind: [#invoked], ~triggerCharacter: never=?, unit) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SignatureHelpItem = {
    open SignatureHelpItem
    type t = t
    type t0 = t
    type tags = [#Ts_SignatureHelpItem]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SignatureHelpItem ]
    @get
    external getIsVariadic: this<'tags, 'base> => bool = "isVariadic"
    @set
    external setIsVariadic: (this<'tags, 'base>, bool) => unit = "isVariadic"
    @get
    external getPrefixDisplayParts: this<'tags, 'base> => array<SymbolDisplayPart.t> = "prefixDisplayParts"
    @set
    external setPrefixDisplayParts: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "prefixDisplayParts"
    @get
    external getSuffixDisplayParts: this<'tags, 'base> => array<SymbolDisplayPart.t> = "suffixDisplayParts"
    @set
    external setSuffixDisplayParts: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "suffixDisplayParts"
    @get
    external getSeparatorDisplayParts: this<'tags, 'base> => array<SymbolDisplayPart.t> = "separatorDisplayParts"
    @set
    external setSeparatorDisplayParts: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "separatorDisplayParts"
    @get
    external getParameters: this<'tags, 'base> => array<SignatureHelpParameter.t> = "parameters"
    @set
    external setParameters: (this<'tags, 'base>, array<SignatureHelpParameter.t>) => unit = "parameters"
    @get
    external getDocumentation: this<'tags, 'base> => array<SymbolDisplayPart.t> = "documentation"
    @set
    external setDocumentation: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "documentation"
    @get
    external getTags: this<'tags, 'base> => array<JSDocTagInfo.t> = "tags"
    @set
    external setTags: (this<'tags, 'base>, array<JSDocTagInfo.t>) => unit = "tags"
    @obj
    external make: (~isVariadic: bool, ~prefixDisplayParts: array<SymbolDisplayPart.t>, ~suffixDisplayParts: array<SymbolDisplayPart.t>, ~separatorDisplayParts: array<SymbolDisplayPart.t>, ~parameters: array<SignatureHelpParameter.t>, ~documentation: array<SymbolDisplayPart.t>, ~tags: array<JSDocTagInfo.t>) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SignatureHelpItems = {
    open SignatureHelpItems
    type t = t
    type t0 = t
    type tags = [#Ts_SignatureHelpItems]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SignatureHelpItems ]
    @get
    external getItems: this<'tags, 'base> => array<SignatureHelpItem.t> = "items"
    @set
    external setItems: (this<'tags, 'base>, array<SignatureHelpItem.t>) => unit = "items"
    @get
    external getApplicableSpan: this<'tags, 'base> => TextSpan.t = "applicableSpan"
    @set
    external setApplicableSpan: (this<'tags, 'base>, TextSpan.t) => unit = "applicableSpan"
    @get
    external getSelectedItemIndex: this<'tags, 'base> => float = "selectedItemIndex"
    @set
    external setSelectedItemIndex: (this<'tags, 'base>, float) => unit = "selectedItemIndex"
    @get
    external getArgumentIndex: this<'tags, 'base> => float = "argumentIndex"
    @set
    external setArgumentIndex: (this<'tags, 'base>, float) => unit = "argumentIndex"
    @get
    external getArgumentCount: this<'tags, 'base> => float = "argumentCount"
    @set
    external setArgumentCount: (this<'tags, 'base>, float) => unit = "argumentCount"
    @obj
    external make: (~items: array<SignatureHelpItem.t>, ~applicableSpan: TextSpan.t, ~selectedItemIndex: float, ~argumentIndex: float, ~argumentCount: float) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SignatureHelpItemsOptions = {
    open SignatureHelpItemsOptions
    type t = t
    type t0 = t
    type tags = [#Ts_SignatureHelpItemsOptions]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SignatureHelpItemsOptions ]
    @get
    external getTriggerReason: this<'tags, 'base> => SignatureHelpTriggerReason.t = "triggerReason"
    @set
    external setTriggerReason: (this<'tags, 'base>, SignatureHelpTriggerReason.t) => unit = "triggerReason"
    @obj
    external make: ~triggerReason: SignatureHelpTriggerReason.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SignatureHelpParameter = {
    open SignatureHelpParameter
    type t = t
    type t0 = t
    type tags = [#Ts_SignatureHelpParameter]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SignatureHelpParameter ]
    @get
    external getName: this<'tags, 'base> => string = "name"
    @set
    external setName: (this<'tags, 'base>, string) => unit = "name"
    @get
    external getDocumentation: this<'tags, 'base> => array<SymbolDisplayPart.t> = "documentation"
    @set
    external setDocumentation: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "documentation"
    @get
    external getDisplayParts: this<'tags, 'base> => array<SymbolDisplayPart.t> = "displayParts"
    @set
    external setDisplayParts: (this<'tags, 'base>, array<SymbolDisplayPart.t>) => unit = "displayParts"
    @get
    external getIsOptional: this<'tags, 'base> => bool = "isOptional"
    @set
    external setIsOptional: (this<'tags, 'base>, bool) => unit = "isOptional"
    @get
    external getIsRest: this<'tags, 'base> => bool = "isRest"
    @set
    external setIsRest: (this<'tags, 'base>, bool) => unit = "isRest"
    @obj
    external make: (~name: string, ~documentation: array<SymbolDisplayPart.t>, ~displayParts: array<SymbolDisplayPart.t>, ~isOptional: bool, ~isRest: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SignatureHelpRetriggerCharacter = {
    open SignatureHelpRetriggerCharacter
    type t = Union.t2<SignatureHelpTriggerCharacter.t, [#")"]>
    type t0 = t
  }
  module SignatureHelpRetriggeredReason = {
    open SignatureHelpRetriggeredReason
    type t = t
    type t0 = t
    type tags = [#Ts_SignatureHelpRetriggeredReason]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SignatureHelpRetriggeredReason ]
    @get
    external getKind: this<'tags, 'base> => [#retrigger] = "kind"
    @set
    external setKind: (this<'tags, 'base>, [#retrigger]) => unit = "kind"
    @get
    external getTriggerCharacter: this<'tags, 'base> => SignatureHelpRetriggerCharacter.t = "triggerCharacter"
    @set
    external setTriggerCharacter: (this<'tags, 'base>, SignatureHelpRetriggerCharacter.t) => unit = "triggerCharacter"
    @obj
    external make: (~kind: [#retrigger], ~triggerCharacter: SignatureHelpRetriggerCharacter.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SignatureHelpTriggerCharacter = {
    open SignatureHelpTriggerCharacter
    type t = Union.t3<[#","], [#"("], [#"<"]>
    type t0 = t
  }
  module SignatureHelpTriggerReason = {
    open SignatureHelpTriggerReason
    type t = Union.t3<SignatureHelpInvokedReason.t, SignatureHelpCharacterTypedReason.t, SignatureHelpRetriggeredReason.t>
    type t0 = t
  }
  module SignatureKind = {
    open SignatureKind
    type t = t = Call | Construct
    type t_0 = t
    module Call = {
      open Call
      type t = t
      type t0 = t
      @module("typescript") @scope("SignatureKind") @val
      external value: t = "Call"
    }
    module Construct = {
      open Construct
      type t = t
      type t0 = t
      @module("typescript") @scope("SignatureKind") @val
      external value: t = "Construct"
    }
  }
  module SolutionBuilder = {
    open SolutionBuilder
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_SolutionBuilder('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_SolutionBuilder('T) ]
    @send
    external build: (this<'tags, 'base, 'T>, ~project:string=?, ~cancellationToken:CancellationToken.t=?, ~writeFile:WriteFileCallback.t=?, ~getCustomTransformers:(@uncurry string => CustomTransformers.t)=?, unit) => ExitStatus.t = "build"
    @send
    external clean: (this<'tags, 'base, 'T>, ~project:string=?, unit) => ExitStatus.t = "clean"
    @send
    external buildReferences: (this<'tags, 'base, 'T>, ~project:string, ~cancellationToken:CancellationToken.t=?, ~writeFile:WriteFileCallback.t=?, ~getCustomTransformers:(@uncurry string => CustomTransformers.t)=?, unit) => ExitStatus.t = "buildReferences"
    @send
    external cleanReferences: (this<'tags, 'base, 'T>, ~project:string=?, unit) => ExitStatus.t = "cleanReferences"
    @send @return(nullable)
    external getNextInvalidatedProject: (this<'tags, 'base, 'T>, ~cancellationToken:CancellationToken.t=?, unit) => option<InvalidatedProject.t<'T>> = "getNextInvalidatedProject"
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
  }
  module SolutionBuilderHost = {
    open SolutionBuilderHost
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_ProgramHost('T) | #Ts_SolutionBuilderHost('T) | #Ts_SolutionBuilderHostBase('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_SolutionBuilderHost('T) ]
    @get
    external getReportErrorSummary: this<'tags, 'base, 'T> => ReportEmitErrorSummary.t = "reportErrorSummary"
    @set
    external setReportErrorSummary: (this<'tags, 'base, 'T>, ReportEmitErrorSummary.t) => unit = "reportErrorSummary"
    @obj
    external make: ~reportErrorSummary: ReportEmitErrorSummary.t => t<'T> = ""
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asSolutionBuilderHostBase: t<'T> => SolutionBuilderHostBase.t<'T> = "%identity"
  }
  module SolutionBuilderHostBase = {
    open SolutionBuilderHostBase
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_ProgramHost('T) | #Ts_SolutionBuilderHostBase('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_SolutionBuilderHostBase('T) ]
    @send
    external createDirectory: (this<'tags, 'base, 'T>, ~path:string) => unit = "createDirectory"
    @send
    external writeFile: (this<'tags, 'base, 'T>, ~path:string, ~data:string, ~writeByteOrderMark:bool=?, unit) => unit = "writeFile"
    @send @return(nullable)
    external getCustomTransformers: (this<'tags, 'base, 'T>, ~project:string) => option<CustomTransformers.t> = "getCustomTransformers"
    @send @return(nullable)
    external getModifiedTime: (this<'tags, 'base, 'T>, ~fileName:string) => option<Js.Date.t> = "getModifiedTime"
    @send
    external setModifiedTime: (this<'tags, 'base, 'T>, ~fileName:string, ~date:Js.Date.t) => unit = "setModifiedTime"
    @send
    external deleteFile: (this<'tags, 'base, 'T>, ~fileName:string) => unit = "deleteFile"
    @send @return(nullable)
    external getParsedCommandLine: (this<'tags, 'base, 'T>, ~fileName:string) => option<ParsedCommandLine.t> = "getParsedCommandLine"
    @get
    external getReportDiagnostic: this<'tags, 'base, 'T> => DiagnosticReporter.t = "reportDiagnostic"
    @set
    external setReportDiagnostic: (this<'tags, 'base, 'T>, DiagnosticReporter.t) => unit = "reportDiagnostic"
    @get
    external getReportSolutionBuilderStatus: this<'tags, 'base, 'T> => DiagnosticReporter.t = "reportSolutionBuilderStatus"
    @set
    external setReportSolutionBuilderStatus: (this<'tags, 'base, 'T>, DiagnosticReporter.t) => unit = "reportSolutionBuilderStatus"
    @send
    external afterProgramEmitAndDiagnostics: (this<'tags, 'base, 'T>, ~program:'T) => unit = "afterProgramEmitAndDiagnostics"
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asProgramHost: t<'T> => ProgramHost.t<'T> = "%identity"
  }
  module SolutionBuilderWithWatchHost = {
    open SolutionBuilderWithWatchHost
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Ts_ProgramHost('T) | #Ts_SolutionBuilderHostBase('T) | #Ts_SolutionBuilderWithWatchHost('T) | #Ts_WatchHost]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_SolutionBuilderWithWatchHost('T) ]
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asSolutionBuilderHostBase: t<'T> => SolutionBuilderHostBase.t<'T> = "%identity"
    external asWatchHost: t<'T> => WatchHost.t = "%identity"
  }
  module SortedArray = {
    open SortedArray
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#Array('T) | #Ts_SortedArray('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_SortedArray('T) ]
    @get
    external \"get __sortedArrayBrand": this<'tags, 'base, 'T> => any = " __sortedArrayBrand"
    @set
    external \"set __sortedArrayBrand": (this<'tags, 'base, 'T>, any) => unit = " __sortedArrayBrand"
    @obj
    external make: ~\" __sortedArrayBrand": any => t<'T> = ""
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asArray: t<'T> => Js.Array.t<'T> = "%identity"
  }
  module SortedReadonlyArray = {
    open SortedReadonlyArray
    type t<'T> = t<'T>
    type t1<'T> = t<'T>
    type tags<'T> = [#ReadonlyArray('T) | #Ts_SortedReadonlyArray('T)]
    type tags1<'T> = tags<'T>
    type this<'tags, 'base, 'T> = intf<'tags, 'base> constraint 'tags = [> #Ts_SortedReadonlyArray('T) ]
    @get
    external \"get __sortedArrayBrand": this<'tags, 'base, 'T> => any = " __sortedArrayBrand"
    @set
    external \"set __sortedArrayBrand": (this<'tags, 'base, 'T>, any) => unit = " __sortedArrayBrand"
    @obj
    external make: ~\" __sortedArrayBrand": any => t<'T> = ""
    external castFrom: this<'tags, 'base, 'T> => t<'T> = "%identity"
    external asReadonlyArray: t<'T> => array<'T> = "%identity"
  }
  module SourceFile = {
    open SourceFile
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SourceFile]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SourceFile ]
    @send
    external getLineAndCharacterOfPosition: (this<'tags, 'base>, ~pos:float) => LineAndCharacter.t = "getLineAndCharacterOfPosition"
    @send
    external getLineEndOfPosition: (this<'tags, 'base>, ~pos:float) => float = "getLineEndOfPosition"
    @send
    external getLineStarts: this<'tags, 'base> => array<float> = "getLineStarts"
    @send
    external getPositionOfLineAndCharacter: (this<'tags, 'base>, ~line:float, ~character:float) => float = "getPositionOfLineAndCharacter"
    @send
    external update: (this<'tags, 'base>, ~newText:string, ~textChangeRange:TextChangeRange.t) => t = "update"
    @get
    external kind: this<'tags, 'base> => SyntaxKind.SourceFile.t = "kind"
    @get
    external statements: this<'tags, 'base> => NodeArray.t<Statement.t> = "statements"
    @get
    external endOfFileToken: this<'tags, 'base> => Token.t<SyntaxKind.EndOfFileToken.t> = "endOfFileToken"
    @get
    external getFileName: this<'tags, 'base> => string = "fileName"
    @set
    external setFileName: (this<'tags, 'base>, string) => unit = "fileName"
    @get
    external getText: this<'tags, 'base> => string = "text"
    @set
    external setText: (this<'tags, 'base>, string) => unit = "text"
    @get
    external getAmdDependencies: this<'tags, 'base> => array<AmdDependency.t> = "amdDependencies"
    @set
    external setAmdDependencies: (this<'tags, 'base>, array<AmdDependency.t>) => unit = "amdDependencies"
    @get
    external getModuleName: this<'tags, 'base> => string = "moduleName"
    @set
    external setModuleName: (this<'tags, 'base>, string) => unit = "moduleName"
    @get
    external getReferencedFiles: this<'tags, 'base> => array<FileReference.t> = "referencedFiles"
    @set
    external setReferencedFiles: (this<'tags, 'base>, array<FileReference.t>) => unit = "referencedFiles"
    @get
    external getTypeReferenceDirectives: this<'tags, 'base> => array<FileReference.t> = "typeReferenceDirectives"
    @set
    external setTypeReferenceDirectives: (this<'tags, 'base>, array<FileReference.t>) => unit = "typeReferenceDirectives"
    @get
    external getLibReferenceDirectives: this<'tags, 'base> => array<FileReference.t> = "libReferenceDirectives"
    @set
    external setLibReferenceDirectives: (this<'tags, 'base>, array<FileReference.t>) => unit = "libReferenceDirectives"
    @get
    external getLanguageVariant: this<'tags, 'base> => LanguageVariant.t = "languageVariant"
    @set
    external setLanguageVariant: (this<'tags, 'base>, LanguageVariant.t) => unit = "languageVariant"
    @get
    external getIsDeclarationFile: this<'tags, 'base> => bool = "isDeclarationFile"
    @set
    external setIsDeclarationFile: (this<'tags, 'base>, bool) => unit = "isDeclarationFile"
    @get
    external getHasNoDefaultLib: this<'tags, 'base> => bool = "hasNoDefaultLib"
    @set
    external setHasNoDefaultLib: (this<'tags, 'base>, bool) => unit = "hasNoDefaultLib"
    @get
    external getLanguageVersion: this<'tags, 'base> => ScriptTarget.t = "languageVersion"
    @set
    external setLanguageVersion: (this<'tags, 'base>, ScriptTarget.t) => unit = "languageVersion"
    @get
    external getImpliedNodeFormat: this<'tags, 'base> => Union.t2<ModuleKind.ESNext.t, ModuleKind.CommonJS.t> = "impliedNodeFormat"
    @set
    external setImpliedNodeFormat: (this<'tags, 'base>, Union.t2<ModuleKind.ESNext.t, ModuleKind.CommonJS.t>) => unit = "impliedNodeFormat"
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module SourceFileLike = {
    open SourceFileLike
    type t = t
    type t0 = t
    type tags = [#Ts_SourceFileLike]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SourceFileLike ]
    @send
    external getLineAndCharacterOfPosition: (this<'tags, 'base>, ~pos:float) => LineAndCharacter.t = "getLineAndCharacterOfPosition"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SourceMapRange = {
    open SourceMapRange
    type t = t
    type t0 = t
    type tags = [#Ts_SourceMapRange | #Ts_TextRange]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SourceMapRange ]
    @get
    external getSource: this<'tags, 'base> => SourceMapSource.t = "source"
    @set
    external setSource: (this<'tags, 'base>, SourceMapSource.t) => unit = "source"
    @obj
    external make: ~source: SourceMapSource.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asTextRange: t => TextRange.t = "%identity"
  }
  module SourceMapSource = {
    open SourceMapSource
    type t = t
    type t0 = t
    type tags = [#Ts_SourceMapSource]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SourceMapSource ]
    @send
    external getLineAndCharacterOfPosition: (this<'tags, 'base>, ~pos:float) => LineAndCharacter.t = "getLineAndCharacterOfPosition"
    @get
    external getFileName: this<'tags, 'base> => string = "fileName"
    @set
    external setFileName: (this<'tags, 'base>, string) => unit = "fileName"
    @get
    external getText: this<'tags, 'base> => string = "text"
    @set
    external setText: (this<'tags, 'base>, string) => unit = "text"
    @send
    external skipTrivia: (this<'tags, 'base>, ~pos:float) => float = "skipTrivia"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SourceMapSpan = {
    open SourceMapSpan
    type t = t
    type t0 = t
    type tags = [#Ts_SourceMapSpan]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SourceMapSpan ]
    @get
    external getEmittedLine: this<'tags, 'base> => float = "emittedLine"
    @set
    external setEmittedLine: (this<'tags, 'base>, float) => unit = "emittedLine"
    @get
    external getEmittedColumn: this<'tags, 'base> => float = "emittedColumn"
    @set
    external setEmittedColumn: (this<'tags, 'base>, float) => unit = "emittedColumn"
    @get
    external getSourceLine: this<'tags, 'base> => float = "sourceLine"
    @set
    external setSourceLine: (this<'tags, 'base>, float) => unit = "sourceLine"
    @get
    external getSourceColumn: this<'tags, 'base> => float = "sourceColumn"
    @set
    external setSourceColumn: (this<'tags, 'base>, float) => unit = "sourceColumn"
    @get
    external getNameIndex: this<'tags, 'base> => float = "nameIndex"
    @set
    external setNameIndex: (this<'tags, 'base>, float) => unit = "nameIndex"
    @get
    external getSourceIndex: this<'tags, 'base> => float = "sourceIndex"
    @set
    external setSourceIndex: (this<'tags, 'base>, float) => unit = "sourceIndex"
    @obj
    external make: (~emittedLine: float, ~emittedColumn: float, ~sourceLine: float, ~sourceColumn: float, ~nameIndex: float, ~sourceIndex: float) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SpreadAssignment = {
    open SpreadAssignment
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_JSDocContainer | #Ts_NamedDeclaration | #Ts_Node | #Ts_ObjectLiteralElement | #Ts_ReadonlyTextRange | #Ts_SpreadAssignment]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SpreadAssignment ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.SpreadAssignment.t = "kind"
    @get
    external parent: this<'tags, 'base> => ObjectLiteralExpression.t = "parent"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.SpreadAssignment.t, ~parent: ObjectLiteralExpression.t, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asObjectLiteralElement: t => ObjectLiteralElement.t = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module SpreadElement = {
    open SpreadElement
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SpreadElement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SpreadElement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.SpreadElement.t = "kind"
    @get
    external parent: this<'tags, 'base> => Union.t3<ArrayLiteralExpression.t, CallExpression.t, NewExpression.t> = "parent"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @obj
    external make: (~kind: SyntaxKind.SpreadElement.t, ~parent: Union.t3<ArrayLiteralExpression.t, CallExpression.t, NewExpression.t>, ~expression: Expression.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asExpression: t => Expression.t = "%identity"
  }
  module Statement = {
    open Statement
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Statement ]
    @get
    external get_statementBrand: this<'tags, 'base> => any = "_statementBrand"
    @set
    external set_statementBrand: (this<'tags, 'base>, any) => unit = "_statementBrand"
    @obj
    external make: ~\"_statementBrand": any => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asNode: t => Dom.node = "%identity"
    external asJSDocContainer: t => JSDocContainer.t = "%identity"
  }
  module StaticKeyword = {
    open StaticKeyword
    type t = ModifierToken.t<SyntaxKind.StaticKeyword.t>
    type t0 = t
  }
  module StringLiteral = {
    open StringLiteral
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_LiteralExpression | #Ts_LiteralLikeNode | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_StringLiteral | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_StringLiteral ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.StringLiteral.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.StringLiteral.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLiteralExpression: t => LiteralExpression.t = "%identity"
    external asDeclaration: t => Declaration.t = "%identity"
  }
  module StringLiteralLike = {
    open StringLiteralLike
    type t = Union.t2<StringLiteral.t, NoSubstitutionTemplateLiteral.t>
    type t0 = t
  }
  module StringLiteralType = {
    open StringLiteralType
    type t = t
    type t0 = t
    type tags = [#Ts_LiteralType | #Ts_StringLiteralType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_StringLiteralType ]
    @get
    external getValue: this<'tags, 'base> => string = "value"
    @set
    external setValue: (this<'tags, 'base>, string) => unit = "value"
    @obj
    external make: ~value: string => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asLiteralType: t => LiteralType.t = "%identity"
  }
  module StringMappingType = {
    open StringMappingType
    type t = t
    type t0 = t
    type tags = [#Ts_InstantiableType | #Ts_StringMappingType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_StringMappingType ]
    @get
    external getSymbol: this<'tags, 'base> => Symbol.t = "symbol"
    @set
    external setSymbol: (this<'tags, 'base>, Symbol.t) => unit = "symbol"
    @get
    external getType: this<'tags, 'base> => Type.t = "type"
    @set
    external setType: (this<'tags, 'base>, Type.t) => unit = "type"
    @obj
    external make: (~symbol: Symbol.t, ~\"type": Type.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asInstantiableType: t => InstantiableType.t = "%identity"
  }
  module StructuredType = {
    open StructuredType
    type t = Union.t3<ObjectType.t, UnionType.t, IntersectionType.t>
    type t0 = t
  }
  module SubstitutionType = {
    open SubstitutionType
    type t = t
    type t0 = t
    type tags = [#Ts_InstantiableType | #Ts_SubstitutionType | #Ts_Type]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SubstitutionType ]
    @get
    external getObjectFlags: this<'tags, 'base> => ObjectFlags.t = "objectFlags"
    @set
    external setObjectFlags: (this<'tags, 'base>, ObjectFlags.t) => unit = "objectFlags"
    @get
    external getBaseType: this<'tags, 'base> => Type.t = "baseType"
    @set
    external setBaseType: (this<'tags, 'base>, Type.t) => unit = "baseType"
    @get
    external getSubstitute: this<'tags, 'base> => Type.t = "substitute"
    @set
    external setSubstitute: (this<'tags, 'base>, Type.t) => unit = "substitute"
    @obj
    external make: (~objectFlags: ObjectFlags.t, ~baseType: Type.t, ~substitute: Type.t) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asInstantiableType: t => InstantiableType.t = "%identity"
  }
  module SuperCall = {
    open SuperCall
    type t = t
    type t0 = t
    type tags = [#Ts_CallExpression | #Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SuperCall | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SuperCall ]
    @get
    external expression: this<'tags, 'base> => SuperExpression.t = "expression"
    @obj
    external make: ~expression: SuperExpression.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asCallExpression: t => CallExpression.t = "%identity"
  }
  module SuperElementAccessExpression = {
    open SuperElementAccessExpression
    type t = t
    type t0 = t
    type tags = [#Ts_ElementAccessExpression | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_SuperElementAccessExpression | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SuperElementAccessExpression ]
    @get
    external expression: this<'tags, 'base> => SuperExpression.t = "expression"
    @obj
    external make: ~expression: SuperExpression.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asElementAccessExpression: t => ElementAccessExpression.t = "%identity"
  }
  module SuperExpression = {
    open SuperExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_Node | #Ts_PrimaryExpression | #Ts_ReadonlyTextRange | #Ts_SuperExpression | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SuperExpression ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.SuperKeyword.t = "kind"
    @obj
    external make: ~kind: SyntaxKind.SuperKeyword.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPrimaryExpression: t => PrimaryExpression.t = "%identity"
  }
  module SuperProperty = {
    open SuperProperty
    type t = Union.t2<SuperPropertyAccessExpression.t, SuperElementAccessExpression.t>
    type t0 = t
  }
  module SuperPropertyAccessExpression = {
    open SuperPropertyAccessExpression
    type t = t
    type t0 = t
    type tags = [#Ts_Declaration | #Ts_Expression | #Ts_LeftHandSideExpression | #Ts_MemberExpression | #Ts_NamedDeclaration | #Ts_Node | #Ts_PropertyAccessExpression | #Ts_ReadonlyTextRange | #Ts_SuperPropertyAccessExpression | #Ts_UnaryExpression | #Ts_UpdateExpression]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SuperPropertyAccessExpression ]
    @get
    external expression: this<'tags, 'base> => SuperExpression.t = "expression"
    @obj
    external make: ~expression: SuperExpression.t => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asPropertyAccessExpression: t => PropertyAccessExpression.t = "%identity"
  }
  module SwitchStatement = {
    open SwitchStatement
    type t = t
    type t0 = t
    type tags = [#Ts_JSDocContainer | #Ts_Node | #Ts_ReadonlyTextRange | #Ts_Statement | #Ts_SwitchStatement]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SwitchStatement ]
    @get
    external kind: this<'tags, 'base> => SyntaxKind.SwitchStatement.t = "kind"
    @get
    external expression: this<'tags, 'base> => Expression.t = "expression"
    @get
    external caseBlock: this<'tags, 'base> => CaseBlock.t = "caseBlock"
    @get
    external getPossiblyExhaustive: this<'tags, 'base> => bool = "possiblyExhaustive"
    @set
    external setPossiblyExhaustive: (this<'tags, 'base>, bool) => unit = "possiblyExhaustive"
    @obj
    external make: (~kind: SyntaxKind.SwitchStatement.t, ~expression: Expression.t, ~caseBlock: CaseBlock.t, ~possiblyExhaustive: bool) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
    external asStatement: t => Statement.t = "%identity"
  }
  module Symbol = {
    open Symbol
    type t = t
    type t0 = t
    type tags = [#Ts_Symbol]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_Symbol ]
    @get
    external name: this<'tags, 'base> => string = "name"
    @send
    external getFlags: this<'tags, 'base> => SymbolFlags.t = "getFlags"
    @send
    external getEscapedName: this<'tags, 'base> => M__String.t = "getEscapedName"
    @send
    external getName: this<'tags, 'base> => string = "getName"
    @send @return(nullable)
    external getDeclarations: this<'tags, 'base> => option<array<Declaration.t>> = "getDeclarations"
    @send
    external getDocumentationComment: (this<'tags, 'base>, ~typeChecker:undefined<TypeChecker.t>) => array<SymbolDisplayPart.t> = "getDocumentationComment"
    @send
    external getJsDocTags: (this<'tags, 'base>, ~checker:TypeChecker.t=?, unit) => array<JSDocTagInfo.t> = "getJsDocTags"
    @get
    external getFlags': this<'tags, 'base> => SymbolFlags.t = "flags"
    @set
    external setFlags: (this<'tags, 'base>, SymbolFlags.t) => unit = "flags"
    @get
    external getEscapedName': this<'tags, 'base> => M__String.t = "escapedName"
    @set
    external setEscapedName: (this<'tags, 'base>, M__String.t) => unit = "escapedName"
    @get
    external getDeclarations': this<'tags, 'base> => array<Declaration.t> = "declarations"
    @set
    external setDeclarations: (this<'tags, 'base>, array<Declaration.t>) => unit = "declarations"
    @get
    external getValueDeclaration: this<'tags, 'base> => Declaration.t = "valueDeclaration"
    @set
    external setValueDeclaration: (this<'tags, 'base>, Declaration.t) => unit = "valueDeclaration"
    @get
    external getMembers: this<'tags, 'base> => SymbolTable.t = "members"
    @set
    external setMembers: (this<'tags, 'base>, SymbolTable.t) => unit = "members"
    @get
    external getExports: this<'tags, 'base> => SymbolTable.t = "exports"
    @set
    external setExports: (this<'tags, 'base>, SymbolTable.t) => unit = "exports"
    @get
    external getGlobalExports: this<'tags, 'base> => SymbolTable.t = "globalExports"
    @set
    external setGlobalExports: (this<'tags, 'base>, SymbolTable.t) => unit = "globalExports"
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SymbolDisplayPart = {
    open SymbolDisplayPart
    type t = t
    type t0 = t
    type tags = [#Ts_SymbolDisplayPart]
    type tags0 = tags
    type this<'tags, 'base> = intf<'tags, 'base> constraint 'tags = [> #Ts_SymbolDisplayPart ]
    @get
    external getText: this<'tags, 'base> => string = "text"
    @set
    external setText: (this<'tags, 'base>, string) => unit = "text"
    @get
    external getKind: this<'tags, 'base> => string = "kind"
    @set
    external setKind: (this<'tags, 'base>, string) => unit = "kind"
    @obj
    external make: (~text: string, ~kind: string) => t = ""
    external castFrom: this<'tags, 'base> => t = "%identity"
  }
  module SymbolDisplayPartKind = {
    open SymbolDisplayPartKind
    type t = t =   | AliasName
      | ClassName
      | EnumName
      | FieldName
      | InterfaceName
      | Keyword
      | LineBreak
      | NumericLiteral
      | StringLiteral
      | LocalName
      | MethodName
      | ModuleName
      | Operator
      | ParameterName
      | PropertyName
      | Punctuation
      | Space
      | Text
      | TypeParameterName
      | EnumMemberName
      | FunctionName
      | RegularExpressionLiteral
      | Link
      | LinkName
      | LinkText
    type t_0 = t
    module AliasName = {
      open AliasName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "aliasName"
    }
    module ClassName = {
      open ClassName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "className"
    }
    module EnumName = {
      open EnumName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "enumName"
    }
    module FieldName = {
      open FieldName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "fieldName"
    }
    module InterfaceName = {
      open InterfaceName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "interfaceName"
    }
    module Keyword = {
      open Keyword
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "keyword"
    }
    module LineBreak = {
      open LineBreak
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "lineBreak"
    }
    module NumericLiteral = {
      open NumericLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "numericLiteral"
    }
    module StringLiteral = {
      open StringLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "stringLiteral"
    }
    module LocalName = {
      open LocalName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "localName"
    }
    module MethodName = {
      open MethodName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "methodName"
    }
    module ModuleName = {
      open ModuleName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "moduleName"
    }
    module Operator = {
      open Operator
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "operator"
    }
    module ParameterName = {
      open ParameterName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "parameterName"
    }
    module PropertyName = {
      open PropertyName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "propertyName"
    }
    module Punctuation = {
      open Punctuation
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "punctuation"
    }
    module Space = {
      open Space
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "space"
    }
    module Text = {
      open Text
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "text"
    }
    module TypeParameterName = {
      open TypeParameterName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "typeParameterName"
    }
    module EnumMemberName = {
      open EnumMemberName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "enumMemberName"
    }
    module FunctionName = {
      open FunctionName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "functionName"
    }
    module RegularExpressionLiteral = {
      open RegularExpressionLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "regularExpressionLiteral"
    }
    module Link = {
      open Link
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "link"
    }
    module LinkName = {
      open LinkName
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "linkName"
    }
    module LinkText = {
      open LinkText
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolDisplayPartKind") @val
      external value: t = "linkText"
    }
  }
  module SymbolFlags = {
    open SymbolFlags
    type t = t
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "None"
    }
    module FunctionScopedVariable = {
      open FunctionScopedVariable
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "FunctionScopedVariable"
    }
    module BlockScopedVariable = {
      open BlockScopedVariable
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "BlockScopedVariable"
    }
    module Property = {
      open Property
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Property"
    }
    module EnumMember = {
      open EnumMember
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "EnumMember"
    }
    module Function = {
      open Function
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Function"
    }
    module Class = {
      open Class
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Class"
    }
    module Interface = {
      open Interface
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Interface"
    }
    module ConstEnum = {
      open ConstEnum
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ConstEnum"
    }
    module RegularEnum = {
      open RegularEnum
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "RegularEnum"
    }
    module ValueModule = {
      open ValueModule
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ValueModule"
    }
    module NamespaceModule = {
      open NamespaceModule
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "NamespaceModule"
    }
    module TypeLiteral = {
      open TypeLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "TypeLiteral"
    }
    module ObjectLiteral = {
      open ObjectLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ObjectLiteral"
    }
    module Method = {
      open Method
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Method"
    }
    module Constructor = {
      open Constructor
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Constructor"
    }
    module GetAccessor = {
      open GetAccessor
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "GetAccessor"
    }
    module SetAccessor = {
      open SetAccessor
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "SetAccessor"
    }
    module Signature = {
      open Signature
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Signature"
    }
    module TypeParameter = {
      open TypeParameter
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "TypeParameter"
    }
    module TypeAlias = {
      open TypeAlias
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "TypeAlias"
    }
    module ExportValue = {
      open ExportValue
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ExportValue"
    }
    module Alias = {
      open Alias
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Alias"
    }
    module Prototype = {
      open Prototype
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Prototype"
    }
    module ExportStar = {
      open ExportStar
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ExportStar"
    }
    module Optional = {
      open Optional
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Optional"
    }
    module Transient = {
      open Transient
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Transient"
    }
    module Assignment = {
      open Assignment
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Assignment"
    }
    module ModuleExports = {
      open ModuleExports
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ModuleExports"
    }
    module Enum = {
      open Enum
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Enum"
    }
    module Variable = {
      open Variable
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Variable"
    }
    module Value = {
      open Value
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Value"
    }
    module Type = {
      open Type
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Type"
    }
    module Namespace = {
      open Namespace
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Namespace"
    }
    module Module = {
      open Module
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Module"
    }
    module Accessor = {
      open Accessor
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "Accessor"
    }
    module FunctionScopedVariableExcludes = {
      open FunctionScopedVariableExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "FunctionScopedVariableExcludes"
    }
    module BlockScopedVariableExcludes = {
      open BlockScopedVariableExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "BlockScopedVariableExcludes"
    }
    module ParameterExcludes = {
      open ParameterExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ParameterExcludes"
    }
    module PropertyExcludes = {
      open PropertyExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "PropertyExcludes"
    }
    module EnumMemberExcludes = {
      open EnumMemberExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "EnumMemberExcludes"
    }
    module FunctionExcludes = {
      open FunctionExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "FunctionExcludes"
    }
    module ClassExcludes = {
      open ClassExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ClassExcludes"
    }
    module InterfaceExcludes = {
      open InterfaceExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "InterfaceExcludes"
    }
    module RegularEnumExcludes = {
      open RegularEnumExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "RegularEnumExcludes"
    }
    module ConstEnumExcludes = {
      open ConstEnumExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ConstEnumExcludes"
    }
    module ValueModuleExcludes = {
      open ValueModuleExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ValueModuleExcludes"
    }
    module NamespaceModuleExcludes = {
      open NamespaceModuleExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "NamespaceModuleExcludes"
    }
    module MethodExcludes = {
      open MethodExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "MethodExcludes"
    }
    module GetAccessorExcludes = {
      open GetAccessorExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "GetAccessorExcludes"
    }
    module SetAccessorExcludes = {
      open SetAccessorExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "SetAccessorExcludes"
    }
    module TypeParameterExcludes = {
      open TypeParameterExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "TypeParameterExcludes"
    }
    module TypeAliasExcludes = {
      open TypeAliasExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "TypeAliasExcludes"
    }
    module AliasExcludes = {
      open AliasExcludes
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "AliasExcludes"
    }
    module ModuleMember = {
      open ModuleMember
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ModuleMember"
    }
    module ExportHasLocal = {
      open ExportHasLocal
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ExportHasLocal"
    }
    module BlockScoped = {
      open BlockScoped
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "BlockScoped"
    }
    module PropertyOrAccessor = {
      open PropertyOrAccessor
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "PropertyOrAccessor"
    }
    module ClassMember = {
      open ClassMember
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFlags") @val
      external value: t = "ClassMember"
    }
  }
  module SymbolFormatFlags = {
    open SymbolFormatFlags
    type t = t
    type t_0 = t
    module None = {
      open None
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFormatFlags") @val
      external value: t = "None"
    }
    module WriteTypeParametersOrArguments = {
      open WriteTypeParametersOrArguments
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFormatFlags") @val
      external value: t = "WriteTypeParametersOrArguments"
    }
    module UseOnlyExternalAliasing = {
      open UseOnlyExternalAliasing
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFormatFlags") @val
      external value: t = "UseOnlyExternalAliasing"
    }
    module AllowAnyNodeKind = {
      open AllowAnyNodeKind
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFormatFlags") @val
      external value: t = "AllowAnyNodeKind"
    }
    module UseAliasDefinedOutsideCurrentScope = {
      open UseAliasDefinedOutsideCurrentScope
      type t = t
      type t0 = t
      @module("typescript") @scope("SymbolFormatFlags") @val
      external value: t = "UseAliasDefinedOutsideCurrentScope"
    }
  }
  module SymbolTable = {
    open SymbolTable
    type t = UnderscoreEscapedMap.t<Symbol.t>
    type t0 = t
  }
  module SyntaxKind = {
    open SyntaxKind
    type t = t =   | Unknown_FirstToken
      | EndOfFileToken
      | SingleLineCommentTrivia_FirstTriviaToken
      | MultiLineCommentTrivia
      | NewLineTrivia
      | WhitespaceTrivia
      | ShebangTrivia
      | ConflictMarkerTrivia_LastTriviaToken
      | NumericLiteral_FirstLiteralToken
      | BigIntLiteral
      | StringLiteral
      | JsxText
      | JsxTextAllWhiteSpaces
      | RegularExpressionLiteral
      | NoSubstitutionTemplateLiteral_LastLiteralToken_FirstTemplateToken
      | TemplateHead
      | TemplateMiddle
      | TemplateTail_LastTemplateToken
      | OpenBraceToken_FirstPunctuation
      | CloseBraceToken
      | OpenParenToken
      | CloseParenToken
      | OpenBracketToken
      | CloseBracketToken
      | DotToken
      | DotDotDotToken
      | SemicolonToken
      | CommaToken
      | QuestionDotToken
      | LessThanToken_FirstBinaryOperator
      | LessThanSlashToken
      | GreaterThanToken
      | LessThanEqualsToken
      | GreaterThanEqualsToken
      | EqualsEqualsToken
      | ExclamationEqualsToken
      | EqualsEqualsEqualsToken
      | ExclamationEqualsEqualsToken
      | EqualsGreaterThanToken
      | PlusToken
      | MinusToken
      | AsteriskToken
      | AsteriskAsteriskToken
      | SlashToken
      | PercentToken
      | PlusPlusToken
      | MinusMinusToken
      | LessThanLessThanToken
      | GreaterThanGreaterThanToken
      | GreaterThanGreaterThanGreaterThanToken
      | AmpersandToken
      | BarToken
      | CaretToken
      | ExclamationToken
      | TildeToken
      | AmpersandAmpersandToken
      | BarBarToken
      | QuestionToken
      | ColonToken
      | AtToken
      | QuestionQuestionToken
      | BacktickToken
      | HashToken
      | EqualsToken_FirstAssignment
      | PlusEqualsToken_FirstCompoundAssignment
      | MinusEqualsToken
      | AsteriskEqualsToken
      | AsteriskAsteriskEqualsToken
      | SlashEqualsToken
      | PercentEqualsToken
      | LessThanLessThanEqualsToken
      | GreaterThanGreaterThanEqualsToken
      | GreaterThanGreaterThanGreaterThanEqualsToken
      | AmpersandEqualsToken
      | BarEqualsToken
      | BarBarEqualsToken
      | AmpersandAmpersandEqualsToken
      | QuestionQuestionEqualsToken
      | CaretEqualsToken_LastAssignment_LastCompoundAssignment_LastPunctuation_LastBinaryOperator
      | Identifier
      | PrivateIdentifier
      | BreakKeyword_FirstReservedWord_FirstKeyword
      | CaseKeyword
      | CatchKeyword
      | ClassKeyword
      | ConstKeyword
      | ContinueKeyword
      | DebuggerKeyword
      | DefaultKeyword
      | DeleteKeyword
      | DoKeyword
      | ElseKeyword
      | EnumKeyword
      | ExportKeyword
      | ExtendsKeyword
      | FalseKeyword
      | FinallyKeyword
      | ForKeyword
      | FunctionKeyword
      | IfKeyword
      | ImportKeyword
      | InKeyword
      | InstanceOfKeyword
      | NewKeyword
      | NullKeyword
      | ReturnKeyword
      | SuperKeyword
      | SwitchKeyword
      | ThisKeyword
      | ThrowKeyword
      | TrueKeyword
      | TryKeyword
      | TypeOfKeyword
      | VarKeyword
      | VoidKeyword
      | WhileKeyword
      | WithKeyword_LastReservedWord
      | ImplementsKeyword_FirstFutureReservedWord
      | InterfaceKeyword
      | LetKeyword
      | PackageKeyword
      | PrivateKeyword
      | ProtectedKeyword
      | PublicKeyword
      | StaticKeyword
      | YieldKeyword_LastFutureReservedWord
      | AbstractKeyword
      | AsKeyword
      | AssertsKeyword
      | AssertKeyword
      | AnyKeyword
      | AsyncKeyword
      | AwaitKeyword
      | BooleanKeyword
      | ConstructorKeyword
      | DeclareKeyword
      | GetKeyword
      | InferKeyword
      | IntrinsicKeyword
      | IsKeyword
      | KeyOfKeyword
      | ModuleKeyword
      | NamespaceKeyword
      | NeverKeyword
      | ReadonlyKeyword
      | RequireKeyword
      | NumberKeyword
      | ObjectKeyword
      | SetKeyword
      | StringKeyword
      | SymbolKeyword
      | TypeKeyword
      | UndefinedKeyword
      | UniqueKeyword
      | UnknownKeyword
      | FromKeyword
      | GlobalKeyword
      | BigIntKeyword
      | OverrideKeyword
      | OfKeyword_LastKeyword_LastToken
      | QualifiedName_FirstNode
      | ComputedPropertyName
      | TypeParameter
      | Parameter
      | Decorator
      | PropertySignature
      | PropertyDeclaration
      | MethodSignature
      | MethodDeclaration
      | ClassStaticBlockDeclaration
      | Constructor
      | GetAccessor
      | SetAccessor
      | CallSignature
      | ConstructSignature
      | IndexSignature
      | TypePredicate_FirstTypeNode
      | TypeReference
      | FunctionType
      | ConstructorType
      | TypeQuery
      | TypeLiteral
      | ArrayType
      | TupleType
      | OptionalType
      | RestType
      | UnionType
      | IntersectionType
      | ConditionalType
      | InferType
      | ParenthesizedType
      | ThisType
      | TypeOperator
      | IndexedAccessType
      | MappedType
      | LiteralType
      | NamedTupleMember
      | TemplateLiteralType
      | TemplateLiteralTypeSpan
      | ImportType_LastTypeNode
      | ObjectBindingPattern
      | ArrayBindingPattern
      | BindingElement
      | ArrayLiteralExpression
      | ObjectLiteralExpression
      | PropertyAccessExpression
      | ElementAccessExpression
      | CallExpression
      | NewExpression
      | TaggedTemplateExpression
      | TypeAssertionExpression
      | ParenthesizedExpression
      | FunctionExpression
      | ArrowFunction
      | DeleteExpression
      | TypeOfExpression
      | VoidExpression
      | AwaitExpression
      | PrefixUnaryExpression
      | PostfixUnaryExpression
      | BinaryExpression
      | ConditionalExpression
      | TemplateExpression
      | YieldExpression
      | SpreadElement
      | ClassExpression
      | OmittedExpression
      | ExpressionWithTypeArguments
      | AsExpression
      | NonNullExpression
      | MetaProperty
      | SyntheticExpression
      | TemplateSpan
      | SemicolonClassElement
      | Block
      | EmptyStatement
      | VariableStatement_FirstStatement
      | ExpressionStatement
      | IfStatement
      | DoStatement
      | WhileStatement
      | ForStatement
      | ForInStatement
      | ForOfStatement
      | ContinueStatement
      | BreakStatement
      | ReturnStatement
      | WithStatement
      | SwitchStatement
      | LabeledStatement
      | ThrowStatement
      | TryStatement
      | DebuggerStatement_LastStatement
      | VariableDeclaration
      | VariableDeclarationList
      | FunctionDeclaration
      | ClassDeclaration
      | InterfaceDeclaration
      | TypeAliasDeclaration
      | EnumDeclaration
      | ModuleDeclaration
      | ModuleBlock
      | CaseBlock
      | NamespaceExportDeclaration
      | ImportEqualsDeclaration
      | ImportDeclaration
      | ImportClause
      | NamespaceImport
      | NamedImports
      | ImportSpecifier
      | ExportAssignment
      | ExportDeclaration
      | NamedExports
      | NamespaceExport
      | ExportSpecifier
      | MissingDeclaration
      | ExternalModuleReference
      | JsxElement
      | JsxSelfClosingElement
      | JsxOpeningElement
      | JsxClosingElement
      | JsxFragment
      | JsxOpeningFragment
      | JsxClosingFragment
      | JsxAttribute
      | JsxAttributes
      | JsxSpreadAttribute
      | JsxExpression
      | CaseClause
      | DefaultClause
      | HeritageClause
      | CatchClause
      | AssertClause
      | AssertEntry
      | PropertyAssignment
      | ShorthandPropertyAssignment
      | SpreadAssignment
      | EnumMember
      | UnparsedPrologue
      | UnparsedPrepend
      | UnparsedText
      | UnparsedInternalText
      | UnparsedSyntheticReference
      | SourceFile
      | Bundle
      | UnparsedSource
      | InputFiles
      | JSDocTypeExpression_FirstJSDocNode
      | JSDocNameReference
      | JSDocMemberName
      | JSDocAllType
      | JSDocUnknownType
      | JSDocNullableType
      | JSDocNonNullableType
      | JSDocOptionalType
      | JSDocFunctionType
      | JSDocVariadicType
      | JSDocNamepathType
      | JSDocComment
      | JSDocText
      | JSDocTypeLiteral
      | JSDocSignature
      | JSDocLink
      | JSDocLinkCode
      | JSDocLinkPlain
      | JSDocTag_FirstJSDocTagNode
      | JSDocAugmentsTag
      | JSDocImplementsTag
      | JSDocAuthorTag
      | JSDocDeprecatedTag
      | JSDocClassTag
      | JSDocPublicTag
      | JSDocPrivateTag
      | JSDocProtectedTag
      | JSDocReadonlyTag
      | JSDocOverrideTag
      | JSDocCallbackTag
      | JSDocEnumTag
      | JSDocParameterTag
      | JSDocReturnTag
      | JSDocThisTag
      | JSDocTypeTag
      | JSDocTemplateTag
      | JSDocTypedefTag
      | JSDocSeeTag
      | JSDocPropertyTag_LastJSDocNode_LastJSDocTagNode
      | SyntaxList
      | NotEmittedStatement
      | PartiallyEmittedExpression
      | CommaListExpression
      | MergeDeclarationMarker
      | EndOfDeclarationMarker
      | SyntheticReferenceExpression
      | Count
    type t_0 = t
    module Unknown = {
      open Unknown
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "Unknown"
    }
    module EndOfFileToken = {
      open EndOfFileToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "EndOfFileToken"
    }
    module SingleLineCommentTrivia = {
      open SingleLineCommentTrivia
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "SingleLineCommentTrivia"
    }
    module MultiLineCommentTrivia = {
      open MultiLineCommentTrivia
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "MultiLineCommentTrivia"
    }
    module NewLineTrivia = {
      open NewLineTrivia
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "NewLineTrivia"
    }
    module WhitespaceTrivia = {
      open WhitespaceTrivia
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "WhitespaceTrivia"
    }
    module ShebangTrivia = {
      open ShebangTrivia
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "ShebangTrivia"
    }
    module ConflictMarkerTrivia = {
      open ConflictMarkerTrivia
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "ConflictMarkerTrivia"
    }
    module NumericLiteral = {
      open NumericLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "NumericLiteral"
    }
    module BigIntLiteral = {
      open BigIntLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "BigIntLiteral"
    }
    module StringLiteral = {
      open StringLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "StringLiteral"
    }
    module JsxText = {
      open JsxText
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "JsxText"
    }
    module JsxTextAllWhiteSpaces = {
      open JsxTextAllWhiteSpaces
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "JsxTextAllWhiteSpaces"
    }
    module RegularExpressionLiteral = {
      open RegularExpressionLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "RegularExpressionLiteral"
    }
    module NoSubstitutionTemplateLiteral = {
      open NoSubstitutionTemplateLiteral
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "NoSubstitutionTemplateLiteral"
    }
    module TemplateHead = {
      open TemplateHead
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "TemplateHead"
    }
    module TemplateMiddle = {
      open TemplateMiddle
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "TemplateMiddle"
    }
    module TemplateTail = {
      open TemplateTail
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "TemplateTail"
    }
    module OpenBraceToken = {
      open OpenBraceToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "OpenBraceToken"
    }
    module CloseBraceToken = {
      open CloseBraceToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "CloseBraceToken"
    }
    module OpenParenToken = {
      open OpenParenToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "OpenParenToken"
    }
    module CloseParenToken = {
      open CloseParenToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "CloseParenToken"
    }
    module OpenBracketToken = {
      open OpenBracketToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "OpenBracketToken"
    }
    module CloseBracketToken = {
      open CloseBracketToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "CloseBracketToken"
    }
    module DotToken = {
      open DotToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "DotToken"
    }
    module DotDotDotToken = {
      open DotDotDotToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "DotDotDotToken"
    }
    module SemicolonToken = {
      open SemicolonToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "SemicolonToken"
    }
    module CommaToken = {
      open CommaToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "CommaToken"
    }
    module QuestionDotToken = {
      open QuestionDotToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "QuestionDotToken"
    }
    module LessThanToken = {
      open LessThanToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "LessThanToken"
    }
    module LessThanSlashToken = {
      open LessThanSlashToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "LessThanSlashToken"
    }
    module GreaterThanToken = {
      open GreaterThanToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "GreaterThanToken"
    }
    module LessThanEqualsToken = {
      open LessThanEqualsToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "LessThanEqualsToken"
    }
    module GreaterThanEqualsToken = {
      open GreaterThanEqualsToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "GreaterThanEqualsToken"
    }
    module EqualsEqualsToken = {
      open EqualsEqualsToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "EqualsEqualsToken"
    }
    module ExclamationEqualsToken = {
      open ExclamationEqualsToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "ExclamationEqualsToken"
    }
    module EqualsEqualsEqualsToken = {
      open EqualsEqualsEqualsToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "EqualsEqualsEqualsToken"
    }
    module ExclamationEqualsEqualsToken = {
      open ExclamationEqualsEqualsToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "ExclamationEqualsEqualsToken"
    }
    module EqualsGreaterThanToken = {
      open EqualsGreaterThanToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "EqualsGreaterThanToken"
    }
    module PlusToken = {
      open PlusToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "PlusToken"
    }
    module MinusToken = {
      open MinusToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "MinusToken"
    }
    module AsteriskToken = {
      open AsteriskToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "AsteriskToken"
    }
    module AsteriskAsteriskToken = {
      open AsteriskAsteriskToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "AsteriskAsteriskToken"
    }
    module SlashToken = {
      open SlashToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "SlashToken"
    }
    module PercentToken = {
      open PercentToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "PercentToken"
    }
    module PlusPlusToken = {
      open PlusPlusToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "PlusPlusToken"
    }
    module MinusMinusToken = {
      open MinusMinusToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "MinusMinusToken"
    }
    module LessThanLessThanToken = {
      open LessThanLessThanToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "LessThanLessThanToken"
    }
    module GreaterThanGreaterThanToken = {
      open GreaterThanGreaterThanToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "GreaterThanGreaterThanToken"
    }
    module GreaterThanGreaterThanGreaterThanToken = {
      open GreaterThanGreaterThanGreaterThanToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "GreaterThanGreaterThanGreaterThanToken"
    }
    module AmpersandToken = {
      open AmpersandToken
      type t = t
      type t0 = t
      @module("typescript") @scope("SyntaxKind") @val
      external value: t = "AmpersandToken"
    }
    module BarToken = {
      open BarToken
      type t = t
      type t0 = t
      @module("typescript") @scope

typescript.resi